feat: add plugins DashPay and DashPaySyncWorker

.github/workflows/.env

@@ -1,5 +1,5 @@
 #DRIVE_BRANCH=v0.21-dev
 #DAPI_BRANCH=v0.21-dev
-#DASHMATE_BRANCH=update-dependencies
-#TEST_SUITE_BRANCH=update-dependencies
+#DASHMATE_BRANCH=fix-mnsync
+TEST_SUITE_BRANCH=browser-tests
 #LOG_LEVEL=silly

package.json

@@ -34,7 +34,9 @@
     "@dashevo/grpc-common": "~0.5.4",
     "@dashevo/wallet-lib": "~7.22.0-dev.1",
     "bs58": "^4.0.1",
-    "node-inspect-extracted": "1.0.7"
+    "crypto-js": "^4.0.0",
+    "node-inspect-extracted": "1.0.7",
+    "secp256k1-native": "^1.1.2"
   },
   "devDependencies": {
     "@types/chai": "^4.2.12",

src/SDK/Client/Client.ts

@@ -5,6 +5,8 @@ import { Platform } from './Platform';
 import { Network } from "@dashevo/dashcore-lib";
 import DAPIClient from "@dashevo/dapi-client";
 import { ClientApps, ClientAppsOptions } from "./ClientApps";
+import { DashPaySyncWorker } from "./plugins/DashPaySyncWorker/DashPaySyncWorker";
+import { DashPay } from "./plugins/DashPay/DashPay";
 
 export interface WalletOptions extends Wallet.IWalletOptions {
     defaultAccountIndex?: number;
@@ -82,6 +84,8 @@ export class Client extends EventEmitter {
 
         this.dapiClient = new DAPIClient(dapiClientOptions);
 
+        let dashpayPlugin;
+        let dashpaySyncWorker;
         // Initialize a wallet if `wallet` option is preset
         if (this.options.wallet !== undefined) {
             if (this.options.wallet.network !== undefined && this.options.wallet.network !== this.network) {
@@ -90,11 +94,24 @@ export class Client extends EventEmitter {
 
             const transport = new DAPIClientTransport(this.dapiClient);
 
-            this.wallet = new Wallet({
+            const walletOptions = {
                 transport,
                 network: this.network,
-                ...this.options.wallet,
-            });
+            ...this.options.wallet,
+            }
+
+            // If it's a bip44 wallet, we pass the DashPay Worker and DashPay plugin
+            if(
+                !this.options.wallet.privateKey &&
+                this.options.wallet.offlineMode !== true
+            ){
+                dashpayPlugin = new DashPay();
+                dashpaySyncWorker = new DashPaySyncWorker();
+                //@ts-ignore
+                walletOptions.plugins = [dashpayPlugin, dashpaySyncWorker];
+            }
+            //@ts-ignore
+            this.wallet = new Wallet(walletOptions);
 
             // @ts-ignore
             this.wallet.on('error', (error, context) => (
@@ -119,6 +136,12 @@ export class Client extends EventEmitter {
             network: this.network,
             driveProtocolVersion: this.options.driveProtocolVersion,
         });
+
+        if(dashpaySyncWorker && dashpayPlugin){
+            dashpayPlugin.inject('platform', this.platform, true)
+            dashpaySyncWorker.inject('platform', this.platform, true)
+        }
+
     }
 
     /**
@@ -128,16 +151,24 @@ export class Client extends EventEmitter {
      * @returns {Promise<Account>}
      */
     async getWalletAccount(options: Account.Options = {}) : Promise<Account> {
-        if (!this.wallet) {
+        const { wallet } = this;
+        if (!wallet) {
             throw new Error('Wallet is not initialized, pass `wallet` option to Client');
         }
 
         options = {
             index: this.defaultAccountIndex,
             ...options,
         }
+        const account = await wallet.getAccount(options);
+
+        try {
+            const dashpayworker = account.getWorker('DashPaySyncWorker');
+            //@ts-ignore
+            await dashpayworker.execute();
+        } catch {}
 
-        return this.wallet.getAccount(options);
+        return account;
     }
 
     /**

src/SDK/Client/Platform/methods/identities/register.ts

@@ -36,10 +36,11 @@ export default async function register(
     await broadcastStateTransition(this, identityCreateTransition);
 
     // If state transition was broadcast without any errors, import identity to the account
-    account.storage.insertIdentityIdAtIndex(
-        account.walletId,
-        identity.getId().toString(),
-        identityIndex,
+    account.storage
+        .getWalletStore(account.walletId)
+        .insertIdentityIdAtIndex(
+            identity.getId().toString(),
+            identityIndex,
     );
 
     return identity;

src/SDK/Client/plugins/DashPay/DashPay.ts

@@ -0,0 +1,65 @@
+import { plugins } from "@dashevo/wallet-lib"
+
+import { acceptContactRequest } from "./methods/acceptContactRequest";
+import { createAccountReference } from "./methods/createAccountReference";
+import { decryptAccountLabel }from "./methods/decryptAccountLabel";
+import { decryptPublicKey } from "./methods/decryptPublicKey";
+import { encryptAccountLabel } from "./methods/encryptAccountLabel";
+import { encryptPublicKey } from "./methods/encryptPublicKey";
+import { encryptSharedKey } from "./methods/encryptSharedKey";
+import { fetchEstablishedContacts } from "./methods/fetchEstablishedContacts";
+import { fetchProfile } from "./methods/fetchProfile";
+import { fetchReceivedContactRequests } from "./methods/fetchReceivedContactRequests";
+import { fetchSentContactRequests } from "./methods/fetchSentContactRequests";
+import { sendContactRequest } from "./methods/sendContactRequest";
+
+export class DashPay extends plugins.StandardPlugin {
+    acceptContactRequest: any;
+    createAccountReference: any;
+    decryptAccountLabel: any;
+    decryptPublicKey: any;
+    encryptAccountLabel: any;
+    encryptPublicKey: any;
+    encryptSharedKey: any;
+    fetchEstablishedContacts: any;
+    fetchProfile: any;
+    fetchReceivedContactRequests: any;
+    fetchSentContactRequests: any;
+    sendContactRequest: any;
+    private contacts: any[];
+    constructor() {
+        super({
+            name: 'DashPay',
+            executeOnStart: true,
+            firstExecutionRequired: true,
+            awaitOnInjection: true,
+            workerIntervalTime: 60 * 1000,
+            dependencies: [
+                'storage',
+                'decrypt',
+                'encrypt',
+                'keyChainStore',
+                'walletId',
+                'network',
+                'identities',
+                'getUnusedIdentityIndex'
+            ],
+            injectionOrder:{
+                after: ['IdentitySyncWorker']
+            }
+        });
+        this.contacts = []
+    }
+}
+DashPay.prototype.acceptContactRequest = acceptContactRequest;
+DashPay.prototype.createAccountReference = createAccountReference;
+DashPay.prototype.decryptAccountLabel = decryptAccountLabel;
+DashPay.prototype.decryptPublicKey = decryptPublicKey;
+DashPay.prototype.encryptAccountLabel = encryptAccountLabel;
+DashPay.prototype.encryptPublicKey = encryptPublicKey;
+DashPay.prototype.encryptSharedKey = encryptSharedKey;
+DashPay.prototype.fetchEstablishedContacts = fetchEstablishedContacts;
+DashPay.prototype.fetchProfile = fetchProfile;
+DashPay.prototype.fetchReceivedContactRequests = fetchReceivedContactRequests;
+DashPay.prototype.fetchSentContactRequests = fetchSentContactRequests;
+DashPay.prototype.sendContactRequest = sendContactRequest;