dop-wallet-v6 1.2.20 → 1.3.0

package/patches/dop-engine-v3+1.4.9.patch

@@ -1,8 +1,201 @@
+diff --git a/node_modules/dop-engine-v3/dist/contracts/dop-smart-wallet/V2/dop-smart-wallet.js b/node_modules/dop-engine-v3/dist/contracts/dop-smart-wallet/V2/dop-smart-wallet.js
+index 56b2ecb..e5f75b7 100644
+--- a/node_modules/dop-engine-v3/dist/contracts/dop-smart-wallet/V2/dop-smart-wallet.js
++++ b/node_modules/dop-engine-v3/dist/contracts/dop-smart-wallet/V2/dop-smart-wallet.js
+@@ -75,6 +75,7 @@ class DopSmartWalletContract extends events_1.default {
+      * @returns isValid
+      */
+     async validateMerkleroot(tree, root) {
++        console.log(`Validating V2 merkleroot for tree ${tree} : ${root}`);
+         try {
+             const isValidMerkleroot = await this.contract.rootHistory(tree, bytes_1.ByteUtils.formatToByteLength(root, bytes_1.ByteLength.UINT_256, true));
+             // if (!isValidMerkleroot && EngineDebug.isTestRun()) {
+diff --git a/node_modules/dop-engine-v3/dist/dop-engine.js b/node_modules/dop-engine-v3/dist/dop-engine.js
+index d1e96e8..31c592d 100644
+--- a/node_modules/dop-engine-v3/dist/dop-engine.js
++++ b/node_modules/dop-engine-v3/dist/dop-engine.js
+@@ -254,14 +254,17 @@ class DopEngine extends events_1.default {
+     }
+     async performQuickSync(txidVersion, chain, endProgress, retryCount = 0) {
+         try {
++            console.log("Starting quick sync...");
+             debugger_1.default.log(`[${txidVersion}] quickSync: chain ${chain.type}:${chain.id}`);
+             const utxoMerkletree = this.getUTXOMerkletree(txidVersion, chain);
+             const startScanningBlockQuickSync = await this.getStartScanningBlock(txidVersion, chain);
++            console.log(`Quick syncing UTXO merkletree for txid version ${txidVersion} on chain ${chain.type}:${chain.id} from block ${startScanningBlockQuickSync}...`);
+             debugger_1.default.log(`[${txidVersion}] Start scanning block for QuickSync: ${startScanningBlockQuickSync}`);
+             this.emitUTXOMerkletreeScanUpdateEvent(txidVersion, chain, endProgress * 0.2); // 10% / 50%
+             // Fetch events
+             const { commitmentEvents, decryptEvents, nullifierEvents, dopTransactionEvents } = await this.quickSyncEvents(txidVersion, chain, startScanningBlockQuickSync);
+             if (dopTransactionEvents) {
++                console.log(`QuickSync dopTransactionEvents: ${dopTransactionEvents.length}`);
+                 debugger_1.default.log(`[${txidVersion}] QuickSync dopTransactionEvents: ${dopTransactionEvents.length}`);
+                 await this.handleNewDopTransactionsV3(txidVersion, chain, dopTransactionEvents);
+             }
+@@ -269,6 +272,7 @@ class DopEngine extends events_1.default {
+             await this.decryptListener(txidVersion, chain, decryptEvents);
+             this.emitUTXOMerkletreeScanUpdateEvent(txidVersion, chain, endProgress * 0.5); // 25% / 50%
+             await this.nullifierListener(txidVersion, chain, nullifierEvents);
++            console.log(`QuickSync commitmentEvents: ${commitmentEvents.length}`);
+             debugger_1.default.log(`[${txidVersion}] QuickSync commitments: ${commitmentEvents.length}`);
+             // Make sure commitments are scanned after Decrypts and Nullifiers.
+             await this.commitmentListener(txidVersion, chain, commitmentEvents, false, // shouldUpdateTrees - wait until after all commitments added
+@@ -285,6 +289,7 @@ class DopEngine extends events_1.default {
+                 await this.performQuickSync(txidVersion, chain, endProgress, retryCount + 1);
+                 return;
+             }
++            console.error('Quick sync failed:', cause);
+             debugger_1.default.error(new Error('Failed to quick sync', { cause }));
+         }
+     }
+@@ -327,8 +332,10 @@ class DopEngine extends events_1.default {
+                 continue;
+             }
+             // eslint-disable-next-line no-await-in-loop
++            console.log(`Scanning UTXO history for txid version ${txidVersion} on chain ${chain.type}:${chain.id}...`);
+             await this.scanUTXOHistory(txidVersion, chain, walletIdFilter);
+         }
++        console.log("Finished scanning UTXO history");
+         await this.scanTXIDHistoryV2(chain);
+     }
+     /**
+@@ -880,6 +887,7 @@ class DopEngine extends events_1.default {
+         await this.syncDopTransactionsV2(chain, 'reset after txid index');
+     }
+     static async validateMerkleroot(txidVersion, chain, tree, _index, merkleroot) {
++
+         switch (txidVersion) {
+             case poi_types_1.TXIDVersion.V2_PoseidonMerkle:
+                 return contract_store_1.ContractStore.dopSmartWalletContracts
+@@ -901,7 +909,9 @@ class DopEngine extends events_1.default {
+      */
+     async loadNetwork(chain, dopSmartWalletContractAddress, relayAdaptV2ContractAddress, poseidonMerkleAccumulatorV3Address, poseidonMerkleVerifierV3Address, tokenVaultV3Address, defaultProvider, pollingProvider, deploymentBlocks, supportsV3) {
+         debugger_1.default.log(`loadNetwork: ${chain.type}:${chain.id}`);
++        console.log(`Loading network: ${chain.type}:${chain.id}`);
+         try {
++            console.log(`Waiting for default RPC provider to connect...`);
+             await (0, promises_1.promiseTimeout)(defaultProvider.getBlockNumber(), 60_000, 'Timed out waiting for default RPC provider to connect.');
+         }
+         catch (cause) {
+@@ -946,14 +956,19 @@ class DopEngine extends events_1.default {
+             contract_store_1.ContractStore.poseidonMerkleVerifierV3Contracts.set(null, chain, new poseidon_merkle_verifier_1.PoseidonMerkleVerifierContract(poseidonMerkleVerifierV3Address, defaultProvider));
+             contract_store_1.ContractStore.tokenVaultV3Contracts.set(null, chain, new token_vault_contract_1.TokenVaultContract(tokenVaultV3Address, defaultProvider));
+         }
++        console.log(`Setting up merkletrees for ${chain.type}:${chain.id} ACTIVE_TXID_VERSIONS=${poi_types_1.ACTIVE_TXID_VERSIONS.join(', ')}   `);
+         for (const txidVersion of poi_types_1.ACTIVE_UTXO_MERKLETREE_TXID_VERSIONS) {
+             // eslint-disable-next-line no-await-in-loop
++            console.log(`Setting up UTXO merkletree for ${chain.type}:${chain.id} - ${txidVersion}`);
++            console.log(`Validating UTXO merkleroot for ${chain.type}:${chain.id} - ${txidVersion}`);
+             const utxoMerkletree = await utxo_merkletree_1.UTXOMerkletree.create(this.db, chain, txidVersion, 
+             // eslint-disable-next-line @typescript-eslint/no-shadow
+             (txidVersion, chain, tree, index, merkleroot) => DopEngine.validateMerkleroot(txidVersion, chain, tree, index, merkleroot));
++            console.log(`UTXO merkletree created for ${chain.type}:${chain.id} - ${txidVersion}`);
+             this.utxoMerkletrees.set(txidVersion, chain, utxoMerkletree);
+             // Load utxo merkletree to all wallets
+             // eslint-disable-next-line no-await-in-loop
++            console.log(`Loading UTXO merkletree to wallets for ${chain.type}:${chain.id} - ${txidVersion}`);
+             await Promise.all(Object.values(this.wallets).map(async (wallet) => {
+                 await wallet.loadUTXOMerkletree(txidVersion, utxoMerkletree);
+             }));
+@@ -962,6 +977,7 @@ class DopEngine extends events_1.default {
+                 // Wallet Txid merkletree
+                 const autoValidate = async () => true;
+                 // eslint-disable-next-line no-await-in-loop
++                console.log(`Setting up TXID merkletree for ${chain.type}:${chain.id} - ${txidVersion}`);
+                 txidMerkletree = await txid_merkletree_1.TXIDMerkletree.createForWallet(this.db, chain, txidVersion, 
+                 // For V3, we receive events in realtime, and validation is done via on-chain verificationHash field.
+                 supportsV3 ? autoValidate : this.validateDopTxidMerkleroot);
+@@ -978,6 +994,7 @@ class DopEngine extends events_1.default {
+         if (this.skipMerkletreeScans) {
+             return;
+         }
++        console.log(`Setting up merkletrees for ${chain.type}:${chain.id}`);
+         // Set up listeners
+         const commitmentListener = async (txidVersion, commitmentEvents) => {
+             await this.commitmentListener(txidVersion, chain, commitmentEvents, true, // shouldUpdateTrees
+@@ -990,6 +1007,7 @@ class DopEngine extends events_1.default {
+                 false);
+             }
+         };
++        console.log(`Setting commitment listener for ${chain.type}:${chain.id}`);
+         const nullifierListener = async (txidVersion, nullifiers) => {
+             await this.nullifierListener(txidVersion, chain, nullifiers);
+             // Only start wallet balance decryption if utxoMerkletree is not already scanning
+@@ -1003,6 +1021,7 @@ class DopEngine extends events_1.default {
+         const decryptListener = async (txidVersion, decrypts) => {
+             await this.decryptListener(txidVersion, chain, decrypts);
+         };
++        console.log(`Setting merkletree listeners for ${chain.type}:${chain.id}`);
+         await contract_store_1.ContractStore.dopSmartWalletContracts
+             .get(null, chain)
+             ?.setTreeUpdateListeners(commitmentListener, nullifierListener, decryptListener);
+@@ -1025,6 +1044,7 @@ class DopEngine extends events_1.default {
+                     false);
+                 }
+             };
++            console.log(`Setting V3 merkletree listeners for ${chain.type}:${chain.id}`);
+             await contract_store_1.ContractStore.poseidonMerkleAccumulatorV3Contracts
+                 .get(null, chain)
+                 ?.setTreeUpdateListeners(commitmentListenerV3, // No wallet scans
+@@ -1293,7 +1313,9 @@ class DopEngine extends events_1.default {
+      * @returns id
+      */
+     async createWalletFromMnemonic(encryptionKey, mnemonic, index = 0, creationBlockNumbers = undefined) {
++        console.log('Creating wallet from mnemonic...');
+         const wallet = await dop_wallet_1.DopWallet.fromMnemonic(this.db, encryptionKey, mnemonic, index, creationBlockNumbers, this.prover);
++        console.log('Wallet created. Loading wallet...');
+         await this.loadWallet(wallet);
+         return wallet;
+     }
+diff --git a/node_modules/dop-engine-v3/dist/merkletree/merkletree.js b/node_modules/dop-engine-v3/dist/merkletree/merkletree.js
+index 8ca9cd7..aa1b812 100644
+--- a/node_modules/dop-engine-v3/dist/merkletree/merkletree.js
++++ b/node_modules/dop-engine-v3/dist/merkletree/merkletree.js
+@@ -272,9 +272,19 @@ class Merkletree {
+     }
+     async getMetadataFromStorage() {
+         const storedMetadata = await this.getMerkletreesMetadata();
++
+         if (!storedMetadata) {
++            console.warn('No metadata found, starting fresh');
+             return;
+         }
++        
++        // Validate metadata structure
++        if (typeof storedMetadata !== 'object' || !storedMetadata.trees) {
++            console.warn('Invalid metadata format (expected object with trees property), got:', typeof storedMetadata, storedMetadata);
++            console.log('Clearing corrupted metadata and starting fresh');
++            return;
++        }
++        
+         const treeKeys = Object.keys(storedMetadata.trees);
+         for (const treeKey of treeKeys) {
+             const tree = Number(treeKey);
+@@ -292,10 +302,17 @@ class Merkletree {
+      */
+     async getMerkletreesMetadata() {
+         try {
+-            const metadata = msgpack_lite_1.default.decode(bytes_1.ByteUtils.arrayify((await this.db.get(this.getMerkletreeDBPrefix()))));
++            const rawData = await this.db.get(this.getMerkletreeDBPrefix());
++            if (rawData == null || rawData === undefined) {
++                console.warn('No merkletree metadata found in DB (first time setup)');
++                return undefined;
++            }
++            const metadata = msgpack_lite_1.default.decode(bytes_1.ByteUtils.arrayify(rawData));
++            console.log('Successfully decoded merkletree metadata');
+             return metadata;
+         }
+-        catch {
++        catch (err) {
++            console.log('Error fetching merkletree metadata:', err);
+             return undefined;
+         }
+     }
 diff --git a/node_modules/dop-engine-v3/dist/utils/keys-utils.js b/node_modules/dop-engine-v3/dist/utils/keys-utils.js
-index c6e9aca..653041a 100644
+index c6e9aca..dd634ae 100644
 --- a/node_modules/dop-engine-v3/dist/utils/keys-utils.js
 +++ b/node_modules/dop-engine-v3/dist/utils/keys-utils.js
-@@ -7,6 +7,11 @@ const poseidon_1 = require("./poseidon");
+@@ -7,11 +7,30 @@ const poseidon_1 = require("./poseidon");
  const bytes_1 = require("./bytes");
  const hash_1 = require("./hash");
  const scalar_multiply_1 = require("./scalar-multiply");
@@ -10,7 +203,64 @@ index c6e9aca..653041a 100644
 +
 +ed25519_1.utils.sha512 = hashes.sha512;
 +ed25519_1.utils.sha512Async = (m) => Promise.resolve(hashes.sha512(m));
++
++// Helper function to convert Uint8Array to Buffer without causing React Native issues
++// This handles the case where Buffer polyfill may not work properly with Uint8Array
++function safeUint8ArrayToBuffer(uint8Array) {
++    if (Buffer.isBuffer(uint8Array)) {
++        return uint8Array;
++    }
++    // Create buffer using array notation instead of Buffer.from to avoid to-buffer module issues
++    const buffer = Buffer.allocUnsafe(uint8Array.length);
++    for (let i = 0; i < uint8Array.length; i++) {
++        buffer[i] = uint8Array[i];
++    }
++    return buffer;
++}
 +
  const { bytesToHex, randomBytes } = ed25519_1.utils;
  function getPublicSpendingKey(privateKey) {
      if (privateKey.length !== 32)
+         throw Error('Invalid private key length');
+-    return circomlibjs_1.eddsa.prv2pub(Buffer.from(privateKey));
++    return circomlibjs_1.eddsa.prv2pub(safeUint8ArrayToBuffer(privateKey));
+ }
+ exports.getPublicSpendingKey = getPublicSpendingKey;
+ async function getPublicViewingKey(privateViewingKey) {
+@@ -23,7 +42,7 @@ function getRandomScalar() {
+ }
+ exports.getRandomScalar = getRandomScalar;
+ function signEDDSA(privateKey, message) {
+-    return circomlibjs_1.eddsa.signPoseidon(Buffer.from(privateKey), message);
++    return circomlibjs_1.eddsa.signPoseidon(safeUint8ArrayToBuffer(privateKey), message);
+ }
+ exports.signEDDSA = signEDDSA;
+ function verifyEDDSA(message, signature, pubkey) {
+diff --git a/node_modules/dop-engine-v3/dist/wallet/abstract-wallet.js b/node_modules/dop-engine-v3/dist/wallet/abstract-wallet.js
+index f80d71f..d7b13da 100644
+--- a/node_modules/dop-engine-v3/dist/wallet/abstract-wallet.js
++++ b/node_modules/dop-engine-v3/dist/wallet/abstract-wallet.js
+@@ -1695,6 +1695,7 @@ class AbstractWallet extends events_1.default {
+         return msgpack_lite_1.default.decode(bytes_1.ByteUtils.fastHexToBytes(await db.getEncrypted(AbstractWallet.dbPath(id), encryptionKey)));
+     }
+     static async write(db, id, encryptionKey, data) {
++        console.log('Writing wallet data to db...');
+         await db.putEncrypted(AbstractWallet.dbPath(id), encryptionKey, msgpack_lite_1.default.encode(data));
+     }
+     static async delete(db, id) {
+diff --git a/node_modules/dop-engine-v3/dist/wallet/dop-wallet.js b/node_modules/dop-engine-v3/dist/wallet/dop-wallet.js
+index d0dcdad..55c1fad 100644
+--- a/node_modules/dop-engine-v3/dist/wallet/dop-wallet.js
++++ b/node_modules/dop-engine-v3/dist/wallet/dop-wallet.js
+@@ -63,7 +63,10 @@ class DopWallet extends abstract_wallet_1.AbstractWallet {
+     static async fromMnemonic(db, encryptionKey, mnemonic, index, creationBlockNumbers, prover) {
+         const id = DopWallet.generateID(mnemonic, index);
+         // Write encrypted mnemonic to DB
+-        await abstract_wallet_1.AbstractWallet.write(db, id, encryptionKey, { mnemonic, index, creationBlockNumbers });
++        try {
++            await abstract_wallet_1.AbstractWallet.write(db, id, encryptionKey, { mnemonic, index, creationBlockNumbers });
++        } catch (error) {
++        }
+         return this.createWallet(id, db, mnemonic, index, creationBlockNumbers, prover);
+     }
+     /**