@pushchain/core 5.1.4-alpha.9 → 5.1.5-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "5.1.4-alpha.9",
+  "version": "5.1.5-alpha.0",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

package/src/lib/index.d.ts

@@ -1,7 +1,7 @@
 import { PushChain } from './push-chain/push-chain';
 export type { ConversionQuote } from './constants/tokens';
 export type { UniversalSigner, UniversalAccount, UniversalSignerSkeleton, DerivedExecutorAccount, ResolvedAccount, ResolvedControllerAccounts, AccountType, AccountRole, } from './universal/universal.types';
-export type { ChainTarget, ChainSource, UniversalTo, TransactionRouteType, UniversalExecuteParams, UniversalOutboundTxRequest, PreparedUniversalTx, CascadedTxResponse, CascadeHopInfo, CascadeTrackOptions, CascadeProgressEvent, CascadeCompletionResult, MultiChainTxResponse, OutboundTxDetails, WaitForOutboundOptions, SvmGatewayAccountMeta, SvmExecutePayloadFields, SvmExecuteParams, AccountStatus, UEAStatus, RescueFundsParams, } from './orchestrator/orchestrator.types';
+export type { ChainTarget, ChainSource, UniversalTo, TransactionRouteType, UniversalExecuteParams, UniversalOutboundTxRequest, PreparedUniversalTx, CascadedTxResponse, CascadeHopInfo, CascadeTrackOptions, CascadeProgressEvent, CascadeCompletionResult, MultiChainTxResponse, OutboundTxDetails, WaitForOutboundOptions, SvmGatewayAccountMeta, SvmExecutePayloadFields, AccountStatus, UEAStatus, RescueFundsParams, } from './orchestrator/orchestrator.types';
 export { parseUEAVersion } from './orchestrator/orchestrator.types';
 export { TransactionRoute, detectRoute, isChainTarget } from './orchestrator/route-detector';
 export { getCEAAddress, getPushAccountForCEA, isCEA, chainSupportsCEA, chainSupportsOutbound, getCEAFactoryAddress, getAllCEAAddresses, } from './orchestrator/cea-utils';

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

@@ -27,6 +27,7 @@ const payload_builder_1 = require("./payload-builder");
 const uea_manager_1 = require("./uea-manager");
 const gas_calculator_1 = require("./gas-calculator");
 const route_handlers_1 = require("./route-handlers");
+const build_payload_1 = require("../svm-idl/build-payload");
 // ============================================================================
 // prepareTransaction
 // ============================================================================
