feat!: implement receipts

.gitignore

@@ -6,3 +6,4 @@ node_modules
 coverage
 .pnpm-debug.log
 .env
+.vscode

packages/client/package.json

@@ -30,12 +30,11 @@
   },
   "dependencies": {
     "@ucanto/interface": "workspace:^",
-    "multiformats": "^11.0.0"
+    "@ucanto/core": "workspace:^"
   },
   "devDependencies": {
     "@types/chai": "^4.3.3",
     "@types/mocha": "^10.0.1",
-    "@ucanto/core": "workspace:^",
     "@ucanto/principal": "workspace:^",
     "@ucanto/transport": "workspace:^",
     "@web-std/fetch": "^4.1.0",

packages/client/src/connection.js

@@ -1,5 +1,5 @@
 import * as API from '@ucanto/interface'
-import { sha256 } from 'multiformats/hashes/sha2'
+import { Receipt, Signature, sha256 } from '@ucanto/core'
 
 /**
  * Creates a connection to a service.
@@ -8,7 +8,7 @@ import { sha256 } from 'multiformats/hashes/sha2'
  * @param {API.ConnectionOptions<T>} options
  * @returns {API.ConnectionView<T>}
  */
-export const connect = (options) => new Connection(options)
+export const connect = options => new Connection(options)
 
 /**
  * @template {Record<string, any>} T
@@ -21,8 +21,7 @@ class Connection {
   constructor(options) {
     this.id = options.id
     this.options = options
-    this.encoder = options.encoder
-    this.decoder = options.decoder
+    this.codec = options.codec
     this.channel = options.channel
     this.hasher = options.hasher || sha256
   }
@@ -41,12 +40,46 @@ class Connection {
  * @template {Record<string, any>} T
  * @template {API.Tuple<API.ServiceInvocation<C, T>>} I
  * @param {API.Connection<T>} connection
- * @param {I} invocations
- * @returns {Promise<API.InferServiceInvocations<I, T>>}
+ * @param {I} workflow
+ * @returns {Promise<API.InferWorkflowReceipts<I, T>>}
  */
-export const execute = async (invocations, connection) => {
-  const request = await connection.encoder.encode(invocations, connection)
+export const execute = async (workflow, connection) => {
+  const request = await connection.codec.encode(workflow, connection)
   const response = await connection.channel.request(request)
-  const result = await connection.decoder.decode(response)
-  return result
+  // We may fail to decode the response if content type is not supported
+  // or if data was corrupted. We do not want to throw in such case however,
+  // because client will get an Error object as opposed to a receipt, to retain
+  // consistent client API with two kinds of errors we encode caught error as
+  // a receipts per workflow invocation.
+  try {
+    return await connection.codec.decode(response)
+  } catch (error) {
+    // No third party code is run during decode and we know
+    // we only throw an Error
+    const { message, ...cause } = /** @type {Error} */ (error)
+    const receipts = []
+    for await (const invocation of workflow) {
+      const { cid } = await invocation.delegate()
+      const receipt = await Receipt.issue({
+        ran: cid,
+        result: { error: { ...cause, message } },
+        // @ts-expect-error - we can not really sign a receipt without having
+        // an access to a signer which client does not have. In the future
+        // we will change client API requiring a signer to be passed in but
+        // for now we just use a dummy signer.
+        issuer: {
+          did() {
+            return connection.id.did()
+          },
+          sign() {
+            return Signature.createNonStandard('', new Uint8Array())
+          },
+        },
+      })
+
+      receipts.push(receipt)
+    }
+
+    return /** @type {any} */ (receipts)
+  }
 }

packages/client/test/api.ts

@@ -133,16 +133,16 @@ export interface AccessProvider {
    * Associates a DID with another DID in the system. If there is no account
    * associated with a `to` DID will produce an error.
    */
-  link(member: DID, group: DID, proof: Link): Result<null, UnknownDIDError>
+  link(member: DID, group: DID, proof: Link): Result<{}, UnknownDIDError>
 
-  unlink(member: DID, group: DID, proof: Link): Result<null, UnknownDIDError>
+  unlink(member: DID, group: DID, proof: Link): Result<{}, UnknownDIDError>
 
   /**
    * Associates new child DID with an accound of the parent DID. If there is no
    * account associated with a parent it creates account with `parent` did first
    * and then associates child DID with it.
    */
-  register(member: DID, group: DID, proof: Link): Result<null, UnknownDIDError>
+  register(member: DID, group: DID, proof: Link): Result<{}, UnknownDIDError>
 
   /**
    * Resolves account DID associated with a given DID. Returns either account