feat: delegation.toJSON (#186)

* fix: toJSON behavior on the ucan.data

* feat: delegation to-json

package.json

@@ -23,7 +23,7 @@
   "devDependencies": {
     "mocha": "^10.1.0",
     "prettier": "2.7.1",
-    "typescript": "4.8.3"
+    "typescript": "^4.8.4"
   },
   "prettier": {
     "trailingComma": "es5",

packages/core/src/delegation.js

@@ -130,6 +130,19 @@ export class Delegation {
   iterate() {
     return it(this)
   }
+
+  /**
+   * @returns {API.DelegationJSON<this>}
+   */
+  toJSON() {
+    return /** @type {any} */ ({
+      ...this.data.toJSON(),
+      '/': this.cid.toString(),
+      prf: this.proofs.map(proof =>
+        isDelegation(proof) ? proof : { '/': proof.toString() }
+      ),
+    })
+  }
 }
 
 /**

packages/core/test/delegation.spec.js

@@ -1,6 +1,6 @@
 import { assert, test } from './test.js'
-import { Delegation, UCAN, isDelegation, parseLink } from '../src/lib.js'
-import { alice, bob, mallory, service } from './fixtures.js'
+import { Delegation, UCAN, delegate, parseLink } from '../src/lib.js'
+import { alice, bob, mallory, service as w3 } from './fixtures.js'
 import { base64 } from 'multiformats/bases/base64'
 const utf8 = new TextEncoder()
 
@@ -132,3 +132,120 @@ test('delegation.data.toJSON with bytes', async () => {
     s: { '/': { bytes: base64.baseEncode(ucan.signature) } },
   })
 })
+
+test('toJSON delegation', async () => {
+  const ucan = await delegate({
+    issuer: alice,
+    audience: w3,
+    capabilities: [
+      {
+        with: alice.did(),
+        can: 'test/echo',
+        nb: {
+          message: 'data:1',
+        },
+      },
+    ],
+    expiration: Infinity,
+  })
+
+  assert.deepEqual(toJSON(ucan), {
+    '/': ucan.cid.toString(),
+    v: ucan.version,
+    iss: alice.did(),
+    aud: w3.did(),
+    att: [
+      {
+        nb: {
+          message: 'data:1',
+        },
+        can: 'test/echo',
+        with: alice.did(),
+      },
+    ],
+    exp: null,
+    prf: [],
+    s: {
+      '/': { bytes: base64.baseEncode(ucan.signature) },
+    },
+  })
+})
+
+test('toJSON delegation chain', async () => {
+  const proof = await delegate({
+    issuer: bob,
+    audience: alice,
+    capabilities: [
+      {
+        with: bob.did(),
+        can: 'test/echo',
+      },
+    ],
+  })
+
+  const proof2 = await delegate({
+    issuer: mallory,
+    audience: alice,
+    capabilities: [
+      {
+        with: mallory.did(),
+        can: 'test/echo',
+      },
+    ],
+  })
+
+  const ucan = await delegate({
+    issuer: alice,
+    audience: w3,
+    capabilities: [
+      {
+        with: bob.did(),
+        can: 'test/echo',
+        nb: {
+          message: 'data:hi',
+        },
+      },
+    ],
+    proofs: [proof, proof2.cid],
+  })
+
+  assert.deepEqual(toJSON(ucan), {
+    '/': ucan.cid.toString(),
+    v: ucan.version,
+    iss: alice.did(),
+    aud: w3.did(),
+    att: [
+      {
+        with: bob.did(),
+        can: 'test/echo',
+        nb: {
+          message: 'data:hi',
+        },
+      },
+    ],
+    exp: ucan.expiration,
+    prf: [
+      {
+        '/': proof.cid.toString(),
+        iss: bob.did(),
+        aud: alice.did(),
+        att: [
+          {
+            with: bob.did(),
+            can: 'test/echo',
+          },
+        ],
+        exp: proof.expiration,
+        v: proof.version,
+        s: { '/': { bytes: base64.baseEncode(proof.signature) } },
+        prf: [],
+      },
+      {
+        '/': proof2.cid.toString(),
+      },
+    ],
+    s: {
+      '/': { bytes: base64.baseEncode(ucan.signature) },
+    },
+  })
+})

packages/interface/src/lib.ts

@@ -17,8 +17,13 @@ import {
   Principal,
   MulticodecCode,
   SigAlg,
+  ToJSON,
+  SignatureJSON,
+  JSONUnknown,
+  IntoJSON,
+  JSONObject,
 } from '@ipld/dag-ucan'
-import { Link, Block as IPLDBlock } from 'multiformats'
+import { Link, UnknownLink, Block as IPLDBlock, ToString } from 'multiformats'
 import * as UCAN from '@ipld/dag-ucan'
 import {
   CanIssue,
@@ -59,6 +64,10 @@ export type {
   MultibaseEncoder,
   MulticodecCode,
   Principal,
+  ToJSON,
+  ToString,
+  UnknownLink,
+  JSONUnknown,
 }
 export * as UCAN from '@ipld/dag-ucan'
 
@@ -161,8 +170,39 @@ export interface Delegation<C extends Capabilities = Capabilities> {
   iterate(): IterableIterator<Delegation>
 
   signature: Signature
+  version: UCAN.Version
+
+  toJSON(): DelegationJSON<this>
 }
 
+export type DelegationJSON<T extends Delegation = Delegation> = ToJSON<
+  T,
+  {
+    '/': ToString<T['cid']>
+    v: T['version']
+    iss: DID
+    aud: DID
+    att: ToJSON<
+      T['capabilities'],
+      T['capabilities'] &
+        UCAN.Tuple<{ with: UCAN.Resource; can: UCAN.Ability; nb?: JSONObject }>
+    >
+    exp: T['expiration']
+    nbf?: T['notBefore'] & {}
+    nnc?: T['nonce'] & {}
+    fct: ToJSON<T['facts']>
+    prf: ProofJSON[] & JSONUnknown[]
+    s: SignatureJSON<T['signature']>
+  }
+>
+
+export type ProofJSON = DelegationJSON | LinkJSON<UCANLink>
+
+export type LinkJSON<T extends UnknownLink = UnknownLink> = ToJSON<
+  T,
+  { '/': ToString<T> }
+>
+
 /**
  * An Invocation represents a UCAN that can be presented to a service provider to
  * invoke or "exercise" a {@link Capability}. You can think of invocations as a