@pushchain/core 2.1.5 → 2.1.7-alpha-v0

package/src/lib/orchestrator/orchestrator.js

@@ -138,16 +138,48 @@ class Orchestrator {
                             const bridgeToken = execute.funds.token.mechanism === 'approve'
                                 ? tokenAddr
                                 : '0x0000000000000000000000000000000000000000';
+                            const { nonce } = yield this.getUeaStatusAndNonce();
+                            const { payload: universalPayload } = yield this.buildGatewayPayloadAndGas(execute, nonce, 'sendFunds', bridgeAmount);
+                            // Get UEA info
+                            const ueaAddress = this.computeUEAOffchain();
+                            const ueaVersion = yield this.fetchUEAVersion();
+                            const eip712Signature = yield this.signUniversalPayload(universalPayload, ueaAddress, ueaVersion);
+                            const eip712SignatureHex = (0, viem_1.bytesToHex)(eip712Signature);
                             let txHash;
                             try {
+                                // Compute minimal native amount to deposit for gas on Push Chain
+                                const ueaAddressForGas = this.computeUEAOffchain();
+                                const ueaBalanceForGas = yield this.pushClient.getBalance(ueaAddressForGas);
+                                const nativeAmount = yield this.calculateNativeAmountForDeposit(chain, BigInt(0), ueaBalanceForGas);
+                                console.log([
+                                    tokenAddr,
+                                    bridgeAmount,
+                                    universalPayload,
+                                    revertCFG,
+                                    '0x',
+                                ]);
                                 txHash = yield evmClient.writeContract({
                                     abi: abi_1.UNIVERSAL_GATEWAY_V0,
                                     address: gatewayAddress,
-                                    functionName: 'sendFunds',
-                                    args: [recipient, bridgeToken, bridgeAmount, revertCFG],
+                                    functionName: 'sendTxWithFunds',
+                                    args: [
+                                        tokenAddr,
+                                        bridgeAmount,
+                                        universalPayload,
+                                        revertCFG,
+                                        '0x',
+                                    ],
                                     signer: this.universalSigner,
-                                    value: isNative ? bridgeAmount : BigInt(0),
+                                    value: nativeAmount,
                                 });
+                                // txHash = await evmClient.writeContract({
+                                //   abi: UNIVERSAL_GATEWAY_V0 as unknown as Abi,
+                                //   address: gatewayAddress,
+                                //   functionName: 'sendFunds',
+                                //   args: [recipient, bridgeToken, bridgeAmount, revertCFG],
+                                //   signer: this.universalSigner,
+                                //   value: isNative ? bridgeAmount : BigInt(0),
+                                // });
                             }
                             catch (err) {
                                 this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_04);
@@ -333,7 +365,7 @@ class Orchestrator {
                         }
                         const mechanism = execute.funds.token.mechanism;
                         const { deployed, nonce } = yield this.getUeaStatusAndNonce();
-                        const { payload: universalPayload } = yield this.buildGatewayPayloadAndGas(execute, nonce);
+                        const { payload: universalPayload } = yield this.buildGatewayPayloadAndGas(execute, nonce, 'sendTxWithFunds');
                         this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_02_01);
                         // Compute required gas funding on Push Chain and current UEA balance
                         const gasEstimate = execute.gasLimit || BigInt(1e7);
@@ -434,6 +466,21 @@ class Orchestrator {
                                     : (0, viem_1.bytesToHex)(eip712Signature);
                                 const evmClientEvm = evmClient;
                                 const gatewayAddressEvm = gatewayAddress;
+                                // @@@@@@@@@@@@
+                                // txHash = await evmClientEvm.writeContract({
+                                //   abi: UNIVERSAL_GATEWAY_V0 as unknown as Abi,
+                                //   address: gatewayAddressEvm,
+                                //   functionName: 'sendTxWithFunds',
+                                //   args: [
+                                //     tokenAddr,
+                                //     bridgeAmount,
+                                //     universalPayload,
+                                //     revertCFG,
+                                //     '0x',
+                                //   ],
+                                //   signer: this.universalSigner,
+                                //   value: nativeAmount,
+                                // });
                                 // New behavior: if user provided a gasTokenAddress, pay gas in that token via Uniswap quote
                                 // Determine pay-with token address, min-out and slippage
                                 const payWith = execute.funds.payWith;
@@ -479,7 +526,7 @@ class Orchestrator {
                                             deadline,
                                             universalPayload,
                                             revertCFG,
-                                            eip712SignatureHex,
+                                            '0x',
                                         ],
                                         signer: this.universalSigner,
                                     });
