@pushchain/core 2.0.21 → 2.1.1-alpha-v0

package/src/lib/orchestrator/orchestrator.js

@@ -82,8 +82,9 @@ class Orchestrator {
                         if (!(chain === enums_1.CHAIN.ETHEREUM_SEPOLIA ||
                             chain === enums_1.CHAIN.ARBITRUM_SEPOLIA ||
                             chain === enums_1.CHAIN.BASE_SEPOLIA ||
+                            chain === enums_1.CHAIN.BNB_TESTNET ||
                             chain === enums_1.CHAIN.SOLANA_DEVNET)) {
-                            throw new Error('Funds bridging is only supported on Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, and Solana Devnet for now');
+                            throw new Error('Funds bridging is only supported on Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, BNB Testnet, and Solana Devnet for now');
                         }
                         // Progress: Origin chain detected
                         this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_01, chain);
@@ -438,7 +439,7 @@ class Orchestrator {
                                         bridgeAmount,
                                         universalPayload,
                                         revertCFG,
-                                        eip712SignatureHex,
+                                        '0x',
                                     ],
                                     signer: this.universalSigner,
                                     value: nativeAmount,
@@ -698,7 +699,7 @@ class Orchestrator {
                     to: payloadTo,
                     value: execute.value,
                     data: payloadData,
-                    gasLimit: execute.gasLimit || BigInt(1e7),
+                    gasLimit: execute.gasLimit || BigInt(5e7),
                     maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
                     maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
                     nonce,
@@ -734,28 +735,101 @@ class Orchestrator {
                 }
                 else {
                     /**
-                     * Fee Locking
+                     * Fee Locking - For all chains, EVM and Solana
                      */
                     const fundDifference = requiredFunds - funds;
                     const fixedPushAmount = push_chain_1.PushChain.utils.helpers.parseUnits('0.001', 18); // Minimum lock 0.001 Push tokens
                     const lockAmount = funds < requiredFunds ? fundDifference : fixedPushAmount;
                     const lockAmountInUSD = this.pushClient.pushToUSDC(lockAmount);
                     this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_05_01, lockAmount);
-                    const feeLockTxHashBytes = yield this.lockFee(lockAmountInUSD, executionHash);
+                    const feeLockTxHashBytes = yield this.lockFee(lockAmountInUSD, universalPayload);
                     feeLockTxHash = (0, viem_1.bytesToHex)(feeLockTxHashBytes);
                     verificationData = (0, viem_1.bytesToHex)(feeLockTxHashBytes);
-                    /**
-                     * Waiting for Confirmations
-                     */
                     const { vm } = chain_1.CHAIN_INFO[chain];
                     this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_05_02, vm === enums_1.VM.SVM
                         ? anchor_1.utils.bytes.bs58.encode(feeLockTxHashBytes)
                         : feeLockTxHash, chain_1.CHAIN_INFO[chain].confirmations);
+                    // Waiting for blocks confirmations
                     yield this.waitForLockerFeeConfirmation(feeLockTxHashBytes);
                     this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_05_03);
