@docknetwork/wallet-sdk-core 1.4.0 → 1.5.0

package/src/did-provider.ts

@@ -54,35 +54,6 @@ export async function importDID({
   }
 }
 
-export async function createDIDock({wallet, address, name}) {
-  assert(!!wallet, 'wallet is required');
-  assert(!!address, 'address is required');
-  assert(!!name, 'name is required');
-
-  const keyPair = await wallet.getAccountKeyPair(address);
-  const {dockDID, keyPairWalletId} = await didServiceRPC.registerDidDock(
-    keyPair,
-  );
-
-  const keydoc = await didServiceRPC.generateKeyDoc({
-    keyPairJSON: keyPair,
-    controller: dockDID,
-  });
-
-  const didDocument = await didServiceRPC.getDidDockDocument(dockDID);
-
-  const dockDIDResolution = {
-    id: dockDID,
-    type: 'DIDResolutionResponse',
-    name,
-    didDocument,
-    correlation: [keydoc.id, keyPairWalletId],
-  };
-
-  await wallet.add(keydoc);
-  await wallet.add(dockDIDResolution);
-}
-
 async function editDID({wallet, id, name}){
   if (typeof id === 'string' && id.length > 0) {
     const docs = await wallet.query({
@@ -216,7 +187,6 @@ export interface IDIDProvider {
     encryptedJSONWallet: any;
     password: string;
   }): Promise<void>;
-  createDIDock(params: {address: string; name: string}): Promise<void>;
   createDIDKey(params: {name: string, derivePath?:string, type?: string}): Promise<any>;
   editDID(params: {id: string; name: string}): Promise<void>;
   deleteDID(params: {id: string;}): Promise<void>;
@@ -232,9 +202,6 @@ export function createDIDProvider({wallet}): IDIDProvider {
     async importDID({encryptedJSONWallet, password}) {
       return importDID({wallet, encryptedJSONWallet, password});
     },
-    async createDIDock({address, name}) {
-      return createDIDock({wallet, address, name});
-    },
     async createDIDKey({name, derivePath, type}) {
       return createDIDKey({wallet, name, derivePath, type});
     },

package/src/ecosystem-tools.ts

@@ -1,11 +1,9 @@
-import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
-import {trustRegistryService} from '@docknetwork/wallet-sdk-wasm/src/services/trust-registry';
 import assert from 'assert';
 import axios from 'axios';
 
-
+// TODO: FIXME: this wont work for other staging envs
 function getApiURL(networkId) {
-  return networkId === 'mainnet' ? 'https://api.dock.io' : 'https://api-testnet.dock.io';
+  return networkId === 'mainnet' ? 'https://api.truvera.io' : 'https://api-testnet.truvera.io';
 }
 
 export async function getEcosystems({

package/src/message-provider.ts

@@ -139,7 +139,7 @@ export function createMessageProvider({
         return;
       }
 
-      console.log(`Fetched ${encryptedMessages.length} messages`);
+      logger.debug(`Fetched ${encryptedMessages.length} messages`);
 
       for (const message of encryptedMessages) {
         try {
@@ -157,13 +157,20 @@ export function createMessageProvider({
 
           recentlyFetchedMessages.push(message._id);
         } catch (err) {
+          logger.debug(
+            `Failed to store message in wallet: ${JSON.stringify(message)}`,
+          );
           // this message will be lost if it fails to be stored in the wallet
           captureException(err);
         }
       }
 
       for (const [did, messageIds] of Object.entries(messageIdsPerDid)) {
-        logger.debug(`Acknowledging messages for ${did}`);
+        logger.debug(
+          `Acknowledging ${
+            (messageIds as string[])?.length
+          } messages for ${did}`,
+        );
         let startTime = new Date().getTime();
         relayService
           .ackMessages({

package/src/types.ts

@@ -70,6 +70,7 @@ export type IWallet = {
   getNetworkId: () => string;
   resolveDocumentNetwork: (document: any) => Promise<DocumentResolverResult>;
   dataStore: DataStore;
+  networkCheckInterval?: NodeJS.Timeout;
 } & IV1Wallet;
 
 export type CrateWalletWithDataStore = {

package/src/wallet-wasm.ts

@@ -1,14 +1,14 @@
-import {keyringService} from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
-import {utilCryptoService} from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
-import {dockService} from '@docknetwork/wallet-sdk-wasm/src/services/dock';
+import { blockchainService } from '@docknetwork/wallet-sdk-wasm/src/services/blockchain';
+import { keyringService } from '@docknetwork/wallet-sdk-wasm/src/services/keyring';
+import { utilCryptoService } from '@docknetwork/wallet-sdk-wasm/src/services/util-crypto';
 
-import {IWallet} from './types';
-import {Network} from '@docknetwork/wallet-sdk-data-store/src/types';
-import {WalletEvents} from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
+import { Network } from '@docknetwork/wallet-sdk-data-store/src/types';
+import { WalletEvents } from '@docknetwork/wallet-sdk-wasm/src/modules/wallet';
 import { captureException } from './helpers';
+import { IWallet } from './types';
 
-function isSubstrateNetwork(network: Network) {
-  return !!network.configs.substrateUrl;
+function isBlockchainNetwork(network: Network) {
+  return !!(network.configs.substrateUrl || network.configs.cheqdApiUrl);
 }
 
 /**
@@ -16,58 +16,117 @@ function isSubstrateNetwork(network: Network) {
  * Compare connected substrate connection with the current walle network
  * Disconnect and Establish a new connection if the network is different
  */
-export async function handleSubstrateNetworkChange(
+export async function handleBlockchainNetworkChange(
   wallet: IWallet,
 ): Promise<void> {
-  const currentSubstrateAddress = await dockService.getAddress();
-  const substrateNetworkId = wallet.dataStore.networks.find(
-    network => network.configs.substrateUrl === currentSubstrateAddress,
+  const currentAddress = await blockchainService.getAddress();
+  const networkId = wallet.dataStore.networks.find(
+    network => network.configs.substrateUrl === currentAddress || network.configs.cheqdApiUrl === currentAddress,
   )?.id;
   const currentNetworkId = wallet.dataStore.network?.id;
 
-  if (substrateNetworkId === currentNetworkId) {
+  if (networkId === currentNetworkId) {
     return;
   }
 
-  await dockService.disconnect();
-  await setSubstrateNetwork(wallet);
+  await blockchainService.disconnect();
+  await setBlockchainNetwork(wallet);
 }
 
-export async function setSubstrateNetwork(wallet: IWallet) {
+export async function setBlockchainNetwork(wallet: IWallet) {
   const network = wallet.dataStore.network;
   const networkConfigs = network.configs;
 
+
+  let cheqdMnemonicDoc = await wallet.getDocumentById('cheqd-mnemonic');
+
+  if (!cheqdMnemonicDoc) {
+    cheqdMnemonicDoc = {
+      id: 'cheqd-mnemonic',
+      type: 'Mnemonic',
+      value: await utilCryptoService.mnemonicGenerate(12),
+    }
+
+    await wallet.addDocument(cheqdMnemonicDoc);
+  }
+
   await keyringService.initialize({
     ss58Format: networkConfigs.addressPrefix,
   });
 
-  dockService
-    .init({
-      address: networkConfigs.substrateUrl,
-    })
-    .then(() => {
-      wallet.eventManager.emit(WalletEvents.networkConnected);
-    })
-    .catch(err => {
-      captureException(new Error('Unable to connect to substrate node'));
-      captureException(err);
-      console.error(err);
-      wallet.eventManager.emit(WalletEvents.networkError, err);
-    });
+  let connectionInProgress = false;
+
+  const initializeBlockchain = () => {
+    clearInterval(wallet.networkCheckInterval);
+  
+    if (connectionInProgress) {
+      return;
+    }
+  
+    connectionInProgress = true;
+  
+    blockchainService
+      .init({
+        substrateUrl: networkConfigs.substrateUrl,
+        cheqdApiUrl: networkConfigs.cheqdApiUrl,
+        networkId: network.id,
+        cheqdMnemonic: cheqdMnemonicDoc.value,
+      })
+      .then(() => {
+        wallet.eventManager.emit(WalletEvents.networkConnected);
+      })
+      .catch(err => {
+        const errorMessage = new Error('Unable to connect to blockchain');
+        captureException(errorMessage);
+        captureException(err);
+        console.error(err);
+        wallet.eventManager.emit(WalletEvents.networkError, err);
+      })
+      .finally(() => {
+        connectionInProgress = false;
+  
+        wallet.networkCheckInterval = setInterval(async () => {
+          try {
+            if (!await blockchainService.isApiConnected()) {
+              wallet.eventManager.emit(WalletEvents.networkError, new Error('Network not connected'));
+              initializeBlockchain();
+            }
+          } catch (err) {
+            console.error('Error during connectivity check:', err);
+          }
+        }, 10000);
+      });
+  };
+  
+  initializeBlockchain();
 }
 
 export async function initWalletWasm(wallet: IWallet) {
   await utilCryptoService.cryptoWaitReady();
   const network = wallet.dataStore.network;
 
-  if (isSubstrateNetwork(network)) {
-    await setSubstrateNetwork(wallet);
+  if (isBlockchainNetwork(network)) {
+    await setBlockchainNetwork(wallet);
 
     wallet.eventManager.on(WalletEvents.networkUpdated, async () => {
-      handleSubstrateNetworkChange(wallet).catch(err => console.error(err));
+      handleBlockchainNetworkChange(wallet).catch(err => console.error(err));
     });
   }
 
+  wallet.ensureNetwork = async () => {
+    try {
+      const isConnected = await blockchainService.isApiConnected();
+
+      if (!isConnected) {
+        await setBlockchainNetwork(wallet);
+        wallet.eventManager.emit(WalletEvents.networkConnected);
+      }
+    } catch (err) {
+      console.error('Error checking network connection:', err);
+      wallet.eventManager.emit(WalletEvents.networkError, err);
+    }
+  }
+
   wallet.setStatus('ready');
 
   wallet.eventManager.emit(WalletEvents.ready);