@docknetwork/wallet-sdk-core 1.7.6 → 1.9.0

package/src/delegation/delegation-tree.test.ts

@@ -0,0 +1,110 @@
+import {delegationPolicyTravelAgent} from './delegation-fixtures';
+import {
+  buildDelegationRoleTree,
+  getRoleNodeById,
+  getRemainingDelegationDepth,
+} from './delegation-tree';
+
+describe('Delegation tree', () => {
+  it('builds a delegation tree from the delegation policy', () => {
+    const delegationTree = buildDelegationRoleTree(delegationPolicyTravelAgent);
+
+    expect(delegationTree).toMatchObject({
+      label: 'Travel Agent 1',
+      roleId: 'e79c0d16-8739-4e54-94d7-53d9f1c97c71',
+      level: 1,
+      children: [
+        {
+          label: 'Corporate Account Manager',
+          roleId: '8e5abc88-7006-42ae-ae48-9e34f8f66124',
+          level: 2,
+          children: [
+            {
+              label: 'Booking Specialist',
+              roleId: '6375baa1-a52d-4838-9100-3facea02ba49',
+              level: 3,
+            },
+            {
+              label: 'Hotel Sub-agent',
+              roleId: '16f68474-bf3b-4494-9fe5-f141a7d74a33',
+              level: 3,
+            },
+            {
+              label: 'Flight Sub-agent',
+              roleId: 'c1bd8821-c645-4dd6-ab07-9bc087755db9',
+              level: 3,
+            },
+          ],
+        },
+        {
+          label: 'Car Rental Sub-agent',
+          roleId: '9726317c-cb60-4ae7-a828-e334b10f6f52',
+          level: 2,
+          children: [
+            {
+              label: 'Flight Sub-agent',
+              roleId: '888aeee9-c3ed-469b-86bd-910490c9aa20',
+              level: 3,
+            },
+            {
+              label: 'Booking Executor',
+              roleId: 'd39f29c4-fc3e-4b5d-9eae-9f576576e4fb',
+              level: 3,
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  describe('getRoleNodeById', () => {
+    it('returns level 1 for the root role', () => {
+      const tree = buildDelegationRoleTree(delegationPolicyTravelAgent);
+      const node = getRoleNodeById(
+        'e79c0d16-8739-4e54-94d7-53d9f1c97c71',
+        tree,
+      );
+      expect(node?.level).toBe(1);
+    });
+
+    it('returns the level for nested roles', () => {
+      const tree = buildDelegationRoleTree(delegationPolicyTravelAgent);
+      expect(
+        getRoleNodeById('8e5abc88-7006-42ae-ae48-9e34f8f66124', tree)?.level,
+      ).toBe(2);
+      expect(
+        getRoleNodeById('6375baa1-a52d-4838-9100-3facea02ba49', tree)?.level,
+      ).toBe(3);
+    });
+
+    it('returns null for unknown roleId', () => {
+      const tree = buildDelegationRoleTree(delegationPolicyTravelAgent);
+      expect(getRoleNodeById('does-not-exist', tree)).toBeNull();
+    });
+  });
+
+  describe('getRemainingDelegationDepth', () => {
+    it('subtracts the role level from maxDelegationDepth', () => {
+      const tree = buildDelegationRoleTree(delegationPolicyTravelAgent);
+      const max =
+        delegationPolicyTravelAgent.ruleset.overallConstraints
+          .maxDelegationDepth;
+
+      const root = getRoleNodeById(
+        'e79c0d16-8739-4e54-94d7-53d9f1c97c71',
+        tree,
+      )!;
+      expect(getRemainingDelegationDepth(root, delegationPolicyTravelAgent)).toBe(
+        max - 1,
+      );
+
+      const leaf = getRoleNodeById(
+        '6375baa1-a52d-4838-9100-3facea02ba49',
+        tree,
+      )!;
+      expect(getRemainingDelegationDepth(leaf, delegationPolicyTravelAgent)).toBe(
+        max - 3,
+      );
+    });
+  });
+});

package/src/delegation/delegation-tree.ts

@@ -0,0 +1,60 @@
+import assert from 'assert';
+import {DelegationPolicy, RoleNode, Role} from './delegation-types';
+
+/**
+ * Build a tree structure representing the roles in a delegation policy, based on their parent-child relationships
+ * @param policy - The delegation policy containing the roles and their relationships
+ * @returns A tree structure representing the roles in the delegation policy, where each node contains the role name, roleId, level in the hierarchy, and its children roles (if any)
+ */
+export function buildDelegationRoleTree(policy: DelegationPolicy): RoleNode {
+  const root = policy.ruleset.roles.find(r => r.parentRoleId === null);
+  assert(root, 'Delegation policy has no root role');
+
+  const childrenByParent = new Map<string, Role[]>();
+  for (const role of policy.ruleset.roles) {
+    if (role.parentRoleId === null) continue;
+    const siblings = childrenByParent.get(role.parentRoleId) ?? [];
+    siblings.push(role);
+    childrenByParent.set(role.parentRoleId, siblings);
+  }
+
+  const toNode = (role: Role, level: number): RoleNode => {
+    const children = childrenByParent.get(role.roleId);
+    const node: RoleNode = {level, ...role};
+    if (children?.length) {
+      node.children = children.map(c => toNode(c, level + 1));
+    }
+    return node;
+  };
+
+  return toNode(root, 1);
+}
+
+export function getRoleNodeById(
+  roleId: string,
+  node: RoleNode,
+): RoleNode | null {
+  if (node.roleId === roleId) return node;
+  if (!node.children) return null;
+
+  for (const child of node.children) {
+    const result = getRoleNodeById(roleId, child);
+    if (result) return result;
+  }
+
+  return null;
+}
+
+/**
+ * Compute how many more times the holder of `roleId` may further delegate,
+ * based on the policy's maxDelegationDepth and the holder's depth in the tree.
+ * @param policy - The delegation policy
+ * @param roleId - The roleId of the holder
+ * @returns The remaining delegation depth, or null if the role is not in the policy
+ */
+export function getRemainingDelegationDepth(
+  roleNode: RoleNode,
+  policy: DelegationPolicy,
+): number | null {
+  return policy.ruleset.overallConstraints.maxDelegationDepth - roleNode.level;
+}

package/src/delegation/delegation-types.ts

@@ -0,0 +1,65 @@
+import {Credential} from '../credential-provider';
+
+export type JsonSchema = Record<string, unknown>;
+
+export type CapabilityGrant = {
+  capability: string;
+  schema: JsonSchema;
+};
+
+export type Capability = {
+  name: string;
+  schema: JsonSchema;
+};
+
+export type Role = {
+  label: string;
+  roleId: string;
+  attributes: string[];
+  parentRoleId: string | null;
+  capabilityGrants: CapabilityGrant[];
+};
+
+export type DelegatedCredentialLifetime = {
+  unit: string;
+  value: number;
+};
+
+export type OverallConstraints = {
+  maxDelegationDepth: number;
+  delegatedCredentialLifetime: DelegatedCredentialLifetime;
+};
+
+export type Ruleset = {
+  roles: Role[];
+  capabilities: Capability[];
+  delegationTarget: string;
+  overallConstraints: OverallConstraints;
+};
+
+export type DelegationPolicy = {
+  id: string;
+  type: 'DelegationPolicy';
+  ruleset: Ruleset;
+  createdAt: string;
+  name?: string;
+};
+
+export type RoleNode = Role & {
+  level: number;
+  children?: RoleNode[];
+};
+
+export type DelegationDetails = {
+  delegationPolicy: DelegationPolicy | null;
+  delegationChain: Credential[];
+  delegatedBy: {
+    role: Role | null;
+    issuerName: string;
+    issuerDid: string;
+  };
+  role: RoleNode | null;
+  roleTree: RoleNode | null;
+  remainingDelegationDepth: number | null;
+  delegationOptions: RoleNode[];
+};

package/src/delegation/delegation-utils.ts

@@ -0,0 +1,10 @@
+import {CapabilityGrant} from './delegation-types';
+
+export const DELEGATION_CONTEXT = 'https://ld.truvera.io/credentials/delegation';
+
+export function isDelegatableCredential(credential): boolean {
+  return (
+    Array.isArray(credential?.['@context']) &&
+    credential['@context'].includes(DELEGATION_CONTEXT)
+  );
+}

package/src/did-provider.ts

@@ -174,7 +174,7 @@ export async function createDIDKey({wallet, name, derivePath=undefined, type=und
  * Internal function to retrieve all DIDs stored in the wallet
  * @private
  */
-export async function getAll({wallet}) {
+export async function getAllDIDs({wallet}) {
   assert(!!wallet, 'wallet is required');
   const dids = await wallet.getDocumentsByType('DIDResolutionResponse');
   return dids;
@@ -186,20 +186,24 @@ export async function getAll({wallet}) {
  */
 export async function getDefaultDID({wallet}) {
   assert(!!wallet, 'wallet is required');
-  const allDids = await getAll({ wallet });
+  const allDids = await getAllDIDs({ wallet });
   return allDids[0]?.didDocument.id;
 }
 
+export async function getDIDKeyPair(wallet, didDoc) {
+  return wallet.getDocumentById(didDoc.correlation[0])
+}
+
 /**
  * Internal function to retrieve all keypairs associated with DIDs
  * @private
  */
 export async function getDIDKeyPairs({wallet}) {
   assert(!!wallet, 'wallet is required');
-  const didDocs = await getAll({wallet});
+  const didDocs = await getAllDIDs({wallet});
   const keyPairs = [];
   for (const didDoc of didDocs) {
-    const keyPair = await wallet.getDocumentById(didDoc.correlation[0]);
+    const keyPair = await getDIDKeyPair(wallet, didDoc);
     keyPairs.push(keyPair);
   }
   return keyPairs;
@@ -208,7 +212,7 @@ export async function getDIDKeyPairs({wallet}) {
 
 export async function ensureDID({wallet}) {
   assert(!!wallet, 'wallet is required');
-  const dids = await getAll({wallet});
+  const dids = await getAllDIDs({wallet});
   if (dids.length === 0) {
     return createDIDKey({wallet, name: 'Default DID'});
   }
@@ -335,7 +339,7 @@ export function createDIDProvider({wallet}): IDIDProvider {
      * console.log(`Found ${allDIDs.length} DIDs in wallet`);
      */
     async getAll() {
-      return getAll({wallet});
+      return getAllDIDs({wallet});
     },
     /**
      * Retrieves all keypairs associated with DIDs in the wallet

package/src/globals.d.ts

@@ -0,0 +1,6 @@
+// CryptoKey is available globally in Node.js 15+ but TypeScript needs
+// the DOM lib to recognize it. Declare it here to avoid pulling in all DOM types.
+declare global {
+  type CryptoKey = import('crypto').webcrypto.CryptoKey;
+}
+export {};

package/src/message-provider.ts

@@ -151,7 +151,6 @@ export function createMessageProvider({
 
   async function fetchMessages() {
     try {
-      logger.debug('Fetching messages');
       const fetchMessagesStartTime = Date.now();
       const keyPairDocs = await getKeyPairDocs(didProvider);
       let encryptedMessages = await relayService.getMessages({
@@ -227,6 +226,7 @@ export function createMessageProvider({
 
       return encryptedMessages;
     } catch (error) {
+      logger.error(`Failed to fetch messages: ${error.message}`);
       captureException(error);
       throw new Error(`Failed to fetch messages: ${error.message}`);
     }

package/src/verification-controller.test.ts

@@ -90,6 +90,29 @@ describe('Verification provider', () => {
     expect(result.isValid).toBe(true);
   });
 
+  it('expect to create a default presentation using filtered credentials', async () => {
+    const controller = createVerificationController({
+      wallet,
+      didProvider,
+    });
+
+    await controller.start({
+      template: anyCredentialProofRequest,
+    });
+
+    const credentials = controller.getFilteredCredentials();
+
+    const presentation = await controller.createDefaultPresentation();
+
+    expect(presentation.credentials[0]).toStrictEqual(credentials[0]);
+    expect(presentation.type).toEqual(['VerifiablePresentation']);
+
+    // validate the presentation
+    const result = await controller.evaluatePresentation(presentation);
+
+    expect(result.isValid).toBe(true);
+  });
+
   it('expect to generate presentation iiw credential', async () => {
     const controller = createVerificationController({
       wallet,