@@ -110,18 +111,12 @@ function buildHopDescriptor(ctx, params, route, ueaAddress) {
                 const targetChain = target.chain;
                 // Branch: SVM vs EVM
                 if ((0, payload_builders_1.isSvmChain)(targetChain)) {
-                    // SVM path: no CEA lookup, build SVM payload
-                    const hasSvmExecute = !!params.svmExecute;
-                    let svmPayload = '0x';
-                    if (hasSvmExecute) {
-                        const exec = params.svmExecute;
-                        svmPayload = (0, payload_builders_1.encodeSvmExecutePayload)({
-                            targetProgram: exec.targetProgram,
-                            accounts: exec.accounts,
-                            ixData: exec.ixData,
-                            instructionId: 2,
-                        });
-                    }
+                    // SVM path: no CEA lookup, build SVM payload via IDL resolver
+                    const { svmPayload, hasExecute: hasSvmExecute } = (0, build_payload_1.buildSvmPayloadFromParams)({
+                        data: params.data,
+                        to: target,
+                        senderUea: ueaAddress,
+                    });
                     let prc20Token = selectors_1.ZERO_ADDRESS;
                     let burnAmount = BigInt(0);
                     if ((_b = params.funds) === null || _b === void 0 ? void 0 : _b.amount) {
@@ -432,7 +427,7 @@ function getSegmentType(route) {
 // composeCascade
 // ============================================================================
 function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    var _a, _b, _c, _d, _e, _f, _g;
     let accumulatedPushMulticalls = [];
     const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
     // Compute per-outbound nativeValueForGas from UEA balance
@@ -465,10 +460,9 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 if (isSvmSegment) {
                     // SVM: use the pre-built SVM payload from the hop descriptor
                     outboundPayload = (_a = firstHop.svmPayload) !== null && _a !== void 0 ? _a : '0x';
-                    // For SVM, target is the recipient/program from the hop params
+                    // For SVM, to.address IS the target (program for execute, recipient for withdraw)
                     const svmTarget = firstHop.params.to;
-                    targetForOutbound =
-                        (_c = (_b = firstHop.params.svmExecute) === null || _b === void 0 ? void 0 : _b.targetProgram) !== null && _c !== void 0 ? _c : svmTarget.address;
+                    targetForOutbound = svmTarget.address;
                 }
                 else if (isMigration) {
                     // Migration: use raw 4-byte MIGRATION_SELECTOR, no multicall wrapping
@@ -482,7 +476,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     targetForOutbound = (firstHop === null || firstHop === void 0 ? void 0 : firstHop.ceaAddress) || ueaAddress;
                 }
                 // Build outbound request
-                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetForOutbound, segment.prc20Token || selectors_1.ZERO_ADDRESS, segment.totalBurnAmount || BigInt(0), (_d = segment.gasLimit) !== null && _d !== void 0 ? _d : BigInt(0), outboundPayload, ueaAddress);
+                const outboundReq = (0, payload_builders_1.buildOutboundRequest)(targetForOutbound, segment.prc20Token || selectors_1.ZERO_ADDRESS, segment.totalBurnAmount || BigInt(0), (_b = segment.gasLimit) !== null && _b !== void 0 ? _b : BigInt(0), outboundPayload, ueaAddress);
                 // Build approval + outbound multicalls
                 const segGasFee = segment.gasFee || BigInt(0);
                 const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
@@ -507,7 +501,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 // Build push multicalls from this hop's own data (e.g., counter.increment())
                 // This is the Route 3 hop's payload that executes on Push Chain after inbound.
                 const hop0 = segment.hops[0];
-                if ((_e = hop0 === null || hop0 === void 0 ? void 0 : hop0.params) === null || _e === void 0 ? void 0 : _e.data) {
+                if ((_c = hop0 === null || hop0 === void 0 ? void 0 : hop0.params) === null || _c === void 0 ? void 0 : _c.data) {
                     const hopPushMulticalls = (0, payload_builders_1.buildExecuteMulticall)({
                         execute: {
                             to: hop0.params.to,
@@ -543,7 +537,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     let drainAmount = BigInt(0);
                     let tokenMintHex;
                     const params = hop.params;
-                    if (((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) && params.funds.amount > BigInt(0)) {
+                    if (((_d = params.funds) === null || _d === void 0 ? void 0 : _d.amount) && params.funds.amount > BigInt(0)) {
                         drainAmount = params.funds.amount;
                         const token = params.funds.token;
                         if (token && token.address) {
@@ -572,7 +566,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                     });
                     const svmBurnAmount = segment.totalBurnAmount || BigInt(0);
                     const outboundReq = (0, payload_builders_1.buildOutboundRequest)(gatewayProgramHex, segment.prc20Token ||
-                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), svmBurnAmount, (_g = segment.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), svmPayload, ueaAddress);
+                        (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), svmBurnAmount, (_e = segment.gasLimit) !== null && _e !== void 0 ? _e : BigInt(0), svmPayload, ueaAddress);
                     const inboundGasFee = segment.gasFee || BigInt(0);
                     const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
                         prc20Token: segment.prc20Token ||
@@ -598,7 +592,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 let tokenAddress = selectors_1.ZERO_ADDRESS;
                 let amount = BigInt(0);
                 const params = hop.params;
-                if ((_h = params.funds) === null || _h === void 0 ? void 0 : _h.amount) {
+                if ((_f = params.funds) === null || _f === void 0 ? void 0 : _f.amount) {
                     const token = params.funds.token;
                     if (token) {
                         if (token.mechanism === 'native') {
@@ -645,7 +639,7 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
                 // Wrap CEA multicall in outbound from Push Chain
                 const ceaPayload = (0, payload_builders_1.buildCeaMulticallPayload)(ceaMulticalls);
                 const outboundReq = (0, payload_builders_1.buildOutboundRequest)(ceaAddress, segment.prc20Token ||
-                    (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(0), (_j = segment.gasLimit) !== null && _j !== void 0 ? _j : BigInt(0), ceaPayload, ueaAddress);
+                    (0, helpers_1.getNativePRC20ForChain)(sourceChain, ctx.pushNetwork), segment.totalBurnAmount || BigInt(0), (_g = segment.gasLimit) !== null && _g !== void 0 ? _g : BigInt(0), ceaPayload, ueaAddress);
                 const inboundGasFee = segment.gasFee || BigInt(0);
                 const outboundMulticalls = (0, payload_builders_1.buildOutboundApprovalAndCall)({
                     prc20Token: segment.prc20Token ||

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

@@ -74,15 +74,15 @@ function executeFundsWithPayload(ctx, execute, eventBuffer, getResponseCallbacks
         const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
         const ueaBalance = yield ctx.pushClient.getBalance(ueaAddress);
         (0, context_1.fireProgressHook)(ctx, 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
+        // Determine USD to deposit via gateway (8 decimals) with caps: min=$1, max=$1000
         const oneUsd = utils_1.Utils.helpers.parseUnits('1', 8);
-        const tenUsd = utils_1.Utils.helpers.parseUnits('10', 8);
+        const maxUsd = utils_1.Utils.helpers.parseUnits('1000', 8);
         const deficit = requiredFunds > ueaBalance ? requiredFunds - ueaBalance : BigInt(0);
         let depositUsd = deficit > BigInt(0) ? ctx.pushClient.pushToUSDC(deficit) : oneUsd;
         if (depositUsd < oneUsd)
             depositUsd = oneUsd;
-        if (depositUsd > tenUsd)
-            throw new Error('Deposit value exceeds max $10 worth of native token');
+        if (depositUsd > maxUsd)
+            throw new Error('Deposit value exceeds max $1000 worth of native token');
         (0, context_1.fireProgressHook)(ctx, 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) {

package/src/lib/orchestrator/internals/execute-standard.js

@@ -28,6 +28,9 @@ const confirmation_1 = require("./confirmation");
 const gateway_client_1 = require("./gateway-client");
 const response_builder_1 = require("./response-builder");
 const push_chain_tx_1 = require("./push-chain-tx");
+const gas_calculator_1 = require("./gas-calculator");
+const helpers_2 = require("./helpers");
+const price_fetch_1 = require("../../price-fetch/price-fetch");
 function executeStandardPayload(ctx, execute, eventBuffer, getResponseCallbacks) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a, _b;
@@ -197,8 +200,106 @@ function executeStandardPayload(ctx, execute, eventBuffer, getResponseCallbacks)
             const fundDifference = requiredFunds - funds;
             const fixedPushAmount = utils_1.Utils.helpers.parseUnits('0.001', 18);
             const lockAmount = funds < requiredFunds ? fundDifference : fixedPushAmount;
-            const lockAmountInUSD = ctx.pushClient.pushToUSDC(lockAmount);
-            const feeLockTxHashBytes = yield (0, gateway_client_1.lockFee)(ctx, lockAmountInUSD, universalPayload, req);
+            // Size the USD deposit against the REAL Uniswap pool rate (not the fixed
+            // $0.10/PC SDK rate) for EVM origins. The pool typically prices PC much
+            // higher than $0.10, so pushToUSDC under-provisions and the resulting
+            // deposit gets clamped up to the $1 minimum, producing near-zero WPC.
+            // When the quoted USD exceeds the $1000 cap the later clamp kicks in
+            // (pool limit surfaces via the pre-flight capacity message).
+            // Falls back to pushToUSDC if the quoter is unavailable.
+            const { vm: sizingOriginVm } = chain_1.CHAIN_INFO[chain];
+            let lockAmountInUSD = ctx.pushClient.pushToUSDC(lockAmount);
+            if (sizingOriginVm === enums_1.VM.EVM && lockAmount > BigInt(0)) {
+                // Target lockAmount × 1.2 so that the 10% slippage margin applied by
+                // the pre-flight check (safeUPC = predictedUPC × 0.9) leaves enough
+                // headroom even when Uniswap V3 exactOutput↔exactInput quotes aren't
+                // perfectly symmetric (tick-math rounding).
+                const targetWPC = (lockAmount * BigInt(12)) / BigInt(10);
+                const originPrc20ForSizing = (0, helpers_2.getNativePRC20ForChain)(chain, ctx.pushNetwork);
+                const requiredNative = yield (0, gas_calculator_1.estimateNativeForDesiredDeposit)(ctx, targetWPC, originPrc20ForSizing);
+                if (requiredNative > BigInt(0)) {
+                    const ethPriceForSizing = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(chain);
+                    if (ethPriceForSizing > BigInt(0)) {
+                        // requiredNative (18-dec wei) × ethPrice (8-dec USD/ETH) / 1e18 = USD in 8-dec
+                        const poolBasedUsd = (requiredNative * ethPriceForSizing) / BigInt(1e18);
+                        (0, context_1.printLog)(ctx, `Fee-lock sizing: pushToUSDC=${lockAmountInUSD.toString()} (fixed $0.10/PC), ` +
+                            `poolBased=${poolBasedUsd.toString()} (pool quote for ${targetWPC.toString()} WPC) — using poolBased`);
+                        lockAmountInUSD = poolBasedUsd;
+                    }
+                }
+            }
+            // Apply minimum deposit override (e.g., Route 2 needs enough UPC for outbound swap)
+            const effectiveLockAmountInUSD = execute._minimumDepositUsd && execute._minimumDepositUsd > lockAmountInUSD
+                ? execute._minimumDepositUsd
+                : lockAmountInUSD;
+            // Pre-flight: predict the actual $PC the UEA will receive after the
+            // on-chain pETH → WPC swap and validate it covers requiredFunds.
+            // Uses the same Uniswap V3 quoter the chain uses (execute_inbound_gas.go).
+            // Mirrors the pattern in route-handlers.ts (Route 2/3).
+            const { vm: originVm } = chain_1.CHAIN_INFO[chain];
+            if (originVm === enums_1.VM.EVM) {
+                try {
+                    // Replicate lockFee's USD → native conversion (with its $1–$1000 clamp)
+                    const oneUsd = utils_1.Utils.helpers.parseUnits('1', 8);
+                    const maxUsd = utils_1.Utils.helpers.parseUnits('1000', 8);
+                    let depositUsd = effectiveLockAmountInUSD < oneUsd ? oneUsd : effectiveLockAmountInUSD;
+                    if (depositUsd > maxUsd)
+                        depositUsd = maxUsd;
+                    const ethPrice = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(chain);
+                    if (ethPrice > BigInt(0)) {
+                        const nativeAmountETH = (depositUsd * BigInt(1e18) + (ethPrice - BigInt(1))) / ethPrice + BigInt(1);
+                        const originPrc20 = (0, helpers_2.getNativePRC20ForChain)(chain, ctx.pushNetwork);
+                        const predictedUPC = yield (0, gas_calculator_1.estimateDepositFromLockedNative)(ctx, nativeAmountETH, originPrc20);
+                        if (predictedUPC > BigInt(0)) {
+                            // 10% slippage margin (same as route-handlers.ts)
+                            const safeUPC = (predictedUPC * BigInt(90)) / BigInt(100);
+                            const totalAvailable = safeUPC + funds;
+                            (0, context_1.printLog)(ctx, `Fee-lock pre-flight: deposit ${depositUsd.toString()} USD → ` +
+                                `~${nativeAmountETH.toString()} wei ETH → ~${predictedUPC.toString()} UPC ` +
+                                `(safe: ${safeUPC.toString()}), existing: ${funds.toString()}, ` +
+                                `total: ${totalAvailable.toString()}, required: ${requiredFunds.toString()}`);
+                            if (totalAvailable < requiredFunds) {
+                                const shortfall = requiredFunds - totalAvailable;
+                                // On failure only: probe pool capacity at the max cap so the
+                                // caller gets a readable "max transferable right now" number.
+                                // One extra quoter call — not run on the success path.
+                                let maxTransferableNote = '';
+                                if (depositUsd < maxUsd) {
+                                    const maxNativeAmountETH = (maxUsd * BigInt(1e18) + (ethPrice - BigInt(1))) / ethPrice + BigInt(1);
+                                    const maxPredictedUPC = yield (0, gas_calculator_1.estimateDepositFromLockedNative)(ctx, maxNativeAmountETH, originPrc20);
+                                    if (maxPredictedUPC > BigInt(0)) {
+                                        const maxSafeUPC = (maxPredictedUPC * BigInt(90)) / BigInt(100);
+                                        const gasReserve = utils_1.Utils.helpers.parseUnits('0.01', 18);
+                                        const maxFromDeposit = maxSafeUPC > gasReserve ? maxSafeUPC - gasReserve : BigInt(0);
+                                        const maxTransferable = funds + maxFromDeposit;
+                                        maxTransferableNote =
+                                            `Max transferable right now (at $1000 cap, pool-limited): ` +
+                                                `~${(Number(maxTransferable) / 1e18).toFixed(4)} $PC ` +
+                                                `(UEA balance ${(Number(funds) / 1e18).toFixed(4)} + ` +
+                                                `pool-safe deposit ${(Number(maxFromDeposit) / 1e18).toFixed(4)} − gas).`;
+                                        (0, context_1.printLog)(ctx, `Fee-lock capacity: ${maxTransferableNote}`);
+                                    }
+                                }
+                                throw new Error(`Insufficient deposit: the fee-lock will deposit ~${(Number(safeUPC) / 1e18).toFixed(4)} $PC ` +
+                                    `but the transaction requires ~${(Number(requiredFunds) / 1e18).toFixed(4)} $PC ` +
+                                    `(shortfall: ~${(Number(shortfall) / 1e18).toFixed(4)} $PC). ` +
+                                    `The fee-lock deposit is capped at $1000 USD. ` +
+                                    (maxTransferableNote ? maxTransferableNote + ' ' : '') +
+                                    `Reduce the transfer value or pre-fund the UEA (${UEA}) on Push Chain.`);
+                            }
+                        }
+                    }
+                }
+                catch (err) {
+                    // If the error is our own insufficient-deposit error, rethrow it
+                    if (err instanceof Error && err.message.startsWith('Insufficient deposit')) {
+                        throw err;
+                    }
+                    // Otherwise quoter failed — log and continue (same fallback as route-handlers)
+                    (0, context_1.printLog)(ctx, `Fee-lock pre-flight quote failed, proceeding without validation: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            const feeLockTxHashBytes = yield (0, gateway_client_1.lockFee)(ctx, effectiveLockAmountInUSD, universalPayload, req);
             feeLockTxHash = (0, viem_1.bytesToHex)(feeLockTxHashBytes);
             verificationData = (0, viem_1.bytesToHex)(feeLockTxHashBytes);
             const { vm } = chain_1.CHAIN_INFO[chain];

package/src/lib/orchestrator/internals/gas-calculator.d.ts

@@ -36,3 +36,22 @@ export declare function calculateGasAmountFromAmountOutMinETH(ctx: OrchestratorC
 }) => Promise<ConversionQuote>): Promise<{
     gasAmount: bigint;
 }>;
+/**
+ * Predicts how much UPC (WPC) the chain will deposit to the UEA from a given
+ * amount of locked native token (e.g., ETH on Sepolia). The chain converts
+ * locked ETH → pETH (PRC-20) → WPC via Uniswap V3 swap on Push Chain.
+ *
+ * Queries the same Uniswap V3 QuoterV2 the chain uses in execute_inbound_gas.go.
+ * Returns 0 on any failure (caller should fall back to other logic).
+ */
+export declare function estimateDepositFromLockedNative(ctx: OrchestratorContext, nativeAmountForLocker: bigint, prc20Token: `0x${string}`): Promise<bigint>;
+/**
+ * Inverse of estimateDepositFromLockedNative: given a desired WPC output,
+ * asks the Push Chain Uniswap V3 pool how much native PRC-20 (pETH) input is
+ * required to produce exactly that output via QuoterV2.quoteExactOutputSingle.
+ *
+ * Used to size fee-lock deposits against the real on-chain pool rate instead
+ * of the fixed $0.10/PC SDK rate. Returns 0 on any failure (caller should
+ * fall back to the fixed-rate sizing).
+ */
+export declare function estimateNativeForDesiredDeposit(ctx: OrchestratorContext, desiredWpc: bigint, prc20Token: `0x${string}`): Promise<bigint>;

package/src/lib/orchestrator/internals/gas-calculator.js

@@ -10,6 +10,8 @@ exports.estimateNativeValueForSwap = estimateNativeValueForSwap;
 exports.queryRescueGasFee = queryRescueGasFee;
 exports.calculateNativeAmountForDeposit = calculateNativeAmountForDeposit;
 exports.calculateGasAmountFromAmountOutMinETH = calculateGasAmountFromAmountOutMinETH;
+exports.estimateDepositFromLockedNative = estimateDepositFromLockedNative;
+exports.estimateNativeForDesiredDeposit = estimateNativeForDesiredDeposit;
 const tslib_1 = require("tslib");
 const web3_js_1 = require("@solana/web3.js");
 const viem_1 = require("viem");
@@ -335,13 +337,13 @@ function calculateNativeAmountForDeposit(ctx, chain, requiredFunds, ueaBalance)
         var _a, _b;
         (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_02_01);
         const oneUsd = utils_1.Utils.helpers.parseUnits('1', 8);
-        const tenUsd = utils_1.Utils.helpers.parseUnits('10', 8);
+        const maxUsd = utils_1.Utils.helpers.parseUnits('1000', 8);
         const deficit = requiredFunds > ueaBalance ? requiredFunds - ueaBalance : BigInt(0);
         let depositUsd = deficit > BigInt(0) ? ctx.pushClient.pushToUSDC(deficit) : oneUsd;
         if (depositUsd < oneUsd)
             depositUsd = oneUsd;
-        if (depositUsd > tenUsd)
-            throw new Error('Deposit value exceeds max $10 worth of native token');
+        if (depositUsd > maxUsd)
+            throw new Error('Deposit value exceeds max $1000 worth of native token');
         if (chain_1.CHAIN_INFO[chain].vm === enums_1.VM.SVM) {
             const svmClient = new svm_client_1.SvmClient({
                 rpcUrls: ctx.rpcUrls[enums_1.CHAIN.SOLANA_DEVNET] ||
@@ -421,4 +423,188 @@ function calculateGasAmountFromAmountOutMinETH(ctx, gasTokenAddress, amountOutMi
         return { gasAmount };
     });
 }
+// ============================================================================
+// Estimate UPC deposit from locked ETH via Uniswap V3 quote
+// ============================================================================
+/**
+ * Predicts how much UPC (WPC) the chain will deposit to the UEA from a given
+ * amount of locked native token (e.g., ETH on Sepolia). The chain converts
+ * locked ETH → pETH (PRC-20) → WPC via Uniswap V3 swap on Push Chain.
+ *
+ * Queries the same Uniswap V3 QuoterV2 the chain uses in execute_inbound_gas.go.
+ * Returns 0 on any failure (caller should fall back to other logic).
+ */
+function estimateDepositFromLockedNative(ctx, nativeAmountForLocker, prc20Token) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            const pushChain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork);
+            const quoterAddress = (_b = (_a = chain_1.CHAIN_INFO[pushChain]) === null || _a === void 0 ? void 0 : _a.dex) === null || _b === void 0 ? void 0 : _b.uniV3QuoterV2;
+            if (!quoterAddress || quoterAddress.startsWith('0xTBD'))
+                return BigInt(0);
+            // Get UniversalCore → WPC address + fee tier (reuses existing ABI)
+            const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+            const universalCoreAddress = yield ctx.pushClient.readContract({
+                address: gatewayPcAddress,
+                abi: abi_1.UNIVERSAL_GATEWAY_PC,
+                functionName: 'UNIVERSAL_CORE',
+                args: [],
+            });
+            const [wpcAddress, feeTier] = yield Promise.all([
+                ctx.pushClient.readContract({
+                    address: universalCoreAddress,
+                    abi: UNIVERSAL_CORE_SWAP_HELPERS_ABI,
+                    functionName: 'WPC',
+                    args: [],
+                }),
+                ctx.pushClient.readContract({
+                    address: universalCoreAddress,
+                    abi: UNIVERSAL_CORE_SWAP_HELPERS_ABI,
+                    functionName: 'defaultFeeTier',
+                    args: [prc20Token],
+                }),
+            ]);
+            if (!feeTier || !wpcAddress)
+                return BigInt(0);
+            // QuoterV2.quoteExactInputSingle — same call the chain relay makes
+            const QUOTER_ABI = [
+                {
+                    type: 'function',
+                    name: 'quoteExactInputSingle',
+                    inputs: [
+                        {
+                            type: 'tuple',
+                            components: [
+                                { name: 'tokenIn', type: 'address' },
+                                { name: 'tokenOut', type: 'address' },
+                                { name: 'amountIn', type: 'uint256' },
+                                { name: 'fee', type: 'uint24' },
+                                { name: 'sqrtPriceLimitX96', type: 'uint160' },
+                            ],
+                        },
+                    ],
+                    outputs: [
+                        { name: 'amountOut', type: 'uint256' },
+                        { name: 'sqrtPriceX96After', type: 'uint160' },
+                        { name: 'initializedTicksCrossed', type: 'uint32' },
+                        { name: 'gasEstimate', type: 'uint256' },
+                    ],
+                    stateMutability: 'view',
+                },
+            ];
+            const result = yield ctx.pushClient.readContract({
+                address: quoterAddress,
+                abi: QUOTER_ABI,
+                functionName: 'quoteExactInputSingle',
+                args: [
+                    {
+                        tokenIn: prc20Token,
+                        tokenOut: wpcAddress,
+                        amountIn: nativeAmountForLocker,
+                        fee: feeTier,
+                        sqrtPriceLimitX96: BigInt(0),
+                    },
+                ],
+            });
+            const amountOut = result[0];
+            (0, context_1.printLog)(ctx, `estimateDepositFromLockedNative — quote: ${nativeAmountForLocker.toString()} pETH → ${amountOut.toString()} WPC (fee tier: ${feeTier})`);
+            return amountOut;
+        }
+        catch (err) {
+            (0, context_1.printLog)(ctx, `estimateDepositFromLockedNative — failed: ${err instanceof Error ? err.message : String(err)}`);
+            return BigInt(0);
+        }
+    });
+}
+/**
+ * Inverse of estimateDepositFromLockedNative: given a desired WPC output,
+ * asks the Push Chain Uniswap V3 pool how much native PRC-20 (pETH) input is
+ * required to produce exactly that output via QuoterV2.quoteExactOutputSingle.
+ *
+ * Used to size fee-lock deposits against the real on-chain pool rate instead
+ * of the fixed $0.10/PC SDK rate. Returns 0 on any failure (caller should
+ * fall back to the fixed-rate sizing).
+ */
+function estimateNativeForDesiredDeposit(ctx, desiredWpc, prc20Token) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            if (desiredWpc <= BigInt(0))
+                return BigInt(0);
+            const pushChain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork);
+            const quoterAddress = (_b = (_a = chain_1.CHAIN_INFO[pushChain]) === null || _a === void 0 ? void 0 : _a.dex) === null || _b === void 0 ? void 0 : _b.uniV3QuoterV2;
+            if (!quoterAddress || quoterAddress.startsWith('0xTBD'))
+                return BigInt(0);
+            const gatewayPcAddress = (0, helpers_1.getUniversalGatewayPCAddress)();
+            const universalCoreAddress = yield ctx.pushClient.readContract({
+                address: gatewayPcAddress,
+                abi: abi_1.UNIVERSAL_GATEWAY_PC,
+                functionName: 'UNIVERSAL_CORE',
+                args: [],
+            });
+            const [wpcAddress, feeTier] = yield Promise.all([
+                ctx.pushClient.readContract({
+                    address: universalCoreAddress,
+                    abi: UNIVERSAL_CORE_SWAP_HELPERS_ABI,
+                    functionName: 'WPC',
+                    args: [],
+                }),
+                ctx.pushClient.readContract({
+                    address: universalCoreAddress,
+                    abi: UNIVERSAL_CORE_SWAP_HELPERS_ABI,
+                    functionName: 'defaultFeeTier',
+                    args: [prc20Token],
+                }),
+            ]);
+            if (!feeTier || !wpcAddress)
+                return BigInt(0);
+            const QUOTER_ABI = [
+                {
+                    type: 'function',
+                    name: 'quoteExactOutputSingle',
+                    inputs: [
+                        {
+                            type: 'tuple',
+                            components: [
+                                { name: 'tokenIn', type: 'address' },
+                                { name: 'tokenOut', type: 'address' },
+                                { name: 'amount', type: 'uint256' },
+                                { name: 'fee', type: 'uint24' },
+                                { name: 'sqrtPriceLimitX96', type: 'uint160' },
+                            ],
+                        },
+                    ],
+                    outputs: [
+                        { name: 'amountIn', type: 'uint256' },
+                        { name: 'sqrtPriceX96After', type: 'uint160' },
+                        { name: 'initializedTicksCrossed', type: 'uint32' },
+                        { name: 'gasEstimate', type: 'uint256' },
+                    ],
+                    stateMutability: 'view',
+                },
+            ];
+            const result = yield ctx.pushClient.readContract({
+                address: quoterAddress,
+                abi: QUOTER_ABI,
+                functionName: 'quoteExactOutputSingle',
+                args: [
+                    {
+                        tokenIn: prc20Token,
+                        tokenOut: wpcAddress,
+                        amount: desiredWpc,
+                        fee: feeTier,
+                        sqrtPriceLimitX96: BigInt(0),
+                    },
+                ],
+            });
+            const amountIn = result[0];
+            (0, context_1.printLog)(ctx, `estimateNativeForDesiredDeposit — quote: ${desiredWpc.toString()} WPC ← ${amountIn.toString()} pETH (fee tier: ${feeTier})`);
+            return amountIn;
+        }
+        catch (err) {
+            (0, context_1.printLog)(ctx, `estimateNativeForDesiredDeposit — failed: ${err instanceof Error ? err.message : String(err)}`);
+            return BigInt(0);
+        }
+    });
+}
 //# sourceMappingURL=gas-calculator.js.map

package/src/lib/orchestrator/internals/gateway-client.js

@@ -96,10 +96,10 @@ req) {
                 const nativeTokenUsdPrice = yield new price_fetch_1.PriceFetch(ctx.rpcUrls).getPrice(chain);
                 const nativeDecimals = 18;
                 const oneUsd = utils_1.Utils.helpers.parseUnits('1', 8);
-                const tenUsd = utils_1.Utils.helpers.parseUnits('10', 8);
+                const maxUsd = utils_1.Utils.helpers.parseUnits('1000', 8);
                 let depositUsd = amount < oneUsd ? oneUsd : amount;
-                if (depositUsd > tenUsd)
-                    depositUsd = tenUsd;
+                if (depositUsd > maxUsd)
+                    depositUsd = maxUsd;
                 let nativeAmount = (depositUsd * BigInt(Math.pow(10, nativeDecimals)) +
                     (nativeTokenUsdPrice - BigInt(1))) /
                     nativeTokenUsdPrice;
@@ -114,10 +114,10 @@ req) {
                 ]);
                 const nativeDecimals = 9;
                 const oneUsd = utils_1.Utils.helpers.parseUnits('1', 8);
-                const tenUsd = utils_1.Utils.helpers.parseUnits('10', 8);
+                const maxUsd = utils_1.Utils.helpers.parseUnits('1000', 8);
                 let depositUsd = amount < oneUsd ? oneUsd : amount;
-                if (depositUsd > tenUsd)
-                    depositUsd = tenUsd;
+                if (depositUsd > maxUsd)
+                    depositUsd = maxUsd;
                 let nativeAmount = (depositUsd * BigInt(Math.pow(10, nativeDecimals)) +
                     (nativeTokenUsdPrice - BigInt(1))) /
                     nativeTokenUsdPrice;

package/src/lib/orchestrator/internals/push-chain-tx.js

@@ -195,10 +195,24 @@ function extractPcTxAndTransform(ctx, pushChainUniversalTx, gatewayTxHash, event
         const lastPcTransaction = pushChainUniversalTx.pcTx.at(-1);
         (0, context_1.printLog)(ctx, `${label} — pcTx: ` + JSON.stringify(pushChainUniversalTx.pcTx.map((p) => ({ txHash: p.txHash, status: p.status, errorMsg: p.errorMsg })), null, 2));
         (0, context_1.printLog)(ctx, `${label} — using lastPcTransaction: ` + JSON.stringify(lastPcTransaction, null, 2));
-        if (!(lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.txHash)) {
-            const failedPcTx = pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
+        if (!(lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.txHash) || lastPcTransaction.status === 'FAILED') {
+            const failedPcTx = (lastPcTransaction === null || lastPcTransaction === void 0 ? void 0 : lastPcTransaction.status) === 'FAILED'
+                ? lastPcTransaction
+                : pushChainUniversalTx.pcTx.find((pcTx) => pcTx.status === 'FAILED' && pcTx.errorMsg);
             const errorDetails = (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg) ? `: ${failedPcTx.errorMsg}` : '';
-            throw new Error(`No transaction hash found in Push Chain response for gateway tx: ${gatewayTxHash}${errorDetails}`);
+            // Parse known UEA error selectors for actionable hints
+            let hint = '';
+            if (failedPcTx === null || failedPcTx === void 0 ? void 0 : failedPcTx.errorMsg) {
+                if (failedPcTx.errorMsg.includes('0xacfdb444')) {
+                    hint = ' [ExecutionFailed: the subcall to the target contract reverted. ' +
+                        'Check that the target address can receive native tokens (has receive/fallback) ' +
+                        'and that calldata matches a valid function signature.]';
+                }
+                else if (failedPcTx.errorMsg.includes('0x179a867c')) {
+                    hint = ' [ExpiredDeadline: the transaction deadline has passed.]';
+                }
+            }
+            throw new Error(`Push Chain transaction failed for gateway tx: ${gatewayTxHash}${errorDetails}${hint}`);
         }
         const tx = yield ctx.pushClient.getTransaction(lastPcTransaction.txHash);
         return transformFn(tx, eventBuffer);

package/src/lib/orchestrator/internals/response-builder.js

@@ -150,7 +150,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
             throw new Error('trackTransaction requires ResponseBuilderCallbacks');
         }
         const { chain = (0, helpers_1.getPushChainForNetwork)(ctx.pushNetwork), progressHook, waitForCompletion = true, advanced = {}, } = options !== null && options !== void 0 ? options : {};
-        const { timeout = 300000, rpcUrls = {} } = advanced;
+        const { timeout = 300000, pollingIntervalMs = 1000, rpcUrls = {} } = advanced;
         // Event buffer for replay via response.progressHook()
         const eventBuffer = [];
         // Helper to emit progress events
@@ -190,7 +190,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
                     throw new Error(`Timeout: transaction ${txHash} not confirmed within ${timeout}ms`);
                 }
                 // Brief delay before retry
-                yield new Promise((r) => setTimeout(r, 1000));
+                yield new Promise((r) => setTimeout(r, pollingIntervalMs));
             }
         }
         // Try to get UniversalTx data for richer progress reconstruction
@@ -256,7 +256,7 @@ function trackTransaction(ctx, txHash, options, callbacks) {
 function transformToUniversalTxResponse(ctx_1, tx_1) {
     return tslib_1.__awaiter(this, arguments, void 0, function* (ctx, tx, eventBuffer = [], callbacks) {
         const chain = ctx.universalSigner.account.chain;
-        const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+        let { vm, chainId } = chain_1.CHAIN_INFO[chain];
         let from;
         let to;
         let value;
@@ -269,6 +269,13 @@ function transformToUniversalTxResponse(ctx_1, tx_1) {
                 throw new Error('UEA origin account is null');
             }
             originAddress = ueaOrigin.account.address;
+            // Use the resolved origin chain for vm/chainId so that the `origin`
+            // field reflects the transaction's actual origin, not the tracker's.
+            const resolvedChainInfo = chain_1.CHAIN_INFO[ueaOrigin.account.chain];
+            if (resolvedChainInfo) {
+                vm = resolvedChainInfo.vm;
+                chainId = resolvedChainInfo.chainId;
+            }
             from = (0, viem_1.getAddress)(tx.to);
             let decoded;
             if (tx.input !== '0x') {