@docknetwork/wallet-sdk-wasm 1.7.0 → 1.7.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.7.0",
+    "version": "1.7.6",
     "license": "https://github.com/docknetwork/wallet-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -18,34 +18,42 @@
         "p-limit": "2.3.0"
     },
     "dependencies": {
-        "p-limit": "2.3.0",
         "@astronautlabs/jsonpath": "^1.1.2",
-        "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/wallet-sdk-dids": "^1.7.0",
+        "@cedar-policy/cedar-wasm": "^4.5.0",
         "@cosmjs/proto-signing": "^0.32.4",
-        "@docknetwork/cheqd-blockchain-api": "4.0.5",
-        "@docknetwork/cheqd-blockchain-modules": "4.0.6",
-        "@scure/bip39": "^1.6.0",
+        "@docknetwork/cheqd-blockchain-api": "4.1.1",
+        "@docknetwork/cheqd-blockchain-modules": "4.0.8",
+        "@docknetwork/credential-sdk": "0.54.16",
+        "@docknetwork/universal-wallet": "^2.0.1",
+        "@docknetwork/vc-delegation-engine": "1.0.3",
+        "@docknetwork/wallet-sdk-dids": "^1.7.6",
         "@noble/hashes": "1.8.0",
-        "@docknetwork/credential-sdk": "0.54.9",
-        "@sphereon/oid4vci-client": "^0.16.0",
-        "@sphereon/oid4vci-common": "^0.16.0",
+        "@scure/bip39": "^1.6.0",
         "@sd-jwt/crypto-nodejs": "^0.15.0",
         "@sd-jwt/sd-jwt-vc": "^0.15.1",
-        "base64url": "^3.0.1",
+        "@sphereon/oid4vci-client": "^0.16.0",
+        "@sphereon/oid4vci-common": "^0.16.0",
+        "@sphereon/pex": "^1.1.4",
         "axios": "^0.25.0",
+        "axios-retry": "^3.2.5",
+        "base64url": "^3.0.1",
+        "cwait": "1.1.2",
+        "futoin-hkdf": "^1.5.3",
         "json-rpc-2.0": "^0.2.16",
+        "jsonld": "^6.0.0",
+        "p-limit": "2.3.0",
         "uuid": "^8.3.2",
-        "winston": "^3.3.3",
-        "cwait": "1.1.2",
-        "axios-retry": "^3.2.5",
-        "@sphereon/pex": "^1.1.4"
+        "winston": "^3.3.3"
     },
     "devDependencies": {
         "@babel/node": "^7.16.0",
-        "sinon": "^12.0.1",
         "jest": "29.6.1",
+        "sinon": "^12.0.1",
         "ts-jest": "29.1.0",
         "typescript": "^5.0.4"
+    },
+    "overrides": {
+        "@digitalbazaar/http-client": "^3.4.1",
+        "base58-universal": "2.0.0"
     }
 }

package/rollup.config.mjs

@@ -1,14 +1,16 @@
 import json from '@rollup/plugin-json';
-import multiInput from 'rollup-plugin-multi-input';
+import _multiInput from 'rollup-plugin-multi-input';
 import commonjs from '@rollup/plugin-commonjs';
 import flow from 'rollup-plugin-flow';
 import typescript from '@rollup/plugin-typescript';
 
