@pushchain/core 5.1.3 → 5.1.4-alpha.1

package/src/lib/orchestrator/internals/confirmation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transaction confirmation polling functions extracted from Orchestrator.
+ */
+import { EvmClient } from '../../vm-client/evm-client';
+import { SvmClient } from '../../vm-client/svm-client';
+import type { OrchestratorContext } from './context';
+export declare function waitForEvmConfirmationsWithCountdown(ctx: OrchestratorContext, evmClient: EvmClient, txHash: `0x${string}`, confirmations: number, timeoutMs: number): Promise<void>;
+export declare function waitForSvmConfirmationsWithCountdown(ctx: OrchestratorContext, svmClient: SvmClient, txSignature: string, confirmations: number, timeoutMs: number): Promise<void>;
+export declare function waitForLockerFeeConfirmation(ctx: OrchestratorContext, txHashBytes: Uint8Array): Promise<void>;

package/src/lib/orchestrator/internals/confirmation.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Transaction confirmation polling functions extracted from Orchestrator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForEvmConfirmationsWithCountdown = waitForEvmConfirmationsWithCountdown;
+exports.waitForSvmConfirmationsWithCountdown = waitForSvmConfirmationsWithCountdown;
+exports.waitForLockerFeeConfirmation = waitForLockerFeeConfirmation;
+const tslib_1 = require("tslib");
+const bs58_1 = require("../../internal/bs58");
+const viem_1 = require("viem");
+const chain_1 = require("../../constants/chain");
+const context_1 = require("./context");
+const enums_1 = require("../../constants/enums");
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
+const svm_client_1 = require("../../vm-client/svm-client");
+const context_2 = require("./context");
+function waitForEvmConfirmationsWithCountdown(ctx, evmClient, txHash, confirmations, timeoutMs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (confirmations <= 0) {
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02, 0, 0);
+            return;
+        }
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03, confirmations);
+        const start = Date.now();
+        const receipt = yield evmClient.publicClient.waitForTransactionReceipt({
+            hash: txHash,
+        });
+        const targetBlock = receipt.blockNumber + BigInt(confirmations);
+        let lastEmitted = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const currentBlock = yield evmClient.publicClient.getBlockNumber();
+            if (currentBlock >= targetBlock) {
+                if (lastEmitted < confirmations) {
+                    (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02, confirmations, confirmations);
+                }
+                return;
+            }
+            const remaining = Number(targetBlock - currentBlock);
+            const completed = Math.max(1, confirmations - remaining + 1);
+            if (completed > lastEmitted) {
+                (0, context_2.fireProgressHook)(ctx, completed >= confirmations
+                    ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02
+                    : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_01, completed, confirmations);
+                lastEmitted = completed;
+                if (completed >= confirmations)
+                    return;
+            }
+            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));
+        }
+    });
+}
+function waitForSvmConfirmationsWithCountdown(ctx, svmClient, txSignature, confirmations, timeoutMs) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (confirmations <= 0) {
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02, 0, 0);
+            return;
+        }
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03, confirmations);
+        const start = Date.now();
+        let lastConfirmed = 0;
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const connection = svmClient.connections[svmClient.currentConnectionIndex];
+            const { value } = yield connection.getSignatureStatuses([txSignature]);
+            const status = value[0];
+            if (status) {
+                if (status.err) {
+                    throw new Error(`SVM transaction ${txSignature} failed: ${JSON.stringify(status.err)}`);
+                }
+                const rawConfirmations = status.confirmations;
+                const hasNumericConfirmations = rawConfirmations != null;
+                const currentConfirms = hasNumericConfirmations ? rawConfirmations : 0;
+                const isFinalized = status.err === null &&
+                    (status.confirmationStatus === 'finalized' || status.confirmations === null);
+                const hasEnoughConfirmations = hasNumericConfirmations && currentConfirms >= confirmations;
+                if (currentConfirms > lastConfirmed) {
+                    const clamped = currentConfirms >= confirmations ? confirmations : currentConfirms;
+                    (0, context_2.fireProgressHook)(ctx, clamped >= confirmations
+                        ? progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02
+                        : progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_01, Math.max(1, clamped), confirmations);
+                    lastConfirmed = currentConfirms;
+                }
+                if (hasEnoughConfirmations || isFinalized) {
+                    if (lastConfirmed < confirmations) {
+                        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_03_02, confirmations, confirmations);
+                    }
+                    return;
+                }
+            }
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(`Timeout: transaction ${txSignature} not confirmed with ${confirmations} confirmations within ${timeoutMs} ms`);
+            }
+            yield new Promise((r) => setTimeout(r, 500));
+        }
+    });
+}
+function waitForLockerFeeConfirmation(ctx, txHashBytes) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const chain = ctx.universalSigner.account.chain;
+        const { vm, defaultRPC, fastConfirmations, timeout } = chain_1.CHAIN_INFO[chain];
+        const rpcUrls = ctx.rpcUrls[chain] || defaultRPC;
+        switch (vm) {
+            case enums_1.VM.EVM: {
+                const evmClient = (0, context_1.getOriginEvmClient)(ctx);
+                yield waitForEvmConfirmationsWithCountdown(ctx, evmClient, (0, viem_1.bytesToHex)(txHashBytes), fastConfirmations, timeout);
+                return;
+            }
+            case enums_1.VM.SVM: {
+                const svmClient = new svm_client_1.SvmClient({ rpcUrls });
+                yield waitForSvmConfirmationsWithCountdown(ctx, svmClient, bs58_1.bs58.encode(Buffer.from(txHashBytes)), fastConfirmations, timeout);
+                return;
+            }
+            default:
+                throw new Error(`Unsupported VM for tx confirmation: ${vm}`);
+        }
+    });
+}
+//# sourceMappingURL=confirmation.js.map