+                    // Query nodes via gRPC for Push Chain transaction
+                    const { defaultRPC, lockerContract } = chain_1.CHAIN_INFO[chain];
+                    yield this.queryUniversalTxStatusFromGatewayTx(new evm_client_1.EvmClient({ rpcUrls: this.rpcUrls[chain] || defaultRPC }), lockerContract, feeLockTxHash, 'sendTxWithGas');
+                    /**
+                     * Return response directly (skip sendUniversalTx for sendTxWithGas flow)
+                     * Note: queryTx may be undefined since validators don't recognize new UniversalTx event yet
+                     */
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06);
+                    // Transform to UniversalTxResponse (follow sendFunds pattern)
+                    if (vm === enums_1.VM.EVM) {
+                        // Get EVM transaction for full response
+                        const evmClient = new evm_client_1.EvmClient({
+                            rpcUrls: this.rpcUrls[chain] || chain_1.CHAIN_INFO[chain].defaultRPC,
+                        });
+                        const tx = yield evmClient.getTransaction(feeLockTxHash);
+                        const response = yield this.transformToUniversalTxResponse(tx);
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01, [response]);
+                        return response;
+                    }
+                    else {
+                        // SVM: build minimal response (follow sendFunds SVM pattern)
+                        const chainId = chain_1.CHAIN_INFO[chain].chainId;
+                        const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${this.universalSigner.account.address}`;
+                        const response = {
+                            hash: anchor_1.utils.bytes.bs58.encode(feeLockTxHashBytes),
+                            origin,
+                            blockNumber: BigInt(0),
+                            blockHash: '',
+                            transactionIndex: 0,
+                            chainId,
+                            from: this.universalSigner.account.address,
+                            to: '0x0000000000000000000000000000000000000000',
+                            nonce: 0,
+                            data: '0x',
+                            value: BigInt(0),
+                            gasLimit: BigInt(0),
+                            gasPrice: undefined,
+                            maxFeePerGas: undefined,
+                            maxPriorityFeePerGas: undefined,
+                            accessList: [],
+                            wait: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                                return ({
+                                    hash: anchor_1.utils.bytes.bs58.encode(feeLockTxHashBytes),
+                                    blockNumber: BigInt(0),
+                                    blockHash: '',
+                                    transactionIndex: 0,
+                                    from: this.universalSigner.account.address,
+                                    to: '0x0000000000000000000000000000000000000000',
+                                    contractAddress: null,
+                                    gasPrice: BigInt(0),
+                                    gasUsed: BigInt(0),
+                                    cumulativeGasUsed: BigInt(0),
+                                    logs: [],
+                                    logsBloom: '0x',
+                                    status: 1,
+                                    raw: {
+                                        from: this.universalSigner.account.address,
+                                        to: '0x0000000000000000000000000000000000000000',
+                                    },
+                                });
+                            }),
+                            type: '99',
+                            typeVerbose: 'universal',
+                            signature: { r: '0x0', s: '0x0', v: 0 },
+                            raw: {
+                                from: this.universalSigner.account.address,
+                                to: '0x0000000000000000000000000000000000000000',
+                                nonce: 0,
+                                data: '0x',
+                                value: BigInt(0),
+                            },
+                        };
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01, [response]);
+                        return response;
+                    }
                 }
                 /**
-                 * Broadcasting Tx to PC
+                 * Non-fee-locking path: Broadcasting Tx to PC via sendUniversalTx
                  */
                 this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06);
                 const transactions = yield this.sendUniversalTx(isUEADeployed, feeLockTxHash, universalPayload, verificationData);
@@ -785,11 +859,11 @@ class Orchestrator {
      *
      * @param amount - Fee amount in USDC (8 Decimals)
      * @param executionHash - Optional execution payload hash (default: zeroHash)
-     * @returns Transaction hash of the locking transaction
+     * @returns Transaction hash bytes
      */
-    lockFee(amount_1) {
-        return tslib_1.__awaiter(this, arguments, void 0, function* (amount, // USD with 8 decimals
-        executionHash = viem_1.zeroHash) {
+    lockFee(amount, // USD with 8 decimals
+    universalPayload) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const chain = this.universalSigner.account.chain;
             const { lockerContract, vm, defaultRPC } = chain_1.CHAIN_INFO[chain];
             if (!lockerContract) {
@@ -804,35 +878,88 @@ class Orchestrator {
                         Promise.resolve(new evm_client_1.EvmClient({ rpcUrls })),
                     ]);
                     const nativeDecimals = 18; // ETH, MATIC, etc.
-                    const nativeAmount = (amount * BigInt(Math.pow(10, nativeDecimals))) / nativeTokenUsdPrice;
+                    // Ensure deposit respects gateway USD caps (min $1, max $10) and avoid rounding below min
+                    const oneUsd = push_chain_1.PushChain.utils.helpers.parseUnits('1', 8);
+                    const tenUsd = push_chain_1.PushChain.utils.helpers.parseUnits('10', 8);
+                    let depositUsd = amount < oneUsd ? oneUsd : amount;
+                    if (depositUsd > tenUsd)
+                        depositUsd = tenUsd;
+                    // Ceil division to avoid falling below on-chain min due to rounding, then add 1 wei safety
+                    let nativeAmount = (depositUsd * BigInt(Math.pow(10, nativeDecimals)) +
+                        (nativeTokenUsdPrice - BigInt(1))) /
+                        nativeTokenUsdPrice;
+                    nativeAmount = nativeAmount + BigInt(1);
+                    // Deposit-only funding via UniversalGatewayV0 (no payload execution)
+                    const revertCFG = {
+                        fundRecipient: this.universalSigner.account.address,
+                        revertMsg: '0x',
+                    };
+                    // Sign the universal payload
+                    const ueaAddress = this.computeUEAOffchain();
+                    const ueaVersion = yield this.fetchUEAVersion();
+                    const eip712Signature = yield this.signUniversalPayload(universalPayload, ueaAddress, ueaVersion);
+                    const eip712SignatureHex = typeof eip712Signature === 'string'
+                        ? eip712Signature
+                        : (0, viem_1.bytesToHex)(eip712Signature);
                     const txHash = yield evmClient.writeContract({
-                        abi: abi_1.FEE_LOCKER_EVM,
+                        abi: abi_1.UNIVERSAL_GATEWAY_V0,
                         address: lockerContract,
-                        functionName: 'addFunds',
-                        args: [executionHash],
+                        functionName: 'sendTxWithGas',
+                        args: [universalPayload, revertCFG, '0x'],
                         signer: this.universalSigner,
                         value: nativeAmount,
                     });
                     return (0, viem_1.hexToBytes)(txHash);
                 }
                 case enums_1.VM.SVM: {
-                    // Run price fetching, client creation, and PDA computation in parallel
-                    const [nativeTokenUsdPrice, svmClient, [lockerPda]] = yield Promise.all([
+                    // Run price fetching and client creation in parallel
+                    const [nativeTokenUsdPrice, svmClient] = yield Promise.all([
                         new price_fetch_1.PriceFetch(this.rpcUrls).getPrice(chain), // 8 decimals
                         Promise.resolve(new svm_client_1.SvmClient({ rpcUrls })),
-                        Promise.resolve(anchor.web3.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('locker')], new web3_js_1.PublicKey(lockerContract))),
                     ]);
+                    // Ensure deposit respects gateway USD caps (min $1, max $10) and avoid rounding below min
                     const nativeDecimals = 9; // SOL lamports
-                    const nativeAmount = (amount * BigInt(Math.pow(10, nativeDecimals))) / nativeTokenUsdPrice;
+                    const oneUsd = push_chain_1.PushChain.utils.helpers.parseUnits('1', 8);
+                    const tenUsd = push_chain_1.PushChain.utils.helpers.parseUnits('10', 8);
+                    let depositUsd = amount < oneUsd ? oneUsd : amount;
+                    if (depositUsd > tenUsd)
+                        depositUsd = tenUsd;
+                    // Ceil division to avoid falling below on-chain min due to rounding, then add 1 lamport safety
+                    let nativeAmount = (depositUsd * BigInt(Math.pow(10, nativeDecimals)) +
+                        (nativeTokenUsdPrice - BigInt(1))) /
+                        nativeTokenUsdPrice;
+                    nativeAmount = nativeAmount + BigInt(1);
+                    // Program & PDAs
+                    const programId = new web3_js_1.PublicKey(abi_1.SVM_GATEWAY_IDL.address);
+                    const [configPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('config')], programId);
+                    const [vaultPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('vault')], programId);
+                    const userPk = new web3_js_1.PublicKey(this.universalSigner.account.address);
+                    const revertSvm = {
+                        fundRecipient: userPk,
+                        revertMsg: Buffer.from([]),
+                    };
+                    // const ueaAddressSvm = this.computeUEAOffchain();
+                    // const ueaVersion = await this.fetchUEAVersion();
+                    // const svmSignature = await this.signUniversalPayload(
+                    //   universalPayload,
+                    //   ueaAddressSvm,
+                    //   ueaVersion
+                    // );
                     const txHash = yield svmClient.writeContract({
-                        abi: abi_1.FEE_LOCKER_SVM,
-                        address: lockerContract,
-                        functionName: 'addFunds',
-                        args: [nativeAmount, (0, viem_1.toBytes)(executionHash)],
+                        abi: abi_1.SVM_GATEWAY_IDL,
+                        address: programId.toBase58(),
+                        functionName: 'sendTxWithGas',
+                        args: [
+                            universalPayload,
+                            revertSvm,
+                            new anchor.BN(nativeAmount.toString()),
+                            '0x',
+                        ],
                         signer: this.universalSigner,
                         accounts: {
-                            locker: lockerPda,
-                            user: new web3_js_1.PublicKey(this.universalSigner.account.address),
+                            config: configPda,
+                            vault: vaultPda,
+                            user: userPk,
                             priceUpdate: new web3_js_1.PublicKey('7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE'),
                             systemProgram: web3_js_1.SystemProgram.programId,
                         },
@@ -1171,20 +1298,12 @@ class Orchestrator {
             switch (vm) {
                 case enums_1.VM.EVM: {
                     const evmClient = new evm_client_1.EvmClient({ rpcUrls });
-                    yield evmClient.waitForConfirmations({
-                        txHash: (0, viem_1.bytesToHex)(txHashBytes),
-                        confirmations,
-                        timeoutMs: timeout,
-                    });
+                    yield this.waitForEvmConfirmationsWithCountdown(evmClient, (0, viem_1.bytesToHex)(txHashBytes), confirmations, timeout);
                     return;
                 }
                 case enums_1.VM.SVM: {
                     const svmClient = new svm_client_1.SvmClient({ rpcUrls });
-                    yield svmClient.waitForConfirmations({
-                        txSignature: anchor_1.utils.bytes.bs58.encode(txHashBytes),
-                        confirmations,
-                        timeoutMs: timeout,
-                    });
+                    yield this.waitForSvmConfirmationsWithCountdown(svmClient, anchor_1.utils.bytes.bs58.encode(txHashBytes), confirmations, timeout);
                     return;
                 }
                 default:
@@ -1257,8 +1376,9 @@ class Orchestrator {
         if (chain !== enums_1.CHAIN.ETHEREUM_SEPOLIA &&
             chain !== enums_1.CHAIN.ARBITRUM_SEPOLIA &&
             chain !== enums_1.CHAIN.BASE_SEPOLIA &&
+            chain !== enums_1.CHAIN.BNB_TESTNET &&
             chain !== enums_1.CHAIN.SOLANA_DEVNET) {
-            throw new Error('Funds + payload bridging is only supported on Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, and Solana Devnet for now');
+            throw new Error('Funds + payload bridging is only supported on Ethereum Sepolia, Arbitrum Sepolia, Base Sepolia, BNB Testnet, and Solana Devnet for now');
         }
         // For EVM (Sepolia), return client and gateway address. For SVM (Solana Devnet), only chain is needed here.
         if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.EVM) {
@@ -1318,7 +1438,7 @@ class Orchestrator {
                 maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
                 nonce,
                 deadline: execute.deadline || BigInt(9999999999),
-                vType: tx_1.VerificationType.signedVerification,
+                vType: tx_1.VerificationType.universalTxVerification,
             };
             return { payload: universalPayload, gasAmount };
         });
@@ -1566,15 +1686,16 @@ class Orchestrator {
                 continue;
             const discriminatorHex = (0, viem_1.bytesToHex)(decoded.slice(0, 8)).slice(2);
             // Skip add_funds discriminator; return the first other Program data event
-            if (discriminatorHex === '7f1f6cffbb134644')
-                continue;
-            return i;
+            // if (discriminatorHex === '7f1f6cffbb134644') continue;
+            if (discriminatorHex === '6c9ad829b5ea1d7c')
+                return i;
+            // return i;
         }
         // Fallback to first log
         return 0;
     }
     // Query Push Chain for UniversalTx status given an origin gateway tx (EVM or SVM)
-    queryUniversalTxStatusFromGatewayTx(evmClient, gatewayAddress, txHash, fromBranch) {
+    queryUniversalTxStatusFromGatewayTx(evmClient, gatewayAddress, txHash, evmGatewayMethod) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             try {
@@ -1585,11 +1706,22 @@ class Orchestrator {
                 if (vm === enums_1.VM.EVM) {
                     if (!evmClient || !gatewayAddress)
                         throw new Error('Missing EVM context');
-                    const receipt = yield evmClient.publicClient.getTransactionReceipt({
-                        hash: txHash,
-                    });
+                    let receipt;
+                    try {
+                        receipt = yield evmClient.publicClient.getTransactionReceipt({
+                            hash: txHash,
+                        });
+                    }
+                    catch (_c) {
+                        // Receipt might not be indexed yet on this RPC; wait briefly for it
+                        receipt = yield evmClient.publicClient.waitForTransactionReceipt({
+                            hash: txHash,
+                            confirmations: 0,
+                            timeout: chain_1.CHAIN_INFO[chain].timeout,
+                        });
+                    }
                     const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() === gatewayAddress.toLowerCase());
-                    const logIndexToUse = fromBranch === 'sendTxWithFunds' ? 1 : 0;
+                    const logIndexToUse = evmGatewayMethod === 'sendTxWithFunds' ? 1 : 0;
                     const firstLog = (gatewayLogs[logIndexToUse] ||
                         ((_a = receipt.logs) === null || _a === void 0 ? void 0 : _a[logIndexToUse]));
                     const logIndexVal = (_b = firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex) !== null && _b !== void 0 ? _b : 0;
@@ -1657,7 +1789,7 @@ class Orchestrator {
                 // );
                 return universalTxObj;
             }
-            catch (_c) {
+            catch (_d) {
                 // Best-effort; do not fail flow if PC query is unavailable
                 this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06);
                 return undefined;
@@ -1675,15 +1807,31 @@ class Orchestrator {
                 hash: txHash,
             });
             const targetBlock = receipt.blockNumber + BigInt(confirmations);
+            // Track last emitted confirmation to avoid duplicates
+            let lastEmitted = 0;
             // Poll blocks and emit remaining confirmations
             // eslint-disable-next-line no-constant-condition
             while (true) {
                 const currentBlock = yield evmClient.publicClient.getBlockNumber();
-                if (currentBlock >= targetBlock)
+                // If already confirmed, emit progress for final confirmation
+                if (currentBlock >= targetBlock) {
+                    // Only emit if we haven't already shown this confirmation
+                    if (lastEmitted < confirmations) {
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04, confirmations, confirmations);
+                    }
                     return;
+                }
                 const remaining = Number(targetBlock - currentBlock);
                 const completed = Math.max(1, confirmations - remaining + 1);
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04, completed, confirmations);
+                // Only emit if this is a new confirmation count
+                if (completed > lastEmitted) {
+                    this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04, completed, confirmations);
+                    lastEmitted = completed;
+                    // If we've reached required confirmations, we're done
+                    if (completed >= confirmations) {
+                        return;
+                    }
+                }
                 if (Date.now() - start > timeoutMs) {
                     throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
                 }
@@ -1691,6 +1839,44 @@ class Orchestrator {
             }
         });
     }
+    // Emit countdown updates while waiting for SVM confirmations
+    waitForSvmConfirmationsWithCountdown(svmClient, txSignature, confirmations, timeoutMs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // initial emit
+            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03, confirmations);
+            const start = Date.now();
+            // Poll for confirmations and emit progress
+            let lastConfirmed = 0;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const connection = svmClient.connections[svmClient.currentConnectionIndex];
+                const { value } = yield connection.getSignatureStatuses([txSignature]);
+                const status = value[0];
+                if (status) {
+                    const currentConfirms = (_a = status.confirmations) !== null && _a !== void 0 ? _a : 0;
+                    const hasEnoughConfirmations = currentConfirms >= confirmations;
+                    const isSuccessfullyFinalized = status.err === null && status.confirmationStatus !== null;
+                    // Emit progress if we have more confirmations than before OR if finalized
+                    if (currentConfirms > lastConfirmed ||
+                        (isSuccessfullyFinalized && lastConfirmed === 0)) {
+                        const confirmCount = isSuccessfullyFinalized && currentConfirms === 0
+                            ? confirmations
+                            : currentConfirms;
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04, Math.max(1, confirmCount), confirmations);
+                        lastConfirmed = currentConfirms;
+                    }
+                    if (hasEnoughConfirmations || isSuccessfullyFinalized) {
+                        return;
+                    }
+                }
+                if (Date.now() - start > timeoutMs) {
+                    throw new Error(`Timeout: transaction ${txSignature} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
+                }
+                yield new Promise((r) => setTimeout(r, 500));
+            }
+        });
+    }
     // Fetch and cache UEA version from the contract on Push Chain
     fetchUEAVersion() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {