@pushchain/core 2.0.2 → 2.0.5

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,574 @@ 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 || chain === enums_1.CHAIN.SOLANA_DEVNET)) {
+                            throw new Error('Funds bridging is only supported on Ethereum Sepolia and Solana Devnet 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
+                            yield this.queryUniversalTxStatusFromEvmGatewayTx(evmClient, gatewayAddress, txHash, 'sendFunds');
+                            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.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);
+                            let txSignature;
+                            // SVM-specific RevertSettings: bytes must be a Buffer
+                            const revertSvm = {
+                                fundRecipient: userPk,
+                                revertMsg: Buffer.from([]),
+                            };
+                            // New gateway expects EVM recipient as [u8; 20]
+                            const recipientEvm20 = Array.from(Buffer.from(execute.to.slice(2).padStart(40, '0'), 'hex').subarray(0, 20));
+                            if (execute.funds.token.mechanism === 'native') {
+                                // Native SOL funds-only
+                                // Compute a local whitelist PDA to avoid TS scope issues
+                                const [whitelistPdaLocal] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                                txSignature = yield svmClient.writeContract({
+                                    abi: abi_1.SVM_GATEWAY_IDL,
+                                    address: programId.toBase58(),
+                                    functionName: 'sendFunds', // -> unified sendFunds(recipient, bridge_token, bridge_amount, revert_cfg)
+                                    args: [
+                                        recipientEvm20,
+                                        web3_js_1.PublicKey.default,
+                                        bridgeAmount,
+                                        revertSvm,
+                                    ],
+                                    signer: this.universalSigner,
+                                    accounts: {
+                                        config: configPda,
+                                        vault: vaultPda,
+                                        user: userPk,
+                                        tokenWhitelist: whitelistPdaLocal,
+                                        userTokenAccount: userPk,
+                                        gatewayTokenAccount: vaultPda,
+                                        bridgeToken: web3_js_1.PublicKey.default,
+                                        tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+                                        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);
+                                // 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];
+                                txSignature = yield svmClient.writeContract({
+                                    abi: abi_1.SVM_GATEWAY_IDL,
+                                    address: programId.toBase58(),
+                                    functionName: 'sendFunds',
+                                    args: [recipientEvm20, 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.getOriginGatewayContext();
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_01, chain);
+                        // 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);
+                        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);
+                        const gasPrice = yield this.pushClient.getGasPrice();
+                        const requiredGasFee = gasEstimate * gasPrice;
+                        const payloadValue = (_a = execute.value) !== null && _a !== void 0 ? _a : BigInt(0);
+                        const requiredFunds = requiredGasFee + payloadValue;
+                        const ueaAddress = this.computeUEAOffchain();
+                        const [ueaBalance] = yield Promise.all([
+                            this.pushClient.getBalance(ueaAddress),
+                        ]);
+                        // UEA resolved (address, deployment status, balance, nonce)
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, ueaAddress, deployed);
+                        // 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 = (_b = cfg.minCapUniversalTxUsd) !== null && _b !== void 0 ? _b : cfg.min_cap_universal_tx_usd;
+                                const maxField = (_c = cfg.maxCapUniversalTxUsd) !== null && _c !== void 0 ? _c : 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 (_d) {
+                                // 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);
+                        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');
+                            }
+                            const evmClientEvm = evmClient;
+                            const gatewayAddressEvm = gatewayAddress;
+                            yield this.ensureErc20Allowance(evmClientEvm, tokenAddr, gatewayAddressEvm, 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
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
+                                const ueaAddress = this.computeUEAOffchain();
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, ueaAddress, deployed);
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_01);
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_02);
+                                const eip712Signature = yield this.signUniversalPayload(universalPayload, ueaAddress);
+                                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_03);
+                                const eip712SignatureHex = typeof eip712Signature === 'string'
+                                    ? eip712Signature
+                                    : (0, viem_1.bytesToHex)(eip712Signature);
+                                const evmClientEvm = evmClient;
+                                const gatewayAddressEvm = gatewayAddress;
+                                txHash = yield evmClientEvm.writeContract({
+                                    abi: abi_1.UNIVERSAL_GATEWAY_V0,
+                                    address: gatewayAddressEvm,
+                                    functionName: 'sendTxWithFunds',
+                                    args: [
+                                        tokenAddr,
+                                        bridgeAmount,
+                                        universalPayload,
+                                        revertCFG,
+                                        eip712SignatureHex,
+                                    ],
+                                    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.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);
+                                // whitelistPda already computed above
+                                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.from([]),
+                                };
+                                if (isNative) {
+                                    // Native SOL as bridge + gas
+                                    const [whitelistPdaLocal] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                                    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: whitelistPdaLocal,
+                                            userTokenAccount: userPk, // for native SOL, can be any valid account
+                                            gatewayTokenAccount: vaultPda, // for native SOL, can be any valid account
+                                            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];
+                                    const [whitelistPdaLocal] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('whitelist')], programId);
+                                    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: whitelistPdaLocal,
+                                            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) {
+                            const evmClientEvm = evmClient;
+                            yield this.waitForEvmConfirmationsWithCountdown(evmClientEvm, 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
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            yield this.sendUniversalTx(deployed, txHash);
+                        }
+                        else {
+                            // skip
+                        }
+                        this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06);
+                        // After sending Cosmos tx to Push Chain, query UniversalTx status (Sepolia only)
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            const evmClientEvm = evmClient;
+                            const gatewayAddressEvm = gatewayAddress;
+                            yield this.queryUniversalTxStatusFromEvmGatewayTx(evmClientEvm, gatewayAddressEvm, txHash, 'sendTxWithFunds');
+                        }
+                        if (chain_1.CHAIN_INFO[this.universalSigner.account.chain].vm === enums_1.VM.EVM) {
+                            const evmClientEvm = evmClient;
+                            const evmTx = yield evmClientEvm.getTransaction(txHash);
+                            this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_07, bridgeAmount, execute.funds.token.decimals, symbol);
+                            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);
@@ -103,7 +671,7 @@ class Orchestrator {
                 ]);
                 const isUEADeployed = code !== undefined;
                 const nonce = isUEADeployed ? yield this.getUEANonce(UEA) : BigInt(0);
-                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, UEA, isUEADeployed, funds, nonce);
+                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, UEA, isUEADeployed);
                 /**
                  * Compute Universal Payload Hash
                  */
@@ -111,7 +679,7 @@ class Orchestrator {
                 if (feeLockTxHash && !feeLockTxHash.startsWith('0x')) {
                     // decode svm base58
                     const decoded = anchor_1.utils.bytes.bs58.decode(feeLockTxHash);
-                    feeLockTxHash = (0, viem_1.bytesToHex)(Uint8Array.from(decoded));
+                    feeLockTxHash = (0, viem_1.bytesToHex)(new Uint8Array(decoded));
                 }
                 // Fee locking is required if UEA is not deployed OR insufficient funds
                 const feeLockingRequired = (!isUEADeployed || funds < requiredFunds) && !feeLockTxHash;
@@ -224,7 +792,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;
             }
         });
@@ -286,7 +866,7 @@ class Orchestrator {
                             systemProgram: web3_js_1.SystemProgram.programId,
                         },
                     });
-                    return anchor_1.utils.bytes.bs58.decode(txHash);
+                    return new Uint8Array(anchor_1.utils.bytes.bs58.decode(txHash));
                 }
                 default:
                     throw new Error(`Unsupported VM type: ${vm}`);
@@ -353,7 +933,7 @@ class Orchestrator {
                 owner: vm === enums_1.VM.EVM
                     ? address
                     : vm === enums_1.VM.SVM
-                        ? (0, viem_1.bytesToHex)(anchor_1.utils.bytes.bs58.decode(address))
+                        ? (0, viem_1.bytesToHex)(new Uint8Array(anchor_1.utils.bytes.bs58.decode(address)))
                         : address,
             };
             const { cosmosAddress: signer } = this.pushClient.getSignerAddress();
@@ -370,6 +950,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({
@@ -518,7 +1099,7 @@ class Orchestrator {
                         owner: vm === enums_1.VM.EVM
                             ? address
                             : vm === enums_1.VM.SVM
-                                ? (0, viem_1.bytesToHex)(anchor_1.utils.bytes.bs58.decode(address))
+                                ? (0, viem_1.bytesToHex)(new Uint8Array(anchor_1.utils.bytes.bs58.decode(address)))
                                 : address,
                     },
                 ],
@@ -542,7 +1123,7 @@ class Orchestrator {
             ownerKey = address;
         }
         else if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM) {
-            ownerKey = (0, viem_1.bytesToHex)(anchor_1.utils.bytes.bs58.decode(address));
+            ownerKey = (0, viem_1.bytesToHex)(new Uint8Array(anchor_1.utils.bytes.bs58.decode(address)));
         }
         else {
             throw new Error(`Unsupported VM type: ${chain_1.CHAIN_INFO[chain].vm}`);
@@ -640,6 +1221,134 @@ 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.
+     */
+    getOriginGatewayContext() {
+        const chain = this.universalSigner.account.chain;
+        if (chain !== enums_1.CHAIN.ETHEREUM_SEPOLIA && chain !== enums_1.CHAIN.SOLANA_DEVNET) {
+            throw new Error('Funds + payload bridging is only supported on Ethereum Sepolia 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) {
+            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 };
+        }
+        // SVM path (Solana Devnet) does not require evmClient/gatewayAddress
+        return { chain };
+    }
+    /**
+     * 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.signedVerification,
+            };
+            return { payload: universalPayload, gasAmount };
+        });
+    }
     /********************************** HELPER FUNCTIONS **************************************************/
     /**
      * Transforms a TransactionReceipt to UniversalTxReceipt format
@@ -860,6 +1569,86 @@ class Orchestrator {
         // invoke the user-provided callback
         this.progressHook(hookPayload);
     }
+    // Query Push Chain for UniversalTx status given an EVM gateway tx
+    queryUniversalTxStatusFromEvmGatewayTx(evmClient, gatewayAddress, txHash, fromBranch) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const receipt = yield evmClient.publicClient.getTransactionReceipt({
+                    hash: txHash,
+                });
+                const gatewayLogs = (receipt.logs || []).filter((l) => (l.address || '').toLowerCase() === gatewayAddress.toLowerCase());
+                const logIndexToUse = fromBranch === '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;
+                const logIndexStr = typeof logIndexVal === 'bigint'
+                    ? logIndexVal.toString()
+                    : String(logIndexVal);
+                const chain = this.universalSigner.account.chain;
+                const { vm } = chain_1.CHAIN_INFO[chain];
+                const sourceChain = `${chain_1.VM_NAMESPACE[vm]}:${chain_1.CHAIN_INFO[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 (error) {
+                        // ignore and retry
+                        console.log(error);
+                    }
+                    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));
+                this.printLog(`UniversalTx fetched via gRPC: ${JSON.stringify({
+                    gatewayTx: txHash,
+                    id: idHex,
+                    status: (universalTxObj === null || universalTxObj === void 0 ? void 0 : universalTxObj.universalStatus) ||
+                        (universalTxObj === null || universalTxObj === void 0 ? void 0 : universalTxObj.universal_status),
+                }, this.bigintReplacer, 2)}`);
+                return universalTxObj;
+            }
+            catch (_c) {
+                // 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;
+            }
+        });
+    }
+    // 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);
+                const completed = Math.max(1, confirmations - remaining + 1);
+                this.executeProgressHook(progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04, completed, confirmations);
+                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