package/src/lib/orchestrator/internals/context.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shared context for orchestrator submodules.
+ *
+ * Instead of passing `this` or 5+ parameters to every extracted function,
+ * submodules receive this context object. The Orchestrator class implements
+ * this interface and passes itself.
+ */
+import type { PushClient } from '../../push-client/push-client';
+import type { UniversalSigner } from '../../universal/universal.types';
+import type { CHAIN, PUSH_NETWORK } from '../../constants/enums';
+import type { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import type { AccountStatus } from '../orchestrator.types';
+import { EvmClient } from '../../vm-client/evm-client';
+export interface OrchestratorContext {
+    readonly pushClient: PushClient;
+    readonly universalSigner: UniversalSigner;
+    readonly pushNetwork: PUSH_NETWORK;
+    readonly rpcUrls: Partial<Record<CHAIN, string[]>>;
+    readonly printTraces: boolean;
+    progressHook?: (progress: ProgressEvent) => void;
+    ueaVersionCache?: string;
+    accountStatusCache: AccountStatus | null;
+    /** Cached origin chain EvmClient — avoids creating new clients per call site */
+    _originEvmClient?: EvmClient;
+}
+/**
+ * Returns (and caches) an EvmClient for the signer's origin chain.
+ * Avoids creating new EvmClient instances in lockFee, confirmation, fetchOriginTx, etc.
+ */
+export declare function getOriginEvmClient(ctx: OrchestratorContext): EvmClient;
+/**
+ * Logs a message to console when printTraces is enabled.
+ */
+export declare function printLog(ctx: OrchestratorContext, msg: string): void;
+/**
+ * Fires a progress hook event by ID, forwarding args to the hook factory.
+ */
+export declare function fireProgressHook(ctx: OrchestratorContext, hookId: string, ...args: any[]): void;

package/src/lib/orchestrator/internals/context.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Shared context for orchestrator submodules.
+ *
+ * Instead of passing `this` or 5+ parameters to every extracted function,
+ * submodules receive this context object. The Orchestrator class implements
+ * this interface and passes itself.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOriginEvmClient = getOriginEvmClient;
+exports.printLog = printLog;
+exports.fireProgressHook = fireProgressHook;
+const tslib_1 = require("tslib");
+const chain_1 = require("../../constants/chain");
+const evm_client_1 = require("../../vm-client/evm-client");
+const progress_hook_1 = tslib_1.__importDefault(require("../../progress-hook/progress-hook"));
+/**
+ * Returns (and caches) an EvmClient for the signer's origin chain.
+ * Avoids creating new EvmClient instances in lockFee, confirmation, fetchOriginTx, etc.
+ */
+function getOriginEvmClient(ctx) {
+    if (!ctx._originEvmClient) {
+        const chain = ctx.universalSigner.account.chain;
+        const { defaultRPC } = chain_1.CHAIN_INFO[chain];
+        const rpcUrls = ctx.rpcUrls[chain] || defaultRPC;
+        ctx._originEvmClient = new evm_client_1.EvmClient({ rpcUrls });
+    }
+    return ctx._originEvmClient;
+}
+/**
+ * Logs a message to console when printTraces is enabled.
+ */
+function printLog(ctx, msg) {
+    if (ctx.printTraces) {
+        console.log(`[Orchestrator] ${msg}`);
+    }
+}
+/**
+ * Fires a progress hook event by ID, forwarding args to the hook factory.
+ */
+function fireProgressHook(ctx, hookId, ...args) {
+    const hookEntry = progress_hook_1.default[hookId];
+    const hookPayload = hookEntry(...args);
+    printLog(ctx, hookPayload.message);
+    if (ctx.progressHook) {
+        ctx.progressHook(hookPayload);
+    }
+}
+//# sourceMappingURL=context.js.map

package/src/lib/orchestrator/internals/execute-funds-only.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Funds-only execution flow (no payload) — extracted from Orchestrator.execute().
+ *
+ * Handles bridging funds from an external chain to Push Chain
+ * for both EVM and SVM origin chains.
+ */
+import { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+import type { ResponseBuilderCallbacks } from './response-builder';
+export declare function executeFundsOnly(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], getResponseCallbacks: () => ResponseBuilderCallbacks): Promise<UniversalTxResponse>;

package/src/lib/orchestrator/internals/execute-funds-only.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Funds-only execution flow (no payload) — extracted from Orchestrator.execute().
+ *
+ * Handles bridging funds from an external chain to Push Chain
+ * for both EVM and SVM origin chains.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeFundsOnly = executeFundsOnly;
+const tslib_1 = require("tslib");
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const universalGatewayV0_json_1 = tslib_1.__importDefault(require("../../constants/abi/universalGatewayV0.json"));
+const chain_1 = require("../../constants/chain");
+const enums_1 = require("../../constants/enums");
+const tokens_1 = require("../../constants/tokens");
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
+const context_1 = require("./context");
+const svm_client_1 = require("../../vm-client/svm-client");
+const context_2 = require("./context");
+const gas_calculator_1 = require("./gas-calculator");
+const gateway_client_1 = require("./gateway-client");
+const helpers_1 = require("./helpers");
+const payload_builder_1 = require("./payload-builder");
+const uea_manager_1 = require("./uea-manager");
+const confirmation_1 = require("./confirmation");
+const response_builder_1 = require("./response-builder");
+const push_chain_tx_1 = require("./push-chain-tx");
+const svm_helpers_1 = require("./svm-helpers");
+const helpers_2 = require("./helpers");
+const response_builder_2 = require("./response-builder");
+function executeFundsOnly(ctx, execute, eventBuffer, getResponseCallbacks) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const transformFn = (tx, buf = []) => (0, response_builder_2.transformToUniversalTxResponse)(ctx, tx, buf, getResponseCallbacks());
+        const chain = ctx.universalSigner.account.chain;
+        const { vm } = chain_1.CHAIN_INFO[chain];
+        if (!helpers_1.SUPPORTED_GATEWAY_CHAINS.includes(chain)) {
+            throw new Error(`Funds bridging is not supported on chain ${chain}. Supported chains: ${helpers_1.SUPPORTED_GATEWAY_CHAINS.join(', ')}`);
+        }
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_01, chain, ctx.universalSigner.account.address);
+        const { defaultRPC, lockerContract } = chain_1.CHAIN_INFO[chain];
+        const rpcUrls = ctx.rpcUrls[chain] || defaultRPC;
+        // Resolve token: default to native token based on VM
+        if (!execute.funds.token) {
+            const available = tokens_1.MOVEABLE_TOKENS[chain] || [];
+            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;
+        const bridgeAmount = amount;
+        if (vm === enums_1.VM.EVM) {
+            return executeFundsOnlyEvm(ctx, execute, eventBuffer, transformFn, chain, rpcUrls, lockerContract, bridgeAmount, symbol);
+        }
+        else {
+            return executeFundsOnlySvm(ctx, execute, eventBuffer, transformFn, chain, rpcUrls, bridgeAmount, symbol);
+        }
+    });
+}
+// ============================================================================
+// EVM funds-only path
+// ============================================================================
+function executeFundsOnlyEvm(ctx, execute, eventBuffer, transformFn, chain, rpcUrls, lockerContract, bridgeAmount, symbol) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const evmClient = (0, context_1.getOriginEvmClient)(ctx);
+        const gatewayAddress = lockerContract;
+        const tokenAddr = execute.funds.token.address;
+        const isNative = execute.funds.token.mechanism === 'native';
+        // Skip getCode if accountStatusCache already confirmed deployment
+        let nonce;
+        let deployed;
+        const deployedHint = (_b = (_a = ctx.accountStatusCache) === null || _a === void 0 ? void 0 : _a.uea) === null || _b === void 0 ? void 0 : _b.deployed;
+        if (deployedHint) {
+            deployed = true;
+            nonce = yield (0, uea_manager_1.getUEANonce)(ctx, (0, uea_manager_1.computeUEAOffchain)(ctx));
+        }
+        else {
+            const status = yield (0, uea_manager_1.getUeaStatusAndNonce)(ctx);
+            nonce = status.nonce;
+            deployed = status.deployed;
+        }
+        const { payload: universalPayload, req } = yield (0, payload_builder_1.buildGatewayPayloadAndGas)(ctx, execute, nonce, 'sendFunds', bridgeAmount);
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        (0, context_2.printLog)(ctx, 'sendFunds — buildGatewayPayloadAndGas result: ' + JSON.stringify({
+            recipient: execute.to, ueaAddress,
+            isSelfBridge: execute.to.toLowerCase() === ueaAddress.toLowerCase(),
+            bridgeAmount: bridgeAmount.toString(), isNative, tokenAddr,
+            nonce: nonce.toString(), deployed,
+        }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2));
+        const ueaBalanceForGas = yield ctx.pushClient.getBalance(ueaAddress);
+        const nativeAmount = yield (0, gas_calculator_1.calculateNativeAmountForDeposit)(ctx, chain, BigInt(0), ueaBalanceForGas);
+        (0, context_2.printLog)(ctx, `sendFunds — nativeAmount: ${nativeAmount.toString()}, ueaBalanceForGas: ${ueaBalanceForGas.toString()}`);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, ueaAddress, deployed);
+        (0, context_2.printLog)(ctx, `UEA resolved: ${ueaAddress}, deployed: ${deployed}`);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_01, execute.funds.amount, execute.funds.token.decimals, symbol);
+        // Approve gateway to pull tokens if ERC-20
+        if (execute.funds.token.mechanism === 'approve') {
+            yield (0, gas_calculator_1.ensureErc20Allowance)(ctx, evmClient, tokenAddr, gatewayAddress, execute.funds.amount);
+        }
+        else if (execute.funds.token.mechanism === 'permit2') {
+            throw new Error('Permit2 is not supported yet');
+        }
+        let txHash;
+        try {
+            (0, context_2.printLog)(ctx, (execute.to.toLowerCase() === ueaAddress.toLowerCase() ? 'FUNDS ONLY SELF' : 'FUNDS ONLY OTHER') +
+                ' — gateway call payload: ' + JSON.stringify({
+                gatewayAddress, functionName: 'sendUniversalTx', req,
+                value: (isNative ? nativeAmount + bridgeAmount : nativeAmount).toString(),
+                isNative, bridgeAmount: bridgeAmount.toString(), nativeAmount: nativeAmount.toString(),
+            }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2));
+            txHash = yield (0, gateway_client_1.sendGatewayTxWithFallback)(ctx, evmClient, gatewayAddress, req, ctx.universalSigner, isNative ? nativeAmount + bridgeAmount : nativeAmount);
+        }
+        catch (err) {
+            (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_04_04);
+            throw err;
+        }
+        const originTx = yield (0, helpers_2.fetchOriginChainTransactionForProgress)(ctx, chain, txHash, txHash);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_02, txHash, bridgeAmount, execute.funds.token.decimals, symbol, originTx);
+        yield (0, confirmation_1.waitForEvmConfirmationsWithCountdown)(ctx, evmClient, txHash, chain_1.CHAIN_INFO[chain].confirmations, chain_1.CHAIN_INFO[chain].timeout);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_05);
+        (0, context_2.printLog)(ctx, 'sendFunds — querying Push Chain status: ' + JSON.stringify({
+            txHash, evmGatewayMethod: execute.to === ueaAddress ? 'sendFunds' : 'sendTxWithFunds',
+        }));
+        const pushChainUniversalTx = yield (0, response_builder_1.queryUniversalTxStatusFromGatewayTx)(ctx, evmClient, gatewayAddress, txHash, execute.to === ueaAddress ? 'sendFunds' : 'sendTxWithFunds');
+        const response = yield (0, push_chain_tx_1.extractPcTxAndTransform)(ctx, pushChainUniversalTx, txHash, eventBuffer, 'sendFunds', transformFn);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06, bridgeAmount, execute.funds.token.decimals, symbol);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01, [response]);
+        return response;
+    });
+}
+// ============================================================================
+// SVM funds-only path
+// ============================================================================
+function executeFundsOnlySvm(ctx, execute, eventBuffer, transformFn, chain, rpcUrls, bridgeAmount, symbol) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const svmClient = new svm_client_1.SvmClient({ rpcUrls });
+        const programId = new web3_js_1.PublicKey(universalGatewayV0_json_1.default.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 { feeVaultPda, protocolFeeLamports } = yield (0, svm_helpers_1.getSvmProtocolFee)(svmClient, programId);
+        const [rateLimitConfigPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit_config')], programId);
+        const userPk = new web3_js_1.PublicKey(ctx.universalSigner.account.address);
+        const priceUpdatePk = new web3_js_1.PublicKey(chain_1.SVM_PYTH_PRICE_FEED);
+        if (execute.payGasWith !== undefined) {
+            throw new Error('Pay-with token is not supported on Solana');
+        }
+        const recipientEvm20 = Array.from(Buffer.from(execute.to.slice(2).padStart(40, '0'), 'hex').subarray(0, 20));
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01);
+        const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
+        const { nonce, deployed } = yield (0, uea_manager_1.getUeaStatusAndNonce)(ctx);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_02, ueaAddress, deployed);
+        let txSignature;
+        if (execute.funds.token.mechanism === 'native') {
+            const [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), web3_js_1.PublicKey.default.toBuffer()], programId);
+            const reqNative = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
+                recipient: recipientEvm20, token: web3_js_1.PublicKey.default, amount: bridgeAmount,
+                payload: '0x', revertRecipient: userPk, signatureData: '0x',
+            });
+            txSignature = yield svmClient.writeContract({
+                abi: universalGatewayV0_json_1.default, address: programId.toBase58(), functionName: 'sendUniversalTx',
+                args: [reqNative, bridgeAmount + protocolFeeLamports], signer: ctx.universalSigner,
+                accounts: {
+                    config: configPda, vault: vaultPda, feeVault: feeVaultPda,
+                    userTokenAccount: vaultPda, gatewayTokenAccount: vaultPda, user: userPk,
+                    priceUpdate: priceUpdatePk, rateLimitConfig: rateLimitConfigPda,
+                    tokenRateLimit: tokenRateLimitPda,
+                    tokenProgram: new web3_js_1.PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                },
+            });
+        }
+        else if (execute.funds.token.mechanism === 'approve') {
+            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 [tokenRateLimitPda] = web3_js_1.PublicKey.findProgramAddressSync([(0, viem_1.stringToBytes)('rate_limit'), mintPk.toBuffer()], programId);
+            const reqSpl = (0, svm_helpers_1.buildSvmUniversalTxRequest)({
+                recipient: recipientEvm20, token: mintPk, amount: bridgeAmount,
+                payload: '0x', revertRecipient: userPk, signatureData: '0x',
+            });
+            txSignature = yield svmClient.writeContract({
+                abi: universalGatewayV0_json_1.default, address: programId.toBase58(), functionName: 'sendUniversalTx',
+                args: [reqSpl, protocolFeeLamports], signer: ctx.universalSigner,
+                accounts: {
+                    config: configPda, vault: vaultPda, feeVault: feeVaultPda,
+                    userTokenAccount: userAta, gatewayTokenAccount: vaultAta, user: userPk,
+                    tokenProgram: TOKEN_PROGRAM_ID, priceUpdate: priceUpdatePk,
+                    rateLimitConfig: rateLimitConfigPda, tokenRateLimit: tokenRateLimitPda,
+                    systemProgram: web3_js_1.SystemProgram.programId,
+                },
+            });
+        }
+        else {
+            throw new Error('Unsupported token mechanism on Solana');
+        }
+        const originTx = yield (0, helpers_2.fetchOriginChainTransactionForProgress)(ctx, chain, '0x', txSignature);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_02, txSignature, bridgeAmount, execute.funds.token.decimals, symbol, originTx);
+        yield (0, confirmation_1.waitForSvmConfirmationsWithCountdown)(ctx, svmClient, txSignature, chain_1.CHAIN_INFO[chain].confirmations, chain_1.CHAIN_INFO[chain].timeout);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_04);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_05);
+        const pushChainUniversalTx = yield (0, response_builder_1.queryUniversalTxStatusFromGatewayTx)(ctx, undefined, undefined, txSignature, 'sendFunds');
+        const response = yield (0, push_chain_tx_1.extractPcTxAndTransform)(ctx, pushChainUniversalTx, txSignature, eventBuffer, 'sendFunds (SVM)', transformFn);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_06_06, bridgeAmount, execute.funds.token.decimals, symbol);
+        (0, context_2.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_99_01, [response]);
+        return response;
+    });
+}
+//# sourceMappingURL=execute-funds-only.js.map

package/src/lib/orchestrator/internals/execute-funds-payload.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Funds+payload execution flow — extracted from Orchestrator.execute().
+ *
+ * Handles bridging funds AND executing a payload on Push Chain
+ * for both EVM and SVM origin chains.
+ */
+import { ProgressEvent } from '../../progress-hook/progress-hook.types';
+import type { ExecuteParams, UniversalTxResponse } from '../orchestrator.types';
+import type { OrchestratorContext } from './context';
+import { type ResponseBuilderCallbacks } from './response-builder';
+export declare function executeFundsWithPayload(ctx: OrchestratorContext, execute: ExecuteParams, eventBuffer: ProgressEvent[], getResponseCallbacks: () => ResponseBuilderCallbacks): Promise<UniversalTxResponse>;