@@ -495,7 +542,7 @@ class Orchestrator {
                                             bridgeAmount,
                                             universalPayload,
                                             revertCFG,
-                                            eip712SignatureHex,
+                                            '0x',
                                         ],
                                         signer: this.universalSigner,
                                         value: nativeAmount,
@@ -760,7 +807,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,
@@ -796,28 +843,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);
@@ -847,11 +967,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) {
@@ -866,35 +986,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,
                         },
@@ -1233,20 +1406,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:
@@ -1476,26 +1641,65 @@ class Orchestrator {
         });
     }
     /**
-     * Builds UniversalPayload for the gateway and computes the native gas deposit.
+     * For sendFunds, we will call internally the sendTxWithFunds.
      */
-    buildGatewayPayloadAndGas(execute, nonce) {
+    buildGatewayPayloadAndGas(execute, nonce, type, fundsValue) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const gasEstimate = execute.gasLimit || BigInt(1e7);
             const payloadValue = (_a = execute.value) !== null && _a !== void 0 ? _a : BigInt(0);
             const gasAmount = (_b = execute.value) !== null && _b !== void 0 ? _b : BigInt(0);
-            const universalPayload = {
-                to: execute.to,
-                value: payloadValue,
-                data: execute.data || '0x',
-                gasLimit: gasEstimate,
-                maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
-                maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
-                nonce,
-                deadline: execute.deadline || BigInt(9999999999),
-                vType: tx_1.VerificationType.signedVerification,
-            };
-            return { payload: universalPayload, gasAmount };
+            // @@@@@@@@@@@@
+            // const universalPayload = {
+            //   to: execute.to,
+            //   value: payloadValue,
+            //   data: execute.data || '0x',
+            //   gasLimit: gasEstimate,
+            //   maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
+            //   maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
+            //   nonce,
+            //   deadline: execute.deadline || BigInt(9999999999),
+            //   vType: VerificationType.universalTxVerification,
+            // } as unknown as never;
+            if (type === 'sendTxWithFunds') {
+                if (fundsValue)
+                    throw new Error('fundsValue property must be empty');
+                const universalPayload = {
+                    to: execute.to,
+                    value: payloadValue,
+                    data: execute.data || '0x',
+                    gasLimit: gasEstimate,
+                    maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
+                    maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
+                    nonce,
+                    deadline: execute.deadline || BigInt(9999999999),
+                    vType: tx_1.VerificationType.universalTxVerification,
+                };
+                return { payload: universalPayload, gasAmount };
+            }
+            else {
+                if (!fundsValue)
+                    throw new Error('fundsValue property must not be empty');
+                // The data will be the abi-encoded transfer function from erc-20 function. The recipient will be `execute.to`, the value
+                // will be the fundsValue property.
+                const data = (0, viem_1.encodeFunctionData)({
+                    abi: abi_1.ERC20_EVM,
+                    functionName: 'transfer',
+                    args: [execute.to, fundsValue],
+                });
+                const universalPayload = {
+                    to: viem_1.zeroAddress, // We can't simply do `0x` because we will get an error when eip712 signing the transaction.
+                    value: payloadValue,
+                    data,
+                    gasLimit: gasEstimate,
+                    maxFeePerGas: execute.maxFeePerGas || BigInt(1e10),
+                    maxPriorityFeePerGas: execute.maxPriorityFeePerGas || BigInt(0),
+                    nonce,
+                    deadline: execute.deadline || BigInt(9999999999),
+                    vType: tx_1.VerificationType.universalTxVerification,
+                };
+                return { payload: universalPayload, gasAmount };
+            }
         });
     }
     /********************************** HELPER FUNCTIONS **************************************************/
