@docknetwork/wallet-sdk-wasm 1.7.0 → 1.7.7-alpha.0

package/lib/index.js

@@ -80,6 +80,7 @@ require('./services/edv/hmac.js');
 require('base64url-universal');
 require('@docknetwork/universal-wallet/crypto');
 require('@docknetwork/wallet-sdk-data-store/lib/logger');
+require('futoin-hkdf');
 require('winston-transport');
 
 rpcClient.initRpcClient(jsonRPCRequest => {

package/lib/index.mjs

@@ -78,6 +78,7 @@ import './services/edv/hmac.mjs';
 import 'base64url-universal';
 import '@docknetwork/universal-wallet/crypto';
 import '@docknetwork/wallet-sdk-data-store/lib/logger';
+import 'futoin-hkdf';
 import 'winston-transport';
 
 initRpcClient(jsonRPCRequest => {

package/lib/modules/network-manager.js

@@ -9,27 +9,30 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert);
 
 // @ts-nocheck
-const SUBSTRATE_NETWORKS = {
+const BLOCKCHAIN_NETWORKS = {
     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) {
-    const networkInfo = SUBSTRATE_NETWORKS[networkId];
+    const networkInfo = BLOCKCHAIN_NETWORKS[networkId];
     assert__default["default"](!!networkInfo, `Network ${networkId} not found`);
     return networkInfo;
 }
@@ -50,7 +53,7 @@ class NetworkManager {
      * @param {string} networkId
      */
     setNetworkId(networkId) {
-        assert__default["default"](!!SUBSTRATE_NETWORKS[networkId], `invalid networkId ${networkId}`);
+        assert__default["default"](!!BLOCKCHAIN_NETWORKS[networkId], `invalid networkId ${networkId}`);
         this.networkId = networkId;
     }
     /**
@@ -73,5 +76,5 @@ class NetworkManager {
     }
 }
 
+exports.BLOCKCHAIN_NETWORKS = BLOCKCHAIN_NETWORKS;
 exports.NetworkManager = NetworkManager;
-exports.SUBSTRATE_NETWORKS = SUBSTRATE_NETWORKS;

package/lib/modules/network-manager.mjs

@@ -1,27 +1,30 @@
 import assert from 'assert';
 
 // @ts-nocheck
-const SUBSTRATE_NETWORKS = {
+const BLOCKCHAIN_NETWORKS = {
     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) {
-    const networkInfo = SUBSTRATE_NETWORKS[networkId];
+    const networkInfo = BLOCKCHAIN_NETWORKS[networkId];
     assert(!!networkInfo, `Network ${networkId} not found`);
     return networkInfo;
 }
@@ -42,7 +45,7 @@ class NetworkManager {
      * @param {string} networkId
      */
     setNetworkId(networkId) {
-        assert(!!SUBSTRATE_NETWORKS[networkId], `invalid networkId ${networkId}`);
+        assert(!!BLOCKCHAIN_NETWORKS[networkId], `invalid networkId ${networkId}`);
         this.networkId = networkId;
     }
     /**
@@ -65,4 +68,4 @@ class NetworkManager {
     }
 }
 
-export { NetworkManager, SUBSTRATE_NETWORKS };
+export { BLOCKCHAIN_NETWORKS, NetworkManager };

package/lib/rpc-server.js

@@ -78,6 +78,7 @@ require('./services/edv/hmac.js');
 require('base64url-universal');
 require('@docknetwork/universal-wallet/crypto');
 require('@docknetwork/wallet-sdk-data-store/lib/logger');
+require('futoin-hkdf');
 
 const rpcServer = new jsonRpc2_0.JSONRPCServer();
 

package/lib/rpc-server.mjs

@@ -76,6 +76,7 @@ import './services/edv/hmac.mjs';
 import 'base64url-universal';
 import '@docknetwork/universal-wallet/crypto';
 import '@docknetwork/wallet-sdk-data-store/lib/logger';
+import 'futoin-hkdf';
 
 const rpcServer = new JSONRPCServer();
 

package/lib/services/blockchain/service.js

@@ -57,7 +57,10 @@ class BlockchainService {
     cheqdApi;
     cheqdApiUrl;
     isBlockchainReady = false;
-    resolver;
+    _resolver;
+    get resolver() {
+        return this._resolver;
+    }
     /**
      * Event names emitted by the blockchain service
      * @static
@@ -88,7 +91,8 @@ class BlockchainService {
         this.cheqdModules = new cheqdBlockchainModules.CheqdCoreModules(this.cheqdApi);
         this.modules = new modules.MultiApiCoreModules([this.cheqdModules]);
         this.emitter = new events.EventEmitter();
-        this.resolver = this.createDIDResolver();
+        // Blockchain is not ready yet, but we can use fallback resolvers
+        this._resolver = this.createDIDResolver();
     }
     /**
      * Gets the types and modules needed for DID or accumulator operations
@@ -148,12 +152,19 @@ class BlockchainService {
      * @private
      * @returns {CachedDIDResolver} Cached DID resolver instance
      */
-    createDIDResolver() {
-        const router = new AnyDIDResolver([
-            new resolver.DIDKeyResolver(),
-            new resolver.CoreResolver(this.modules),
+    createDIDResolver(isBlockchainReady) {
+        let resolvers = [
             new resolver.UniversalResolver(universalResolverUrl),
-        ]);
+            new resolver.DIDKeyResolver(),
+        ];
+        // Add blockchain resolvers if the blockchain is ready
+        if (isBlockchainReady) {
+            resolvers = [
+                new resolver.CoreResolver(this.modules),
+                ...resolvers
+            ];
+        }
+        const router = new AnyDIDResolver(resolvers);
         return new services_blockchain_cachedDidResolver.CachedDIDResolver(router);
     }
     /**
@@ -193,15 +204,17 @@ class BlockchainService {
         try {
             await this.cheqdApi.init({
                 wallet,
-                url: checkdApiUrl,
+                urls: Array.isArray(checkdApiUrl) ? checkdApiUrl : [checkdApiUrl],
                 network: cheqdNetworkId,
             });
             core_logger.Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
         }
         catch (err) {
+            debugger;
             core_logger.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' ||
             process.env.API_MOCK_DISABLED === 'true') {
             await index.initializeWasm();

package/lib/services/blockchain/service.mjs

@@ -2,7 +2,7 @@ import { DirectSecp256k1HdWallet } from '@cosmjs/proto-signing';
 import { CheqdAPI } from '@docknetwork/cheqd-blockchain-api';
 import { CheqdCoreModules } from '@docknetwork/cheqd-blockchain-modules';
 import { MultiApiCoreModules } from '@docknetwork/credential-sdk/modules';
-import { DIDKeyResolver, CoreResolver, UniversalResolver, ResolverRouter, WILDCARD } from '@docknetwork/credential-sdk/resolver';
+import { UniversalResolver, DIDKeyResolver, CoreResolver, ResolverRouter, WILDCARD } from '@docknetwork/credential-sdk/resolver';
 import { initializeWasm } from '@docknetwork/crypto-wasm-ts/lib/index';
 import { EventEmitter } from 'events';
 import { Logger } from '../../core/logger.mjs';
@@ -53,7 +53,10 @@ class BlockchainService {
     cheqdApi;
     cheqdApiUrl;
     isBlockchainReady = false;
-    resolver;
+    _resolver;
+    get resolver() {
+        return this._resolver;
+    }
     /**
      * Event names emitted by the blockchain service
      * @static
@@ -84,7 +87,8 @@ 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();
     }
     /**
      * Gets the types and modules needed for DID or accumulator operations
@@ -144,12 +148,19 @@ class BlockchainService {
      * @private
      * @returns {CachedDIDResolver} Cached DID resolver instance
      */
-    createDIDResolver() {
-        const router = new AnyDIDResolver([
-            new DIDKeyResolver(),
-            new CoreResolver(this.modules),
+    createDIDResolver(isBlockchainReady) {
+        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);
     }
     /**
@@ -189,15 +200,17 @@ 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' ||
             process.env.API_MOCK_DISABLED === 'true') {
             await initializeWasm();

package/lib/services/credential/bound-check.js

@@ -48,7 +48,7 @@ async function fetchBlobFromUrl(url) {
 }
 function blobFromBase64(base64String) {
     const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return base64url__default["default"].toBuffer(cleanedBase64);
+    return new Uint8Array(base64url__default["default"].toBuffer(cleanedBase64));
 }
 async function isBase64OrDataUrl(str) {
     return ((await services_utilCrypto_service.utilCryptoService.isBase64(str)) ||

package/lib/services/credential/bound-check.mjs

@@ -40,7 +40,7 @@ async function fetchBlobFromUrl(url) {
 }
 function blobFromBase64(base64String) {
     const cleanedBase64 = base64String.replace(/^data:application\/octet-stream;base64,/, '');
-    return base64url.toBuffer(cleanedBase64);
+    return new Uint8Array(base64url.toBuffer(cleanedBase64));
 }
 async function isBase64OrDataUrl(str) {
     return ((await utilCryptoService.isBase64(str)) ||

package/lib/services/credential/delegatable-credentials.js

@@ -0,0 +1,300 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var cedar = require('@cedar-policy/cedar-wasm/nodejs');
+var vc = require('@docknetwork/credential-sdk/vc');
+var vcDelegationEngine = require('@docknetwork/vc-delegation-engine');
+var keypairs = require('@docknetwork/universal-wallet/methods/keypairs');
+var services_blockchain_service = require('../blockchain/service.js');
+require('@cosmjs/proto-signing');
+require('@docknetwork/cheqd-blockchain-api');
+require('@docknetwork/cheqd-blockchain-modules');
+require('@docknetwork/credential-sdk/modules');
+require('@docknetwork/credential-sdk/resolver');
+require('@docknetwork/crypto-wasm-ts/lib/index');
+require('events');
+require('../../core/logger.js');
+require('../../modules/event-manager.js');
+require('assert');
+require('../util-crypto/service.js');
+require('@docknetwork/credential-sdk/utils');
+require('@scure/bip39');
+require('@scure/bip39/wordlists/english');
+require('../util-crypto/configs.js');
+require('@docknetwork/credential-sdk/types');
+require('../blockchain/cached-did-resolver.js');
+require('../storage/index.js');
+require('../storage/service.js');
+require('../storage/service-rpc.js');
+require('../rpc-service-client.js');
+require('../../rpc-client.js');
+require('json-rpc-2.0');
+require('../../core/crypto.js');
+require('crypto');
+require('../../logger.js');
+require('../../rpc-util.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var cedar__namespace = /*#__PURE__*/_interopNamespace(cedar);
+
+// @ts-nocheck
+/**
+ * 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) {
+    const kp = keypairs.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,
+    };
+}
+/**
+ * W3C Credentials V1 context URL
+ */
+const W3C_CREDENTIALS_V1 = 'https://www.w3.org/2018/credentials/v1';
+/**
+ * Namespace used by the vc-delegation-engine for delegation properties
+ */
+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',
+ *   },
+ * ];
+ */
+const DELEGATION_CONTEXT_TERMS = {
+    '@version': 1.1,
+    '@protected': true,
+    DelegationCredential: `${DELEGATION_ENGINE_NS}DelegationCredential`,
+    mayClaim: { '@id': vcDelegationEngine.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
+ */
+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
+ */
+async function issueDelegationCredential(keyPair, credential) {
+    const preparedKey = prepareKeyForSigning(keyPair);
+    return vc.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
+ */
+async function issueDelegatedCredential(keyPair, credential) {
+    const preparedKey = prepareKeyForSigning(keyPair);
+    return vc.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
+ */
+async function createSignedPresentation(keyPair, params) {
+    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 vc.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
+ */
+async function verifyDelegatablePresentation(vp, options = {}) {
+    const { challenge = vp.proof?.challenge || 'default-challenge', domain = vp.proof?.domain || 'default-domain', unsignedPresentation = false, failOnUnauthorizedClaims = true, policies, } = options;
+    const verifyOptions = {
+        challenge,
+        domain,
+        documentLoader: vc.documentLoader(services_blockchain_service.blockchainService.resolver),
+        unsignedPresentation,
+        failOnUnauthorizedClaims,
+    };
+    // Add Cedar authorization if policies are provided
+    if (policies) {
+        verifyOptions.cedarAuth = {
+            policies,
+            cedar: cedar__namespace,
+        };
+    }
+    return vc.verifyPresentation(vp, verifyOptions);
+}
+/**
+ * Creates a Cedar policy for delegation verification
+ * @param config - Policy configuration
+ * @returns Cedar policy object
+ */
+function createCedarPolicy(config) {
+    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
+ */
+function createUnsignedPresentation(credentials, proof, context = PRESENTATION_CONTEXT) {
+    const vp = {
+        '@context': context,
+        type: ['VerifiablePresentation'],
+        verifiableCredential: credentials,
+    };
+    if (proof) {
+        vp.proof = proof;
+    }
+    return vp;
+}
+/**
+ * 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) {
+        return issueDelegationCredential(params.keyPair, params);
+    }
+    /**
+     * Issues a credential as a delegate
+     */
+    async issueDelegatedCredential(params) {
+        return issueDelegatedCredential(params.keyPair, params);
+    }
+    /**
+     * Creates and signs a verifiable presentation
+     */
+    async createPresentation(params) {
+        return createSignedPresentation(params.keyPair, params);
+    }
+    /**
+     * Verifies a verifiable presentation with delegation chain
+     */
+    async verifyPresentation(params) {
+        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) {
+        return createCedarPolicy(params);
+    }
+}
+const delegatableCredentialsService = new DelegatableCredentialsService();
+
+exports.cedar = cedar__namespace;
+Object.defineProperty(exports, 'MAY_CLAIM_IRI', {
+  enumerable: true,
+  get: function () { return vcDelegationEngine.MAY_CLAIM_IRI; }
+});
+exports.DELEGATION_CONTEXT_TERMS = DELEGATION_CONTEXT_TERMS;
+exports.DELEGATION_ENGINE_NS = DELEGATION_ENGINE_NS;
+exports.PRESENTATION_CONTEXT = PRESENTATION_CONTEXT;
+exports.W3C_CREDENTIALS_V1 = W3C_CREDENTIALS_V1;
+exports.createCedarPolicy = createCedarPolicy;
+exports.createSignedPresentation = createSignedPresentation;
+exports.createUnsignedPresentation = createUnsignedPresentation;
+exports.delegatableCredentialsService = delegatableCredentialsService;
+exports.issueDelegatedCredential = issueDelegatedCredential;
+exports.issueDelegationCredential = issueDelegationCredential;
+exports.verifyDelegatablePresentation = verifyDelegatablePresentation;