+const multiInput = _multiInput.default || _multiInput;
+
 export default async function () {
   return [
     {
       plugins: [
-        multiInput.default(),
+        multiInput(),
         json(),
         flow({
           all: true,
@@ -17,7 +19,7 @@ export default async function () {
         commonjs(),
         typescript(),
       ],
-      input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js'],
+      input: ['src/**/*.ts', 'src/**/*.js', '!src/**/*.test.ts', '!src/**/*.test.js', '!src/**/*.d.ts'],
       output: [
         {
           dir: 'lib',

package/src/globals.d.ts

@@ -0,0 +1,3 @@
+// 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.
+type CryptoKey = import('crypto').webcrypto.CryptoKey;

package/src/modules/network-manager.ts

@@ -3,35 +3,36 @@ import assert from 'assert';
 
 export type NetworkInfo = {
   name: string,
-  substrateUrl: string | string[],
-  addressPrefix: number,
-  cheqdApiUrl: string,
+  cheqdApiUrl: string | string[],
 };
 
 export type NetworkId = 'mainnet' | 'testnet' | 'local' | 'custom';
 
-export const SUBSTRATE_NETWORKS : Record<NetworkId, NetworkInfo> = {
+export const BLOCKCHAIN_NETWORKS : Record<NetworkId, NetworkInfo> = {
   mainnet: {
     name: 'Cheqd Mainnet',
-    substrateUrl: null,
-    addressPrefix: 22,
-    cheqdApiUrl: 'https://mainnet.cheqd.docknode.io',
+    cheqdApiUrl: [
+      'https://mainnet.cheqd.docknode.io',
+      'https://rpc.cheqd.net',
+    ],
   },
   testnet: {
     name: 'Cheqd Testnet',
-    substrateUrl: null,
-    addressPrefix: 21,
-    cheqdApiUrl: 'https://testnet.cheqd.docknode.io',
+    cheqdApiUrl: [
+      'https://testnet.cheqd.docknode.io',
+      'https://api.cheqd.network',
+    ],
   },
   local: {
     name: 'Local Node',
-    substrateUrl: 'ws://127.0.0.1:9944',
-    addressPrefix: 21,
+    cheqdApiUrl: [
+      'http://localhost:8080',
+    ],
   },
 };
 
 function getNetworkInfo(networkId): NetworkInfo {
-  const networkInfo = SUBSTRATE_NETWORKS[networkId];
+  const networkInfo = BLOCKCHAIN_NETWORKS[networkId];
 
   assert(!!networkInfo, `Network ${networkId} not found`);
 
@@ -57,7 +58,7 @@ export class NetworkManager {
    * @param {string} networkId
    */
   setNetworkId(networkId: NetworkId) {
-    assert(!!SUBSTRATE_NETWORKS[networkId], `invalid networkId ${networkId}`);
+    assert(!!BLOCKCHAIN_NETWORKS[networkId], `invalid networkId ${networkId}`);
 
     this.networkId = networkId;
   }

package/src/services/blockchain/configs.ts

@@ -4,8 +4,7 @@ import assert from 'assert';
 export const validation = {};
 
 export type InitParams = {
-  substrateUrl: string,
-  cheqdApiUrl?: string,
+  cheqdApiUrl?: string | string[],
   networkId?: string,
   cheqdMnemonic?: string,
 };

package/src/services/blockchain/service.ts

@@ -60,7 +60,11 @@ export class BlockchainService {
   cheqdApi;
   cheqdApiUrl;
   isBlockchainReady = false;
-  resolver: any;
+  private _resolver: any;
+
+  get resolver(): any {
+    return this._resolver;
+  }
   /**
    * Event names emitted by the blockchain service
    * @static
@@ -93,7 +97,8 @@ export class BlockchainService {
     this.cheqdModules = new CheqdCoreModules(this.cheqdApi);
     this.modules = new MultiApiCoreModules([this.cheqdModules]);
     this.emitter = new EventEmitter();
-    this.resolver = this.createDIDResolver();
+    // Blockchain is not ready yet, but we can use fallback resolvers
+    this._resolver = this.createDIDResolver();
   }
 
   /**
@@ -161,12 +166,21 @@ export class BlockchainService {
    * @private
    * @returns {CachedDIDResolver} Cached DID resolver instance
    */
-  createDIDResolver() {
-    const router = new AnyDIDResolver([
-      new DIDKeyResolver(),
-      new CoreResolver(this.modules),
+  createDIDResolver(isBlockchainReady: boolean) {
+    let resolvers = [
       new UniversalResolver(universalResolverUrl),
-    ]);
+      new DIDKeyResolver(),
+    ]
+
+    // Add blockchain resolvers if the blockchain is ready
+    if (isBlockchainReady) {
+      resolvers = [
+        new CoreResolver(this.modules),
+        ...resolvers
+      ]
+    }
+
+    const router = new AnyDIDResolver(resolvers);
 
     return new CachedDIDResolver(router);
   }
@@ -217,16 +231,18 @@ export class BlockchainService {
     try {
       await this.cheqdApi.init({
         wallet,
-        url: checkdApiUrl,
+        urls: Array.isArray(checkdApiUrl) ? checkdApiUrl : [checkdApiUrl],
         network: cheqdNetworkId,
       });
       Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
     } catch (err) {
+      debugger
       Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`, err);
     }
 
 
-    this.resolver = this.createDIDResolver();
+    // Re-create the resolver with the new blockchain connection
+    this._resolver = this.createDIDResolver(true);
 
     if (
       process.env.NODE_ENV !== 'test' ||
@@ -299,7 +315,7 @@ export class BlockchainService {
    * @example
    * const apiUrl = await blockchainService.getAddress();
    */
-  async getAddress() {
+  async getAddress(): Promise<string | string[]> {
     return this.cheqdApiUrl;
   }
 

package/src/services/credential/bound-check.ts

@@ -107,7 +107,7 @@ export function blobFromBase64(base64String: string): Uint8Array {
     /^data:application\/octet-stream;base64,/,
     '',
   );
-  return base64url.toBuffer(cleanedBase64);
+  return new Uint8Array(base64url.toBuffer(cleanedBase64));
 }
 
 export async function isBase64OrDataUrl(str: string): Promise<boolean> {

package/src/services/credential/delegatable-credentials.ts

@@ -0,0 +1,409 @@
+// @ts-nocheck
+import * as cedar from '@cedar-policy/cedar-wasm/nodejs';
+import {
+  verifyPresentation,
+  issueCredential,
+  signPresentation,
+  documentLoader,
+  getSuiteFromKeyDoc,
+} from '@docknetwork/credential-sdk/vc';
+import { MAY_CLAIM_IRI } from '@docknetwork/vc-delegation-engine';
+import { getKeypairFromDoc } from '@docknetwork/universal-wallet/methods/keypairs';
+import { blockchainService } from '../blockchain/service';
+
+/**
+ * Prepares a key document for signing by creating a proper keypair with signer capability
+ * @param keyDoc - The key document with id, controller, type, and key material
+ * @returns A key document with an active signer
+ */
+function prepareKeyForSigning(keyDoc: KeyPair): any {
+  const kp = getKeypairFromDoc(keyDoc);
+  // Get the signer from the keypair - this returns an object with id and sign method
+  const signer = kp.signer();
+  // Set the id on the signer to match the verification method
+  signer.id = keyDoc.id;
+  return {
+    ...keyDoc,
+    keypair: kp,
+    signer,
+  };
+}
+
+export interface VerificationResult {
+  verified: boolean;
+  credentialResults?: any[];
+  delegationResult?: {
+    decision: string;
+    summaries?: any[];
+    authorizations?: any[];
+    failures?: any[];
+  };
+  error?: any;
+}
+
+export interface CedarPolicies {
+  staticPolicies: string;
+}
+
+export interface VerifiablePresentation {
+  '@context': any[];
+  type: string[];
+  proof?: any;
+  verifiableCredential?: any[];
+}
+
+export interface DelegationCredential {
+  '@context': any[];
+  id: string;
+  type: string[];
+  issuer: string;
+  issuanceDate: string;
+  previousCredentialId: string | null;
+  rootCredentialId: string;
+  credentialSubject: {
+    id: string;
+    [key: string]: any;
+  };
+  proof?: any;
+}
+
+export interface VerifyDelegationOptions {
+  challenge?: string;
+  domain?: string;
+  unsignedPresentation?: boolean;
+  failOnUnauthorizedClaims?: boolean;
+  policies?: CedarPolicies;
+}
+
+export interface KeyPair {
+  type: string;
+  id?: string;
+  controller?: string;
+  publicKeyJwk?: any;
+  privateKeyJwk?: any;
+  publicKeyBase58?: string;
+  privateKeyBase58?: string;
+}
+
+/**
+ * W3C Credentials V1 context URL
+ */
+export const W3C_CREDENTIALS_V1 = 'https://www.w3.org/2018/credentials/v1';
+
+/**
+ * Re-export MAY_CLAIM_IRI for use in credentials
+ */
+export { MAY_CLAIM_IRI };
+
+/**
+ * Namespace used by the vc-delegation-engine for delegation properties
+ */
+export const DELEGATION_ENGINE_NS = 'https://ld.truvera.io/credentials/delegation#';
+
+/**
+ * Base delegation context terms required for delegation credentials.
+ * These terms define the JSON-LD mappings needed for the vc-delegation-engine
+ * to properly process delegation chains.
+ *
+ * Use this as a base and extend with your own application-specific terms:
+ * @example
+ * const myContext = [
+ *   W3C_CREDENTIALS_V1,
+ *   {
+ *     ...DELEGATION_CONTEXT_TERMS,
+ *     // Add your custom terms here
+ *     MyCredentialType: 'https://example.org/MyCredentialType',
+ *     myField: 'https://example.org/myField',
+ *   },
+ * ];
+ */
+export const DELEGATION_CONTEXT_TERMS = {
+  '@version': 1.1,
+  '@protected': true,
+  DelegationCredential: `${DELEGATION_ENGINE_NS}DelegationCredential`,
+  mayClaim: { '@id': MAY_CLAIM_IRI, '@container': '@set' },
+  rootCredentialId: { '@id': `${DELEGATION_ENGINE_NS}rootCredentialId`, '@type': '@id' },
+  previousCredentialId: { '@id': `${DELEGATION_ENGINE_NS}previousCredentialId`, '@type': '@id' },
+};
+
+/**
+ * Default context for verifiable presentations
+ */
+export const PRESENTATION_CONTEXT = [W3C_CREDENTIALS_V1];
+
+/**
+ * Issues a delegation credential that grants authority to a delegate
+ * @param keyPair - The key pair to sign the credential
+ * @param params - Delegation parameters
+ * @returns Signed delegation credential
+ */
+export async function issueDelegationCredential(
+  keyPair: KeyPair,
+  credential: any
+): Promise<DelegationCredential> {
+  const preparedKey = prepareKeyForSigning(keyPair);
+  return issueCredential(preparedKey, credential);
+}
+
+/**
+ * Issues a credential as a delegate (with delegation chain reference)
+ * @param keyPair - The delegate's key pair to sign the credential
+ * @param params - Credential parameters
+ * @returns Signed credential
+ */
+export async function issueDelegatedCredential(
+  keyPair: KeyPair,
+  credential: any
+): Promise<any> {
+  const preparedKey = prepareKeyForSigning(keyPair);
+  return issueCredential(preparedKey, credential);
+}
+
+/**
+ * Creates and signs a verifiable presentation with delegation credentials
+ * @param keyPair - The key pair to sign the presentation
+ * @param params - Presentation parameters
+ * @returns Signed verifiable presentation
+ */
+export async function createSignedPresentation(
+  keyPair: KeyPair,
+  params: {
+    credentials: any[];
+    holderDid: string;
+    challenge: string;
+    domain: string;
+    context?: any[];
+  }
+): Promise<VerifiablePresentation> {
+  const {
+    credentials,
+    holderDid,
+    challenge,
+    domain,
+    context = PRESENTATION_CONTEXT,
+  } = params;
+
+  const presentation = {
+    '@context': context,
+    type: ['VerifiablePresentation'],
+    holder: holderDid,
+    verifiableCredential: credentials,
+  };
+
+  // Create key document for signing with proper keypair
+  const keyDoc = {
+    ...keyPair,
+    id: keyPair.id || `${holderDid}#keys-1`,
+    controller: keyPair.controller || holderDid,
+  };
+
+  const preparedKey = prepareKeyForSigning(keyDoc);
+  return signPresentation(presentation, preparedKey, challenge, domain);
+}
+
+/**
+ * Verifies a verifiable presentation with optional delegation chain validation
+ * Uses the credential-sdk's verifyPresentation which automatically:
+ * 1. Verifies the presentation signature
+ * 2. Verifies all credentials
+ * 3. Detects delegation credentials
+ * 4. Validates the delegation chain
+ * 5. Applies Cedar policies if provided
+ *
+ * @param vp - The verifiable presentation to verify
+ * @param options - Verification options
+ * @returns Verification result with delegation info if applicable
+ */
+export async function verifyDelegatablePresentation(
+  vp: VerifiablePresentation,
+  options: VerifyDelegationOptions = {}
+): Promise<VerificationResult> {
+  const {
+    challenge = vp.proof?.challenge || 'default-challenge',
+    domain = vp.proof?.domain || 'default-domain',
+    unsignedPresentation = false,
+    failOnUnauthorizedClaims = true,
+    policies,
+  } = options;
+
+  const verifyOptions: any = {
+    challenge,
+    domain,
+    documentLoader: documentLoader(blockchainService.resolver),
+    unsignedPresentation,
+    failOnUnauthorizedClaims,
+  };
+
+  // Add Cedar authorization if policies are provided
+  if (policies) {
+    verifyOptions.cedarAuth = {
+      policies,
+      cedar,
+    };
+  }
+
+  return verifyPresentation(vp, verifyOptions);
+}
+
+/**
+ * Creates a Cedar policy for delegation verification
+ * @param config - Policy configuration
+ * @returns Cedar policy object
+ */
+export function createCedarPolicy(config: {
+  maxDepth?: number;
+  rootIssuer: string;
+  requiredClaims?: Record<string, any>;
+}): CedarPolicies {
+  const { maxDepth = 2, rootIssuer, requiredClaims = {} } = config;
+
+  let claimsConditions = '';
+  for (const [key, value] of Object.entries(requiredClaims)) {
+    if (typeof value === 'number') {
+      claimsConditions += ` &&\n  context.authorizedClaims.${key} >= ${value}`;
+    } else if (typeof value === 'string') {
+      claimsConditions += ` &&\n  context.authorizedClaims.${key} == "${value}"`;
+    }
+  }
+
+  const policyText = `
+permit(
+  principal in Credential::Chain::"Action:Verify",
+  action == Credential::Action::"Verify",
+  resource
+) when {
+  principal == context.vpSigner &&
+  context.tailDepth <= ${maxDepth} &&
+  context.rootIssuer == Credential::Actor::"${rootIssuer}"${claimsConditions}
+};
+`;
+
+  return { staticPolicies: policyText };
+}
+
+/**
+ * Creates an unsigned verifiable presentation (for testing)
+ * @param credentials - Array of credentials to include
+ * @param proof - Optional proof object
+ * @param context - Optional context
+ * @returns Verifiable presentation object
+ */
+export function createUnsignedPresentation(
+  credentials: any[],
+  proof?: any,
+  context: any[] = PRESENTATION_CONTEXT
+): VerifiablePresentation {
+  const vp: VerifiablePresentation = {
+    '@context': context,
+    type: ['VerifiablePresentation'],
+    verifiableCredential: credentials,
+  };
+
+  if (proof) {
+    vp.proof = proof;
+  }
+
+  return vp;
+}
+
+/**
+ * Re-export cedar for use in tests and external code
+ */
+export { cedar };
+
+/**
+ * Service class for delegatable credentials operations
+ */
+class DelegatableCredentialsService {
+  name = 'delegatable-credentials';
+
+  rpcMethods = [
+    DelegatableCredentialsService.prototype.issueDelegation,
+    DelegatableCredentialsService.prototype.issueDelegatedCredential,
+    DelegatableCredentialsService.prototype.createPresentation,
+    DelegatableCredentialsService.prototype.verifyPresentation,
+    DelegatableCredentialsService.prototype.createPolicy,
+  ];
+
+  /**
+   * Issues a delegation credential
+   */
+  async issueDelegation(params: {
+    keyPair: KeyPair;
+    id: string;
+    issuerDid: string;
+    delegateDid: string;
+    mayClaim: string[];
+    context: any[];
+    types: string[];
+    additionalSubjectProperties?: Record<string, any>;
+    previousCredentialId?: string | null;
+    rootCredentialId?: string;
+  }): Promise<DelegationCredential> {
+    return issueDelegationCredential(params.keyPair, params);
+  }
+
+  /**
+   * Issues a credential as a delegate
+   */
+  async issueDelegatedCredential(params: {
+    keyPair: KeyPair;
+    id: string;
+    issuerDid: string;
+    subjectDid: string;
+    claims: Record<string, any>;
+    rootCredentialId: string;
+    previousCredentialId: string;
+    context: any[];
+    types: string[];
+  }): Promise<any> {
+    return issueDelegatedCredential(params.keyPair, params);
+  }
+
+  /**
+   * Creates and signs a verifiable presentation
+   */
+  async createPresentation(params: {
+    keyPair: KeyPair;
+    credentials: any[];
+    holderDid: string;
+    challenge: string;
+    domain: string;
+    context?: any[];
+  }): Promise<VerifiablePresentation> {
+    return createSignedPresentation(params.keyPair, params);
+  }
+
+  /**
+   * Verifies a verifiable presentation with delegation chain
+   */
+  async verifyPresentation(params: {
+    presentation: VerifiablePresentation;
+    challenge?: string;
+    domain?: string;
+    unsignedPresentation?: boolean;
+    failOnUnauthorizedClaims?: boolean;
+    policies?: CedarPolicies;
+  }): Promise<VerificationResult> {
+    return verifyDelegatablePresentation(params.presentation, {
+      challenge: params.challenge,
+      domain: params.domain,
+      unsignedPresentation: params.unsignedPresentation,
+      failOnUnauthorizedClaims: params.failOnUnauthorizedClaims,
+      policies: params.policies,
+    });
+  }
+
+  /**
+   * Creates a Cedar policy for delegation verification
+   */
+  createPolicy(params: {
+    maxDepth?: number;
+    rootIssuer: string;
+    requiredClaims?: Record<string, any>;
+  }): CedarPolicies {
+    return createCedarPolicy(params);
+  }
+}
+
+export const delegatableCredentialsService = new DelegatableCredentialsService();

package/src/services/credential/index.ts

@@ -3,3 +3,19 @@ import {credentialService} from './service';
 
 // TODO: rename it to credentialService, will need to update dock-app
 export const credentialServiceRPC = credentialService;
+
+export {
+  delegatableCredentialsService,
+  verifyDelegatablePresentation,
+  issueDelegationCredential,
+  issueDelegatedCredential,
+  createSignedPresentation,
+  createUnsignedPresentation,
+  createCedarPolicy,
+  cedar,
+  MAY_CLAIM_IRI,
+  W3C_CREDENTIALS_V1,
+  DELEGATION_ENGINE_NS,
+  DELEGATION_CONTEXT_TERMS,
+  PRESENTATION_CONTEXT,
+} from './delegatable-credentials';