@pushchain/core 2.0.1 → 2.0.3

package/src/lib/orchestrator/orchestrator.js

@@ -18,6 +18,7 @@ const anchor_1 = require("@coral-xyz/anchor");
 const progress_hook_types_1 = require("../progress-hook/progress-hook.types");
 const progress_hook_1 = tslib_1.__importDefault(require("../progress-hook/progress-hook"));
 const uea_evm_1 = require("../constants/abi/uea.evm");
+const tokens_1 = require("../constants/tokens");
 class Orchestrator {
     constructor(universalSigner, pushNetwork, rpcUrls = {}, printTraces = false, progressHook) {
         this.universalSigner = universalSigner;
@@ -62,7 +63,555 @@ class Orchestrator {
      */
     execute(execute) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             try {
+                // FUNDS_TX short-circuit: Bridge tokens from origin chain to Push Chain
+                // - EVM (Sepolia): UniversalGatewayV0
+                // - SVM (Solana Devnet): pushsolanagateway
+                if (execute.funds) {
+                    if (!execute.data || execute.data === '0x') {
+                        // Disallow user-provided `value` for funds-only bridging. The SDK derives
+                        // origin-chain msg.value automatically from the funds input:
+                        //  - Native path: msg.value = bridgeAmount
+                        //  - ERC-20 path: msg.value = 0
+                        if (execute.value !== undefined && execute.value !== BigInt(0)) {
+                            throw new Error('Do not set `value` when using funds bridging; the SDK sets origin msg.value from `funds.amount` automatically');
+                        }
+                        const chain = this.universalSigner.account.chain;
+                        const { vm } = chain_1.CHAIN_INFO[chain];
+                        if (!(chain === enums_1.CHAIN.ETHEREUM_SEPOLIA)) {
+                            throw new Error('Funds bridging is only supported on Ethereum Sepolia for now');
+                        }
+                        // Progress: Origin chain detected
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_01, chain);
+                        const { defaultRPC, lockerContract } = chain_1.CHAIN_INFO[chain];
+                        const rpcUrls = this.rpcUrls[chain] || defaultRPC;
+                        // Resolve token: default to native token based on VM (ETH for EVM, SOL for SVM)
+                        if (!execute.funds.token) {
+                            const available = tokens_1.MOVEABLE_TOKENS[chain] || [];
+                            const vm = chain_1.CHAIN_INFO[chain].vm;
+                            const preferredSymbol = vm === enums_1.VM.EVM ? 'ETH' : vm === enums_1.VM.SVM ? 'SOL' : undefined;
+                            const nativeToken = preferredSymbol
+                                ? available.find((t) => t.symbol === preferredSymbol)
+                                : undefined;
+                            if (!nativeToken) {
+                                throw new Error('Native token not configured for this chain');
+                            }
+                            execute.funds.token = nativeToken;
+                        }
+                        const amount = execute.funds.amount;
+                        const symbol = execute.funds.token.symbol;
+                        // Funds Flow: Preparing funds transfer
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_01, amount, execute.funds.token.decimals, symbol);
+                        if (vm === enums_1.VM.EVM) {
+                            const evmClient = new evm_client_1.EvmClient({ rpcUrls });
+                            const gatewayAddress = lockerContract;
+                            const tokenAddr = execute.funds.token.address;
+                            // Approve gateway to pull tokens if ERC-20 (not native sentinel)
+                            if (execute.funds.token.mechanism === 'approve') {
+                                yield this.ensureErc20Allowance(evmClient, tokenAddr, gatewayAddress, amount);
+                            }
+                            else if (execute.funds.token.mechanism === 'permit2') {
+                                throw new Error('Permit2 is not supported yet');
+                            }
+                            else if (execute.funds.token.mechanism === 'native') {
+                                // Native flow uses msg.value == bridgeAmount and bridgeToken = address(0)
+                            }
+                        }
+                        const bridgeAmount = amount;
+                        const revertCFG = {
+                            fundRecipient: this.universalSigner.account
+                                .address,
+                            revertMsg: '0x',
+                        }; // typed by viem via ABI
+                        if (vm === enums_1.VM.EVM) {
+                            const evmClient = new evm_client_1.EvmClient({ rpcUrls });
+                            const gatewayAddress = lockerContract;
+                            const tokenAddr = execute.funds.token.address;
+                            // Call UniversalGatewayV0.sendFunds(recipient, bridgeToken, bridgeAmount, revertCFG)
+                            const recipient = execute.to; // funds to recipient on Push Chain
+                            const isNative = execute.funds.token.mechanism === 'native';
+                            const bridgeToken = execute.funds.token.mechanism === 'approve'
+                                ? tokenAddr
+                                : '0x0000000000000000000000000000000000000000';
+                            let txHash;
+                            try {
+                                txHash = yield evmClient.writeContract({
+                                    abi: abi_1.UNIVERSAL_GATEWAY_V0,
+                                    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);
+                                throw err;
+                            }
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_03);
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_02, txHash, bridgeAmount, execute.funds.token.decimals, symbol);
+                            yield this.waitForEvmConfirmationsWithCountdown(evmClient, txHash, 14, 210000);
+                            // After origin confirmations, query Push Chain for UniversalTx status
+                            try {
+                                const receipt = yield evmClient.publicClient.getTransactionReceipt({
+                                    hash: txHash,
+                                });
+                                const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() ===
+                                    gatewayAddress.toLowerCase());
+                                const firstLog = (gatewayLogs[0] || ((_a = receipt.logs) === null || _a === void 0 ? void 0 : _a[0]));
+                                const logIndexVal = (_b = firstLog === null || firstLog === void 0 ? void 0 : firstLog.logIndex) !== null && _b !== void 0 ? _b : 0;
+                                const logIndexStr = typeof logIndexVal === 'bigint'
+                                    ? logIndexVal.toString()
+                                    : String(logIndexVal);
+                                const sourceChain = `${chain_1.VM_NAMESPACE[vm]}:${chain_1.CHAIN_INFO[this.universalSigner.account.chain].chainId}`;
+                                // ID = sha256("${sourceChain}:${txHash}:${logIndex}") as hex string (no 0x)
+                                const idInput = `${sourceChain}:${txHash}:${logIndexStr}`;
+                                const idHex = (0, viem_1.sha256)((0, viem_1.stringToBytes)(idInput)).slice(2);
+                                // Fetch UniversalTx via gRPC with a brief retry window
+                                let universalTxObj;
+                                for (let attempt = 0; attempt < 10; attempt++) {
+                                    try {
+                                        const universalTxResp = yield this.pushClient.getUniversalTxById(idHex);
+                                        universalTxObj = universalTxResp === null || universalTxResp === void 0 ? void 0 : universalTxResp.universalTx;
+                                        if (universalTxObj)
+                                            break;
+                                    }
+                                    catch (_d) {
+                                        // ignore and retry
+                                    }
+                                    yield new Promise((r) => setTimeout(r, 1500));
+                                }
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06, (universalTxObj === null || universalTxObj === void 0 ? void 0 : universalTxObj.universalStatus) ||
+                                    (universalTxObj === null || universalTxObj === void 0 ? void 0 : universalTxObj.universal_status));
+                            }
+                            catch (_e) {
+                                // Best-effort; do not fail flow if PC query is unavailable
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06);
+                            }
+                            const tx = yield evmClient.getTransaction(txHash);
+                            return yield this.transformToUniversalTxResponse(tx);
+                        }
+                        else {
+                            // SVM path (Solana Devnet)
+                            const svmClient = new svm_client_1.SvmClient({ rpcUrls });
+                            const programId = new web3_js_1.PublicKey(abi_1.SVM_GATEWAY_IDL.metadata.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);
+                            let txSignature;
+                            // SVM-specific RevertSettings: bytes must be a Buffer
+                            const revertSvm = {
+                                fundRecipient: userPk,
+                                revertMsg: Buffer.alloc(0),
+                            };
+                            if (execute.funds.token.mechanism === 'native') {
+                                // Native SOL funds-only
+                                const recipientPk = userPk; // must be non-default per program checks
+                                console.log('recipientPk', recipientPk);
+                                console.log('bridgeAmount', bridgeAmount);
+                                console.log('userPk', userPk);
+                                console.log('configPda', configPda);
+                                console.log('vaultPda', vaultPda);
+                                console.log('systemProgram', web3_js_1.SystemProgram.programId);
+                                console.log('programId', programId.toBase58());
+                                console.log('SVM_GATEWAY_IDL', abi_1.SVM_GATEWAY_IDL);
+                                console.log('sendFundsNative', 'sendFundsNative');
+                                console.log('args', [
+                                    recipientPk,
+                                    bridgeAmount,
+                                    { fundRecipient: userPk, revertMsg: new Uint8Array([]) },
+                                ]);
+                                console.log('signer', this.universalSigner);
+                                console.log('accounts', {
+                                    config: configPda,
+                                    vault: vaultPda,
+                                    user: userPk,
+                                    systemProgram: web3_js_1.SystemProgram.programId,
+                                });
+                                txSignature = yield svmClient.writeContract({
+                                    abi: abi_1.SVM_GATEWAY_IDL,
+                                    address: programId.toBase58(),
+                                    functionName: 'sendFundsNative',
+                                    args: [recipientPk, bridgeAmount, revertSvm],
+                                    signer: this.universalSigner,
+                                    accounts: {
+                                        config: configPda,
+                                        vault: vaultPda,
+                                        user: userPk,
+                                        systemProgram: web3_js_1.SystemProgram.programId,
+                                    },
+                                });
+                            }
+                            else if (execute.funds.token.mechanism === 'approve') {
+                                // SPL token funds-only (requires pre-existing ATAs)
+                                const mintPk = new web3_js_1.PublicKey(execute.funds.token.address);
+                                const [whitelistPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                                // Associated Token Accounts
+                                const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+                                const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+                                const userAta = web3_js_1.PublicKey.findProgramAddressSync([
+                                    userPk.toBuffer(),
+                                    TOKEN_PROGRAM_ID.toBuffer(),
+                                    mintPk.toBuffer(),
+                                ], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+                                const vaultAta = web3_js_1.PublicKey.findProgramAddressSync([
+                                    vaultPda.toBuffer(),
+                                    TOKEN_PROGRAM_ID.toBuffer(),
+                                    mintPk.toBuffer(),
+                                ], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+                                const recipientPk = userPk; // must be non-default per program checks
+                                txSignature = yield svmClient.writeContract({
+                                    abi: abi_1.SVM_GATEWAY_IDL,
+                                    address: programId.toBase58(),
+                                    functionName: 'sendFunds',
+                                    args: [recipientPk, mintPk, bridgeAmount, revertSvm],
+                                    signer: this.universalSigner,
+                                    accounts: {
+                                        config: configPda,
+                                        vault: vaultPda,
+                                        tokenWhitelist: whitelistPda,
+                                        userTokenAccount: userAta,
+                                        gatewayTokenAccount: vaultAta,
+                                        user: userPk,
+                                        bridgeToken: mintPk,
+                                        tokenProgram: TOKEN_PROGRAM_ID,
+                                        systemProgram: web3_js_1.SystemProgram.programId,
+                                    },
+                                });
+                            }
+                            else {
+                                throw new Error('Unsupported token mechanism on Solana');
+                            }
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_03);
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_02, txSignature, bridgeAmount, execute.funds.token.decimals, symbol);
+                            yield svmClient.waitForConfirmations({
+                                txSignature,
+                                confirmations: chain_1.CHAIN_INFO[chain].confirmations,
+                                timeoutMs: chain_1.CHAIN_INFO[chain].timeout,
+                            });
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06);
+                            // Build a minimal UniversalTxResponse for SVM origin
+                            const chainId = chain_1.CHAIN_INFO[chain].chainId;
+                            const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${this.universalSigner.account.address}`;
+                            const universalTxResponse = {
+                                hash: txSignature,
+                                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: txSignature,
+                                        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),
+                                },
+                            };
+                            return universalTxResponse;
+                        }
+                    }
+                    else {
+                        // Bridge funds + execute payload. Support:
+                        // - EVM (Sepolia): ERC-20 approve path + native gas via msg.value
+                        // - SVM (Solana Devnet): SPL or native SOL with gas_amount
+                        const { chain, evmClient, gatewayAddress } = this.ensureSepoliaGateway();
+                        // Default token to native ETH if none provided
+                        if (!execute.funds.token) {
+                            const available = tokens_1.MOVEABLE_TOKENS[chain] || [];
+                            const vm = chain_1.CHAIN_INFO[chain].vm;
+                            const preferredSymbol = vm === enums_1.VM.EVM ? 'ETH' : vm === enums_1.VM.SVM ? 'SOL' : undefined;
+                            const nativeToken = preferredSymbol
+                                ? available.find((t) => t.symbol === preferredSymbol)
+                                : undefined;
+                            if (!nativeToken) {
+                                throw new Error('Native token not configured for this chain');
+                            }
+                            execute.funds.token = nativeToken;
+                        }
+                        const mechanism = execute.funds.token.mechanism;
+                        const { deployed, nonce } = yield this.getUeaStatusAndNonce();
+                        const { payload: universalPayload } = yield this.buildGatewayPayloadAndGas(execute, nonce);
+                        // Compute required gas funding on Push Chain and current UEA balance
+                        const gasEstimate = execute.gasLimit || BigInt(1e7);
+                        const gasPrice = yield this.pushClient.getGasPrice();
+                        const requiredGasFee = gasEstimate * gasPrice;
+                        const payloadValue = (_c = execute.value) !== null && _c !== void 0 ? _c : BigInt(0);
+                        const requiredFunds = requiredGasFee + payloadValue;
+                        const ueaAddress = this.computeUEAOffchain();
+                        const [ueaBalance] = yield Promise.all([
+                            this.pushClient.getBalance(ueaAddress),
+                        ]);
+                        // 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');
+                        // Convert USD(8) -> native wei using the same pricing path as fee locking
+                        const nativeTokenUsdPrice = yield new price_fetch_1.PriceFetch(this.rpcUrls).getPrice(chain); // 8 decimals
+                        const oneEthWei = push_chain_1.PushChain.utils.helpers.parseUnits('1', 18);
+                        const nativeAmount = (depositUsd * oneEthWei) / nativeTokenUsdPrice;
+                        const revertCFG = {
+                            fundRecipient: this.universalSigner.account
+                                .address,
+                            revertMsg: '0x',
+                        };
+                        const bridgeAmount = execute.funds.amount;
+                        const symbol = execute.funds.token.symbol;
+                        // Funds Flow: Preparing funds transfer
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_01, bridgeAmount, execute.funds.token.decimals, symbol);
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            const tokenAddr = execute.funds.token.address;
+                            if (mechanism !== 'approve') {
+                                throw new Error('Only ERC-20 tokens are supported for funds+payload on EVM; native and permit2 are not supported yet');
+                            }
+                            yield this.ensureErc20Allowance(evmClient, tokenAddr, gatewayAddress, bridgeAmount);
+                        }
+                        let txHash;
+                        try {
+                            if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                                const tokenAddr = execute.funds.token.address;
+                                // Compute EIP-712 signature for the universal payload and hash to bytes32
+                                const ueaAddress = this.computeUEAOffchain();
+                                const eip712Signature = yield this.signUniversalPayload(universalPayload, 
+                                // execute.to
+                                ueaAddress);
+                                const eip712SignatureHex = typeof eip712Signature === 'string'
+                                    ? eip712Signature
+                                    : (0, viem_1.bytesToHex)(eip712Signature);
+                                const signatureData = (0, viem_1.keccak256)(eip712SignatureHex);
+                                txHash = yield evmClient.writeContract({
+                                    abi: abi_1.UNIVERSAL_GATEWAY_V0,
+                                    address: gatewayAddress,
+                                    functionName: 'sendTxWithFunds',
+                                    args: [
+                                        tokenAddr,
+                                        bridgeAmount,
+                                        universalPayload,
+                                        revertCFG,
+                                        signatureData,
+                                    ],
+                                    signer: this.universalSigner,
+                                    value: nativeAmount,
+                                });
+                            }
+                            else {
+                                // SVM funds+payload path
+                                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.metadata.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 [whitelistPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                                const userPk = new web3_js_1.PublicKey(this.universalSigner.account.address);
+                                const priceUpdatePk = new web3_js_1.PublicKey('7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE');
+                                const isNative = mechanism === 'native' || execute.funds.token.symbol === 'SOL';
+                                const revertSvm2 = {
+                                    fundRecipient: userPk,
+                                    revertMsg: Buffer.alloc(0),
+                                };
+                                if (isNative) {
+                                    // Native SOL as bridge + gas
+                                    txHash = yield svmClient.writeContract({
+                                        abi: abi_1.SVM_GATEWAY_IDL,
+                                        address: programId.toBase58(),
+                                        functionName: 'sendTxWithFunds',
+                                        args: [
+                                            web3_js_1.PublicKey.default, // bridge_token = default for native SOL
+                                            bridgeAmount,
+                                            universalPayload,
+                                            revertSvm2,
+                                            nativeAmount,
+                                            Buffer.alloc(32),
+                                        ],
+                                        signer: this.universalSigner,
+                                        accounts: {
+                                            config: configPda,
+                                            vault: vaultPda,
+                                            tokenWhitelist: whitelistPda,
+                                            userTokenAccount: web3_js_1.PublicKey.default, // not used for native
+                                            gatewayTokenAccount: web3_js_1.PublicKey.default, // not used for native
+                                            user: userPk,
+                                            priceUpdate: priceUpdatePk,
+                                            bridgeToken: web3_js_1.PublicKey.default,
+                                            tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+                                            systemProgram: web3_js_1.SystemProgram.programId,
+                                        },
+                                    });
+                                }
+                                else {
+                                    // SPL token as bridge + native SOL lamports as gas_amount
+                                    const mintPk = new web3_js_1.PublicKey(execute.funds.token.address);
+                                    const TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
+                                    const ASSOCIATED_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+                                    const userAta = web3_js_1.PublicKey.findProgramAddressSync([
+                                        userPk.toBuffer(),
+                                        TOKEN_PROGRAM_ID.toBuffer(),
+                                        mintPk.toBuffer(),
+                                    ], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+                                    const vaultAta = web3_js_1.PublicKey.findProgramAddressSync([
+                                        vaultPda.toBuffer(),
+                                        TOKEN_PROGRAM_ID.toBuffer(),
+                                        mintPk.toBuffer(),
+                                    ], ASSOCIATED_TOKEN_PROGRAM_ID)[0];
+                                    txHash = yield svmClient.writeContract({
+                                        abi: abi_1.SVM_GATEWAY_IDL,
+                                        address: programId.toBase58(),
+                                        functionName: 'sendTxWithFunds',
+                                        args: [
+                                            mintPk,
+                                            bridgeAmount,
+                                            universalPayload,
+                                            revertSvm2,
+                                            nativeAmount,
+                                            Buffer.alloc(32),
+                                        ],
+                                        signer: this.universalSigner,
+                                        accounts: {
+                                            config: configPda,
+                                            vault: vaultPda,
+                                            tokenWhitelist: whitelistPda,
+                                            userTokenAccount: userAta,
+                                            gatewayTokenAccount: vaultAta,
+                                            user: userPk,
+                                            priceUpdate: priceUpdatePk,
+                                            bridgeToken: mintPk,
+                                            tokenProgram: TOKEN_PROGRAM_ID,
+                                            systemProgram: web3_js_1.SystemProgram.programId,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        catch (err) {
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_04);
+                            throw err;
+                        }
+                        // Payload Flow: Verification Success
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_03);
+                        // Funds Flow: Funds lock submitted
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_02, txHash, bridgeAmount, execute.funds.token.decimals, symbol);
+                        // Awaiting confirmations
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            yield this.waitForEvmConfirmationsWithCountdown(evmClient, txHash, 14, 300000);
+                        }
+                        else {
+                            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,
+                            });
+                            yield svmClient.waitForConfirmations({
+                                txSignature: txHash,
+                                confirmations: chain_1.CHAIN_INFO[enums_1.CHAIN.SOLANA_DEVNET].confirmations,
+                                timeoutMs: chain_1.CHAIN_INFO[enums_1.CHAIN.SOLANA_DEVNET].timeout,
+                            });
+                        }
+                        // Funds Flow: Confirmed on origin
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06);
+                        // If UEA is not deployed yet, deploy it now using the gateway tx hash
+                        yield this.sendUniversalTx(deployed, txHash);
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            const evmTx = yield evmClient.getTransaction(txHash);
+                            return yield this.transformToUniversalTxResponse(evmTx);
+                        }
+                        else {
+                            const chainId = chain_1.CHAIN_INFO[chain].chainId;
+                            const vm = chain_1.CHAIN_INFO[chain].vm;
+                            const origin = `${chain_1.VM_NAMESPACE[vm]}:${chainId}:${this.universalSigner.account.address}`;
+                            const universalTxResponse = {
+                                hash: txHash,
+                                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: txHash,
+                                        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),
+                                },
+                            };
+                            return universalTxResponse;
+                        }
+                    }
+                }
                 // Set default value for value if undefined
                 if (execute.value === undefined) {
                     execute.value = BigInt(0);
@@ -123,8 +672,9 @@ class Orchestrator {
                     if (!allowedChains.includes(this.universalSigner.account.chain)) {
                         throw new Error('Multicall is only enabled for Ethereum Sepolia and Solana Devnet');
                     }
-                    // Validate `to` is a 0x-prefixed address
-                    if (typeof execute.to !== 'string' || !execute.to.startsWith('0x')) {
+                    // For multicall payloads, ExecuteParams.to must be the sentinel '0x'
+                    // Note: This is distinct from each call's `to` inside MulticallCall[]
+                    if (execute.to !== '0x') {
                         throw new Error('When using multicall, "to" must be a 0x-prefixed address');
                     }
                     // Normalize and validate calls
@@ -152,8 +702,12 @@ class Orchestrator {
                 else {
                     payloadData = (execute.data || '0x');
                 }
+                // Determine payload `to` value. For multicall sentinel '0x', encode as zero address.
+                const payloadTo = Array.isArray(execute.data)
+                    ? '0x0000000000000000000000000000000000000000'
+                    : execute.to;
                 const universalPayload = JSON.parse(JSON.stringify({
-                    to: execute.to,
+                    to: payloadTo,
                     value: execute.value,
                     data: payloadData,
                     gasLimit: execute.gasLimit || BigInt(1e7),
@@ -219,7 +773,19 @@ class Orchestrator {
                 return transactions[transactions.length - 1];
             }
             catch (err) {
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_02, err);
+                const errMessage = err instanceof Error
+                    ? err.message
+                    : typeof err === 'string'
+                        ? err
+                        : (() => {
+                            try {
+                                return JSON.stringify(err);
+                            }
+                            catch (_a) {
+                                return 'Unknown error';
+                            }
+                        })();
+                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_02, errMessage);
                 throw err;
             }
         });
@@ -365,6 +931,7 @@ class Orchestrator {
                     universalAccountId,
                     txHash: feeLockTxHash,
                 }));
+                // TODO: pchaind q uexecutor all-universal-tx  --node https://rpc-testnet-donut-node1.push.org/
             }
             if (feeLockTxHash) {
                 msgs.push(this.pushClient.createMsgMintPC({
@@ -635,6 +1202,129 @@ class Orchestrator {
             }
         });
     }
+    ensureErc20Allowance(evmClient, tokenAddress, spender, requiredAmount) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const chain = this.universalSigner.account.chain;
+            const owner = this.universalSigner.account.address;
+            const currentAllowance = yield evmClient.readContract({
+                abi: abi_1.ERC20_EVM,
+                address: tokenAddress,
+                functionName: 'allowance',
+                args: [owner, spender],
+            });
+            if (currentAllowance >= requiredAmount)
+                return;
+            // Some ERC-20s like USDT require setting allowance to 0 before changing
+            // an existing non-zero allowance to a different non-zero value.
+            if (currentAllowance > BigInt(0)) {
+                this.printLog(`Resetting existing allowance from ${currentAllowance.toString()} to 0 for spender ${spender}`);
+                const resetTxHash = yield evmClient.writeContract({
+                    abi: abi_1.ERC20_EVM,
+                    address: tokenAddress,
+                    functionName: 'approve',
+                    args: [spender, BigInt(0)],
+                    signer: this.universalSigner,
+                });
+                yield evmClient.waitForConfirmations({
+                    txHash: resetTxHash,
+                    confirmations: 1,
+                    timeoutMs: chain_1.CHAIN_INFO[chain].timeout,
+                });
+            }
+            const setTxHash = yield evmClient.writeContract({
+                abi: abi_1.ERC20_EVM,
+                address: tokenAddress,
+                functionName: 'approve',
+                args: [spender, requiredAmount],
+                signer: this.universalSigner,
+            });
+            yield evmClient.waitForConfirmations({
+                txHash: setTxHash,
+                confirmations: 1,
+                timeoutMs: chain_1.CHAIN_INFO[chain].timeout,
+            });
+            try {
+                const updated = yield evmClient.readContract({
+                    abi: abi_1.ERC20_EVM,
+                    address: tokenAddress,
+                    functionName: 'allowance',
+                    args: [owner, spender],
+                });
+                if (updated < requiredAmount) {
+                    this.printLog('Warning: allowance not updated yet; proceeding');
+                }
+            }
+            catch (_a) {
+                // ignore
+            }
+        });
+    }
+    /**
+     * Ensures we're on Sepolia, returns EVM client and gateway address.
+     */
+    ensureSepoliaGateway() {
+        const chain = this.universalSigner.account.chain;
+        if (chain !== enums_1.CHAIN.ETHEREUM_SEPOLIA) {
+            throw new Error('Funds + payload bridging is only supported on Ethereum Sepolia for now');
+        }
+        const { defaultRPC, lockerContract } = chain_1.CHAIN_INFO[chain];
+        const rpcUrls = this.rpcUrls[chain] || defaultRPC;
+        const evmClient = new evm_client_1.EvmClient({ rpcUrls });
+        const gatewayAddress = lockerContract;
+        if (!gatewayAddress) {
+            throw new Error('Universal Gateway address not configured');
+        }
+        return { chain, evmClient, gatewayAddress };
+    }
+    /**
+     * Computes UEA and fetches its nonce if deployed; returns 0 otherwise.
+     */
+    getUeaNonceForExecution() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const UEA = this.computeUEAOffchain();
+            const [code] = yield Promise.all([
+                this.pushClient.publicClient.getCode({ address: UEA }),
+            ]);
+            return code !== undefined ? yield this.getUEANonce(UEA) : BigInt(0);
+        });
+    }
+    /**
+     * Returns UEA deployment status and nonce (0 if not deployed).
+     */
+    getUeaStatusAndNonce() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const UEA = this.computeUEAOffchain();
+            const [code] = yield Promise.all([
+                this.pushClient.publicClient.getCode({ address: UEA }),
+            ]);
+            const deployed = code !== undefined;
+            const nonce = deployed ? yield this.getUEANonce(UEA) : BigInt(0);
+            return { deployed, nonce };
+        });
+    }
+    /**
+     * Builds UniversalPayload for the gateway and computes the native gas deposit.
+     */
+    buildGatewayPayloadAndGas(execute, nonce) {
+        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.universalTxVerification,
+            };
+            return { payload: universalPayload, gasAmount };
+        });
+    }
     /********************************** HELPER FUNCTIONS **************************************************/
     /**
      * Transforms a TransactionReceipt to UniversalTxReceipt format
@@ -855,6 +1545,32 @@ class Orchestrator {
         // invoke the user-provided callback
         this.progressHook(hookPayload);
     }
+    // Emit countdown updates while waiting for EVM confirmations
+    waitForEvmConfirmationsWithCountdown(evmClient, txHash, confirmations, timeoutMs) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // initial emit
+            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03, confirmations);
+            const start = Date.now();
+            // Wait for receipt to get included block
+            const receipt = yield evmClient.publicClient.waitForTransactionReceipt({
+                hash: txHash,
+            });
+            const targetBlock = receipt.blockNumber + BigInt(confirmations);
+            // Poll blocks and emit remaining confirmations
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const currentBlock = yield evmClient.publicClient.getBlockNumber();
+                if (currentBlock >= targetBlock)
+                    return;
+                const remaining = Number(targetBlock - currentBlock);
+                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03, remaining);
+                if (Date.now() - start > timeoutMs) {
+                    throw new Error(`Timeout: transaction ${txHash} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
+                }
+                yield new Promise((r) => setTimeout(r, 12000));
+            }
+        });
+    }
 }
 exports.Orchestrator = Orchestrator;
 //# sourceMappingURL=orchestrator.js.map