@@ -1741,15 +1945,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 {
@@ -1760,11 +1965,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;
@@ -1832,7 +2048,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;
@@ -1850,15 +2066,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`);
                 }
@@ -1866,6 +2098,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* () {
@@ -1931,6 +2201,63 @@ class Orchestrator {
             return { gasAmount };
         });
     }
+    calculateNativeAmountForDeposit(chain, requiredFunds, ueaBalance) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // Determine USD to deposit via gateway (8 decimals) with caps: min=$1, max=$10
+            const oneUsd = push_chain_1.PushChain.utils.helpers.parseUnits('1', 8);
+            const tenUsd = push_chain_1.PushChain.utils.helpers.parseUnits('10', 8);
+            const deficit = requiredFunds > ueaBalance ? requiredFunds - ueaBalance : BigInt(0);
+            let depositUsd = deficit > BigInt(0) ? this.pushClient.pushToUSDC(deficit) : oneUsd;
+            if (depositUsd < oneUsd)
+                depositUsd = oneUsd;
+            if (depositUsd > tenUsd)
+                throw new Error('Deposit value exceeds max $10 worth of native token');
+            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_02_02, depositUsd);
+            // If SVM, clamp depositUsd to on-chain Config caps
+            if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM) {
+                const svmClient = new svm_client_1.SvmClient({
+                    rpcUrls: this.rpcUrls[enums_1.CHAIN.SOLANA_DEVNET] ||
+                        chain_1.CHAIN_INFO[enums_1.CHAIN.SOLANA_DEVNET].defaultRPC,
+                });
+                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);
+                try {
+                    const cfg = yield svmClient.readContract({
+                        abi: abi_1.SVM_GATEWAY_IDL,
+                        address: abi_1.SVM_GATEWAY_IDL.address,
+                        functionName: 'config',
+                        args: [configPda.toBase58()],
+                    });
+                    const minField = (_a = cfg.minCapUniversalTxUsd) !== null && _a !== void 0 ? _a : cfg.min_cap_universal_tx_usd;
+                    const maxField = (_b = cfg.maxCapUniversalTxUsd) !== null && _b !== void 0 ? _b : cfg.max_cap_universal_tx_usd;
+                    const minCapUsd = BigInt(minField.toString());
+                    const maxCapUsd = BigInt(maxField.toString());
+                    if (depositUsd < minCapUsd)
+                        depositUsd = minCapUsd;
+                    // Add 20% safety margin to avoid BelowMinCap due to price drift
+                    const withMargin = (minCapUsd * BigInt(12)) / BigInt(10);
+                    if (depositUsd < withMargin)
+                        depositUsd = withMargin;
+                    if (depositUsd > maxCapUsd)
+                        depositUsd = maxCapUsd;
+                }
+                catch (_c) {
+                    // best-effort; fallback to previous bounds if read fails
+                }
+            }
+            // Convert USD(8) -> native units using pricing path
+            const nativeTokenUsdPrice = yield new price_fetch_1.PriceFetch(this.rpcUrls).getPrice(chain); // 8 decimals
+            const nativeDecimals = chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM ? 9 : 18;
+            const oneNativeUnit = push_chain_1.PushChain.utils.helpers.parseUnits('1', nativeDecimals);
+            // Ceil division to avoid rounding below min USD on-chain
+            let nativeAmount = (depositUsd * oneNativeUnit + (nativeTokenUsdPrice - BigInt(1))) /
+                nativeTokenUsdPrice;
+            // Add 1 unit safety to avoid BelowMinCap from rounding differences
+            nativeAmount = nativeAmount + BigInt(1);
+            return nativeAmount;
+        });
+    }
 }
 exports.Orchestrator = Orchestrator;
 //# sourceMappingURL=orchestrator.js.map