@docknetwork/wallet-sdk-wasm 1.4.0 → 1.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@docknetwork/wallet-sdk-wasm",
-    "version": "1.4.0",
+    "version": "1.5.6",
     "license": "https://github.com/docknetwork/react-native-sdk/LICENSE",
     "repository": {
         "type": "git",
@@ -13,9 +13,9 @@
         "build": "rm -rf lib && rollup -c && node ../../scripts/fix-build-imports.js ./lib"
     },
     "resolutions": {
+        "p-limit": "2.3.0",
         "@polkadot/wasm-crypto": "6.3.1",
         "@polkadot/rpc-core": "9.7.1",
-        "@docknetwork/sdk": "8.6.0",
         "@polkadot/api": "9.7.1",
         "@polkadot/keyring": "10.1.11",
         "@polkadot/rpc-provider": "9.7.1",
@@ -27,7 +27,10 @@
     "dependencies": {
         "@astronautlabs/jsonpath": "^1.1.2",
         "@docknetwork/universal-wallet": "^2.0.1",
-        "@docknetwork/wallet-sdk-dids": "^1.4.0",
+        "@docknetwork/wallet-sdk-dids": "^1.5.6",
+        "@cosmjs/proto-signing": "^0.32.4",
+        "@docknetwork/cheqd-blockchain-api": "0.30.2",
+        "@docknetwork/cheqd-blockchain-modules": "0.30.2",
         "@polkadot/api": "9.7.1",
         "@polkadot/keyring": "10.1.11",
         "@polkadot/rpc-core": "9.7.1",
@@ -38,7 +41,8 @@
         "@polkadot/util": "10.1.11",
         "@polkadot/util-crypto": "10.1.11",
         "@polkadot/wasm-crypto": "6.3.1",
-        "@docknetwork/sdk": "8.6.0",
+        "@docknetwork/credential-sdk": "0.44.0",
+        "@docknetwork/dock-blockchain-modules": "0.26.2",
         "@sphereon/oid4vci-client": "^0.16.0",
         "@sphereon/oid4vci-common": "^0.16.0",
         "axios": "^0.25.0",
@@ -51,9 +55,7 @@
         "cwait": "1.1.2",
         "axios-retry": "^3.2.5",
         "@sphereon/pex": "^1.1.4",
-        "@docknetwork/credential-sdk": "0.12.0",
-        "@docknetwork/dock-blockchain-api": "0.6.1",
-        "@docknetwork/dock-blockchain-modules": "0.8.0"
+        "@docknetwork/dock-blockchain-api": "0.6.1"
     },
     "devDependencies": {
         "@babel/node": "^7.16.0",

package/src/core/polkadot-utils.js

@@ -5,10 +5,8 @@ import {
   sr25519PairFromSeed,
   secp256k1PairFromSeed,
 } from '@polkadot/util-crypto';
-
+import {Ed25519Keypair} from '@docknetwork/credential-sdk/keypairs';
 import {decodePair} from '@polkadot/keyring/pair/decode';
-import {getKeyPairType} from '@docknetwork/sdk/utils/misc';
-
 import * as bs58 from 'base58-universal';
 
 import {getKeypairFromDoc} from '@docknetwork/universal-wallet/methods/keypairs';
@@ -20,6 +18,19 @@ const polkadotTypesToKeys = {
   ecdsa: 'EcdsaSecp256k1VerificationKey2019',
 };
 
+export function getKeyPairType(key) {
+  const keyType = key.type || key.constructor.VerKeyType;
+  if (keyType) {
+    return keyType;
+  }
+
+  if (key instanceof Ed25519Keypair) {
+    return 'Ed25519VerificationKey2018';
+  }
+
+  throw new Error(`Unknown key type for ${key.constructor.name}`);
+}
+
 const TYPE_FROM_SEED = {
   ecdsa: secp256k1PairFromSeed,
   secp256k1: secp256k1PairFromSeed,

package/src/modules/network-manager.ts

@@ -5,6 +5,7 @@ export type NetworkInfo = {
   name: string,
   substrateUrl: string | string[],
   addressPrefix: number,
+  cheqdApiUrl: string,
 };
 
 export type NetworkId = 'mainnet' | 'testnet' | 'local' | 'custom';
@@ -12,13 +13,15 @@ export type NetworkId = 'mainnet' | 'testnet' | 'local' | 'custom';
 export const SUBSTRATE_NETWORKS : Record<NetworkId, NetworkInfo> = {
   mainnet: {
     name: 'Dock PoS Mainnet',
-    substrateUrl: ['wss://mainnet-node.dock.io', 'wss://mainnet-node-2.dock.io'],
+    substrateUrl: null,
     addressPrefix: 22,
+    cheqdApiUrl: 'https://mainnet.cheqd.docknode.io/',
   },
   testnet: {
     name: 'Dock PoS Testnet',
-    substrateUrl: 'wss://knox-1.dock.io',
+    substrateUrl: null,
     addressPrefix: 21,
+    cheqdApiUrl: 'https://testnet.cheqd.docknode.io/',
   },
   local: {
     name: 'Local Node',

package/src/modules/wallet.ts

@@ -2,7 +2,7 @@
 import assert from 'assert';
 import {v4 as uuid} from 'uuid';
 import {getStorage} from '../core/storage';
-import {dockService} from '../services/dock';
+import {blockchainService} from '../services/blockchain';
 import {keyringService} from '../services/keyring';
 import {utilCryptoService} from '../services/util-crypto';
 import {walletService} from '../services/wallet';
@@ -165,7 +165,7 @@ class Wallet {
    * Close wallet
    */
   async close() {
-    await dockService.disconnect();
+    await blockchainService.disconnect();
     this.setStatus('closed');
   }
 
@@ -227,13 +227,13 @@ class Wallet {
       });
 
       Logger.debug(`Initializing network ${JSON.stringify(networkInfo)}`);
-      const isDockConnected = await dockService.isApiConnected();
+      const isDockConnected = await blockchainService.isApiConnected();
 
       if (isDockConnected) {
-        await dockService.disconnect();
+        await blockchainService.disconnect();
       }
 
-      await dockService.init({
+      await blockchainService.init({
         address: networkInfo.substrateUrl,
       });
 

package/src/services/blockchain/configs.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+import assert from 'assert';
+
+export const validation = {};
+
+export type InitParams = {
+  substrateUrl: string,
+  cheqdApiUrl?: string,
+  networkId?: string,
+  cheqdMnemonic?: string,
+};

package/src/services/blockchain/index.android.js

@@ -0,0 +1,3 @@
+import {BlockchainServiceRpc} from './service-rpc';
+
+export const blockchainService = new BlockchainServiceRpc();

package/src/services/blockchain/index.ios.js

@@ -0,0 +1,3 @@
+import {BlockchainServiceRpc} from './service-rpc';
+
+export const blockchainService = new BlockchainServiceRpc();

package/src/services/blockchain/index.js

@@ -0,0 +1 @@
+export {blockchainService} from './service';

package/src/services/blockchain/index.test.js

@@ -0,0 +1,34 @@
+import {NetworkManager} from '../../modules/network-manager';
+import {assertRpcService, mockDockSdkConnection} from '../test-utils';
+import {validation} from './configs';
+import {blockchainService as service} from './service';
+import {BlockchainServiceRpc} from './service-rpc';
+
+const doConnect = (
+  address = NetworkManager.getInstance().getNetworkInfo().substrateUrl,
+) =>
+  service.init({
+    address,
+  });
+
+describe('DockService', () => {
+  it('ServiceRpc', () => {
+    assertRpcService(BlockchainServiceRpc, service, validation);
+  });
+
+  describe('init', () => {
+    afterEach(async () => {
+      await service.disconnect();
+    });
+
+    it('connect and disconnect substrate node', async () => {
+      const mock = mockDockSdkConnection();
+      const result = await doConnect();
+      expect(result).toBe(true);
+      expect(service.isBlockchainReady).toBeTruthy();
+      await service.disconnect();
+      expect(service.isBlockchainReady).toBeFalsy();
+      mock.clear();
+    });
+  });
+});

package/src/services/{dock → blockchain}/service-rpc.js

@@ -1,12 +1,12 @@
 import {RpcService} from '../rpc-service-client';
-import {InitParams, validation} from './configs';
+import {InitParams} from './configs';
 
 /**
  *
  */
-export class DockServiceRpc extends RpcService {
+export class BlockchainServiceRpc extends RpcService {
   constructor() {
-    super('dock');
+    super('blockchain');
   }
 
   /**
@@ -19,15 +19,14 @@ export class DockServiceRpc extends RpcService {
   /**
    *
    */
-  ensureDockReady(): Promise<any> {
-    return this.call('ensureDockReady');
+  ensureBlockchainReady(): Promise<any> {
+    return this.call('ensureBlockchainReady');
   }
 
   /**
    *
    */
   init(params: InitParams): Promise<any> {
-    validation.init(params);
     return this.call('init', params);
   }
 

package/src/services/blockchain/service.ts

@@ -0,0 +1,261 @@
+// @ts-nocheck
+
+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 {
+  CoreResolver,
+  DIDKeyResolver,
+  ResolverRouter,
+  UniversalResolver,
+  WILDCARD,
+} from '@docknetwork/credential-sdk/resolver';
+import {initializeWasm} from '@docknetwork/crypto-wasm-ts/lib/index';
+
+import {DockAPI} from '@docknetwork/dock-blockchain-api';
+import {
+  DockCoreModules,
+  DockDIDModule,
+} from '@docknetwork/dock-blockchain-modules';
+import {EventEmitter} from 'events';
+import {Logger} from '../../core/logger';
+import {once} from '../../modules/event-manager';
+import {utilCryptoService} from '../util-crypto';
+import {InitParams} from './configs';
+
+export const universalResolverUrl = 'https://uniresolver.truvera.io';
+
+import {
+  CheqdAccumulatorCommon,
+  CheqdAccumulatorId,
+  CheqdAccumulatorPublicKey,
+  DockAccumulatorCommon,
+  DockAccumulatorId,
+  DockAccumulatorPublicKey,
+} from '@docknetwork/credential-sdk/types';
+
+class AnyDIDResolver extends ResolverRouter {
+  method = WILDCARD;
+}
+
+const {AccumulatorModule: AccumulatorModuleDock} = DockCoreModules;
+const {AccumulatorModule: AccumulatorModuleCheqd} = CheqdCoreModules;
+
+const TYPES_FOR_DID = {
+  dock: {
+    PublicKey: DockAccumulatorPublicKey,
+    AccumulatorId: DockAccumulatorId,
+    AccumulatorCommon: DockAccumulatorCommon,
+    AccumulatorModule: AccumulatorModuleDock,
+  },
+  cheqd: {
+    PublicKey: CheqdAccumulatorPublicKey,
+    AccumulatorId: CheqdAccumulatorId,
+    AccumulatorCommon: CheqdAccumulatorCommon,
+    AccumulatorModule: AccumulatorModuleCheqd,
+  },
+};
+
+/**
+ *
+ */
+export class BlockchainService {
+  dock;
+  modules;
+  didModule;
+  cheqdApi;
+  isBlockchainReady = false;
+  resolver: any;
+  dockEnabled: boolean;
+  static Events = {
+    BLOCKCHAIN_READY: 'blockchain-ready',
+  };
+
+  rpcMethods = [
+    BlockchainService.prototype.disconnect,
+    BlockchainService.prototype.ensureBlockchainReady,
+    BlockchainService.prototype.init,
+    BlockchainService.prototype.isApiConnected,
+    BlockchainService.prototype.getAddress,
+  ];
+
+  constructor() {
+    this.name = 'blockchain';
+    this.dock = new DockAPI();
+    this.cheqdApi = new CheqdAPI();
+    this.didModule = new DockDIDModule(this.dock);
+    this.dockModules = new DockCoreModules(this.dock);
+    this.cheqdModules = new CheqdCoreModules(this.cheqdApi);
+    this.modules = new MultiApiCoreModules(
+      this.dockEnabled
+        ? [this.dockModules, this.cheqdModules]
+        : [this.cheqdModules],
+    );
+    this.emitter = new EventEmitter();
+    this.resolver = this.createDIDResolver();
+  }
+
+  getTypesForDIDOrAccumulator(didOrRegistryId) {
+    const didType = didOrRegistryId
+      .replace('dock:accumulator:', 'accumulator:dock:')
+      .split(':')[1];
+    const chainDidType = !this.dock && didType === 'dock' ? 'cheqd' : didType;
+    const types = TYPES_FOR_DID[chainDidType];
+    if (!types) {
+      throw new APIError(
+        `Unable to use DID type ${didType} for this operation`,
+      );
+    }
+    return types;
+  }
+
+  /**
+   *
+   * @returns
+   */
+  async ensureBlockchainReady() {
+    if (this.isBlockchainReady) {
+      return;
+    }
+
+    return once(this.emitter, BlockchainService.Events.BLOCKCHAIN_READY);
+  }
+
+  createDIDResolver() {
+    return new AnyDIDResolver([
+      new DIDKeyResolver(),
+      new CoreResolver(this.modules),
+      new UniversalResolver(universalResolverUrl),
+    ]);
+  }
+  /**
+   *
+   * @param {*} params
+   * @returns
+   */
+  async init(params: InitParams) {
+    if (this.dock.isConnected) {
+      await this.dock.disconnect();
+    }
+
+    if (this.cheqdApi && this.cheqdApi.isInitialized()) {
+      await this.cheqdApi.disconnect();
+    }
+
+    Logger.info(`Attempt to initialized substrate at: ${params.address}`);
+
+    this.dockEnabled = !!params.substrateUrl;
+
+    if (this.dockEnabled) {
+      await this.dock.init({
+        address: params.substrateUrl,
+      });
+      Logger.info(`Substrate initialized at: ${params.address}`);
+    }
+
+    this.modules = new MultiApiCoreModules(
+      this.dockEnabled
+        ? [this.dockModules, this.cheqdModules]
+        : [this.cheqdModules],
+    );
+
+    if (params?.cheqdApiUrl) {
+      const checkdApiUrl = params?.cheqdApiUrl;
+      const cheqdNetworkId = params?.networkId;
+      const cheqdMnemonic =
+        params?.cheqdMnemonic || (await utilCryptoService.mnemonicGenerate(12));
+
+      const wallet = await DirectSecp256k1HdWallet.fromMnemonic(cheqdMnemonic, {
+        prefix: 'cheqd',
+      });
+
+      const walletAccounts = await wallet.getAccounts();
+      const [{address}] = walletAccounts;
+      console.log('Using cheqd account:', address);
+
+      Logger.info(
+        `Attempt to initialized cheqd at: ${checkdApiUrl} with networkId: ${cheqdNetworkId}`,
+      );
+      Logger.info(`Using cheqd account: ${address}`);
+
+      try {
+        await this.cheqdApi.init({
+          wallet,
+          url: checkdApiUrl,
+          network: cheqdNetworkId,
+        });
+        Logger.info(`Cheqd initialized at: ${checkdApiUrl}`);
+      } catch (err) {
+        Logger.error(`Failed to initialize cheqd at: ${checkdApiUrl}`);
+      }
+    }
+
+    this.address = params.address;
+
+    this.resolver = this.createDIDResolver();
+
+    if (
+      process.env.NODE_ENV !== 'test' ||
+      process.env.API_MOCK_DISABLED === 'true'
+    ) {
+      await initializeWasm();
+    }
+
+    this._setBlockchainReady(true);
+
+    return true;
+  }
+
+  /**
+   *
+   * @returns
+   */
+  async disconnect() {
+    let result;
+
+    if (this.dockEnabled) {
+      result = await this.dock.disconnect();
+    }
+
+    if (this.cheqdApi && this.cheqdApi.isInitialized()) {
+      result = await this.cheqdApi.disconnect();
+    }
+
+    this._setBlockchainReady(false);
+
+    return result;
+  }
+
+  async waitBlockchainReady() {
+    return new Promise(resolve => {
+      if (this.isBlockchainReady) {
+        resolve();
+      } else {
+        this.emitter.once(BlockchainService.Events.BLOCKCHAIN_READY, resolve);
+      }
+    });
+  }
+
+  /**
+   *
+   * @returns
+   */
+  async isApiConnected() {
+    return this.cheqdApi.isInitialized();
+  }
+
+  async getAddress() {
+    return this.dock.address;
+  }
+
+  _setBlockchainReady(isBlockchainReady) {
+    this.isBlockchainReady = isBlockchainReady;
+
+    if (isBlockchainReady) {
+      this.emitter.emit(BlockchainService.Events.BLOCKCHAIN_READY);
+    }
+  }
+}
+
+export const blockchainService: BlockchainService = new BlockchainService();

package/src/services/credential/bbs-revocation.ts

@@ -9,7 +9,9 @@ import {
 } from '@docknetwork/crypto-wasm-ts';
 
 import {hexToU8a} from '@polkadot/util';
-import { dockService } from '../dock/service';
+import {
+  blockchainService,
+} from '../blockchain/service';
 
 const trimHexID = id => {
   if (id.substr(0, 2) !== '0x') {
@@ -19,100 +21,37 @@ const trimHexID = id => {
   return id.substr(2);
 };
 
-// "-32000: Client error: UnknownBlock: State already discarded for BlockId::Hash(<hash>)"
-// This means that the node has discarded old blocks to preserve space. This should not happen with a full node
-const UnknownBlockErrorCode = -32000;
-
-async function updateMembershipWitness({
-  credential,
-  membershipWitness,
-  registryId,
-  blockNo,
-}) {
-  const revocationId = credential.credentialStatus.revocationId;
-  const member = Accumulator.encodePositiveNumberAsAccumulatorMember(
-    Number(revocationId),
-  );
-
-  let updates = [];
-  try {
-    // TODO: Ensure it will for cheqd 
-    // Will be handled on https://dock-team.atlassian.net/browse/DCKW-572
-    updates = await dockService.modules.accumulator.dockOnly.getUpdatesFromBlock(
-      registryId,
-      blockNo,
-    );
-  } catch (err) {
-    if (err.code === UnknownBlockErrorCode) {
-      console.error(err);
-      updates = [];
-    } else {
-      throw err;
-    }
-  }
-
-  const additions = [];
-  const removals = [];
-
-  if (updates.length && updates[0].additions !== null) {
-    for (const a of updates[0].additions) {
-      additions.push(hexToU8a(a));
-    }
-  }
-
-  if (updates.length && updates[0].removals !== null) {
-    for (const a of updates[0].removals) {
-      removals.push(hexToU8a(a));
-    }
-  }
-
-  
-  const witness = new VBMembershipWitness(hexToU8a(membershipWitness));
-
-  if (updates.length) {
-    const queriedWitnessInfo = new VBWitnessUpdateInfo(
-      hexToU8a(updates[0].witnessUpdateInfo),
-    )
-
-    witness.updateUsingPublicInfoPostBatchUpdate(
-      member,
-      additions,
-      removals,
-      queriedWitnessInfo,
-    );
-  }
-
-  return witness;
-}
-
 export const getWitnessDetails = async (credential, _membershipWitness) => {
   let witness = _membershipWitness;
   let blockNo;
 
   try {
-    ({blockNo, witness} = JSON.parse(_membershipWitness));
+    ({witness, blockNo} = JSON.parse(_membershipWitness));
   } catch (err) {
     console.error(err);
   }
-  
+
   const {credentialStatus} = credential;
-  const registryId = credentialStatus?.id.replace('dock:accumulator:', '');
+  const registryId = credentialStatus?.id;
   const revocationIndex = credentialStatus.revocationId;
 
-  const queriedAccumulator = await dockService.modules.accumulator.getAccumulator(
-    registryId,
-    false,
-  );
+  const queriedAccumulator =
+    await blockchainService.modules.accumulator.getAccumulator(
+      registryId,
+      false,
+    );
 
   if (!queriedAccumulator) {
     throw new Error('Accumulator not found');
   }
 
-  const accumulator = PositiveAccumulator.fromAccumulated(queriedAccumulator.accumulated.bytes);
+  const accumulator = PositiveAccumulator.fromAccumulated(
+    queriedAccumulator.accumulated.bytes,
+  );
 
   const encodedRevId = Encoder.defaultEncodeFunc()(revocationIndex.toString());
 
-  const publicKey = await dockService.modules.accumulator.getPublicKey(
+  const publicKey = await blockchainService.modules.accumulator.getPublicKey(
     queriedAccumulator.keyRef[0],
     queriedAccumulator.keyRef[1],
   );
@@ -120,23 +59,36 @@ export const getWitnessDetails = async (credential, _membershipWitness) => {
   const params = dockAccumulatorParams();
   const pk = new AccumulatorPublicKey(publicKey.bytes);
 
-  let membershipWitness = new VBMembershipWitness(
-    hexToU8a(witness),
-  );
+  const membershipWitness = new VBMembershipWitness(hexToU8a(witness));
 
-  if(blockNo){
-    try {
-      const updatedWitness = await updateMembershipWitness({
-        credential,
-        membershipWitness: witness,
-        registryId,
-        blockNo,
-      });
-      membershipWitness = updatedWitness;
+  try {
+    const credentialStatusId = credential.credentialStatus.id;
+    const accumulatorId = blockchainService
+      .getTypesForDIDOrAccumulator(credentialStatusId)
+      .AccumulatorId.from(credentialStatusId);
+
+    const history =
+      await blockchainService.modules.accumulator.accumulatorHistory(
+        accumulatorId,
+      );
+
+    const blockNoIndex = history.updates.findIndex(
+      update => update.id.toString() === blockNo,
+    );
 
-    } catch (err) {
-      console.error(err);
+    const nextBlockNo = history.updates[blockNoIndex + 1]?.id?.toString();
+
+    if (nextBlockNo) {
+      await blockchainService.modules.accumulator.updateWitness(
+        registryId,
+        encodedRevId,
+        membershipWitness,
+        nextBlockNo,
+        queriedAccumulator.lastModified,
+      );
     }
+  } catch (err) {
+    console.error(err);
   }
 
   return {