@pushchain/core 6.0.16 → 6.0.18

package/CHANGELOG.md

@@ -1,4 +1,140 @@
-@pushchain/core@6.0.2 (unreleased)
+@pushchain/core@6.0.17 (2026-06-09)
+
+- fix: make SVM payload encoding browser-safe
+- fix: prevent underfunded outbound gas swaps
+
+---
+
+@pushchain/core@6.0.17 (unreleased)
+
+- Fixed outbound (UOA_TO_CEA) transactions reverting on-chain with Uniswap `STF`
+  when the UEA held a modest amount of native PC - e.g. pETH -> Ethereum ETH.
+  Destination gas is funded by swapping the UEA's PC into the gas token, and
+  `capSwapEstimate` was sizing `nativeValueForGas` down to `balance - reserve`
+  even when that fell below the swap's actual requirement, so the swap reverted
+  with `STF` while the native pre-flight stayed silent (its check was
+  self-satisfying). The estimator now keeps the full requirement when the
+  affordable amount can't cover the swap floor, so the pre-flight reports the
+  real PC shortfall instead of emitting a cryptic on-chain `STF`.
+
+- Fixed SVM payload encoding in browser environments whose `Buffer` polyfill
+  does not implement Node's `writeBigUInt64LE` / `writeBigInt64LE` methods.
+  The encoder now writes u64/i64 fields with `DataView`, preserving the same
+  little-endian wire format without crashing during Solana transaction builds.
+
+---
+
+@pushchain/core@6.0.16 (2026-06-05)
+
+- Fixed SVM domain-separator chainId encoding to match the pre-EIP-712 UEA_SVM
+  behavior on Donut (raw string encoding), restoring correct SVM signature
+  validation.
+
+- Fixed Route 1 deposit-sizing progress-hook ordering: the `103-03-04` event is
+  now emitted after UEA resolution so it matches the funds-payload path sequence.
+
+- Additional cascade execution test coverage and validation fixes.
+
+---
+
+@pushchain/core@6.0.15 (2026-06-02)
+
+- Internal fixes to response-building logic.
+
+---
+
+@pushchain/core@6.0.14 (2026-06-02)
+
+- `trackTransaction` now resolves the originating source chain correctly even when
+  the tracked hash points to Push Chain, with explicit chain-support checks.
+
+- Added `finalTxHash` to `UniversalTxResponse` — a single hash that resolves across
+  all routes (R1 → Push tx, R2 → external tx, R3 → Push inbound tx).
+
+---
+
+@pushchain/core@6.0.13 (2026-05-26)
+
+- Maintenance release (version bump only; no code changes).
+
+---
+
+@pushchain/core@6.0.12 (2026-05-26)
+
+- Maintenance release (version bump only; no code changes).
+
+---
+
+@pushchain/core@6.0.11 (2026-05-25)
+
+- Added transaction-indexing polling for SVM multihop: the SDK now retries with
+  backoff (1s polling, 30s timeout) before fetching transaction details, fixing
+  failures when querying immediately after confirmation.
+
+---
+
+@pushchain/core@6.0.10 (2026-05-23)
+
+- Added Borsh-encoded SVM-origin inbound relay payload building for Route 3
+  (CEA → Push).
+
+- Improved SVM child-inbound detection using log index for more reliable
+  transaction identification.
+
+---
+
+@pushchain/core@6.0.9 (2026-05-19)
+
+- Added a decoder for the `GasPriceBelowBase` (0x05aab006) error with an
+  actionable hint about gasPrice overrides.
+
+---
+
+@pushchain/core@6.0.8 (2026-05-19)
+
+- Maintenance release (version bump only; no code changes).
+
+---
+
+@pushchain/core@6.0.7 (2026-05-19)
+
+- Fixed corner-case bugs in cascade execution and funds-payload handling for
+  cross-chain transactions.
+
+---
+
+@pushchain/core@6.0.6 (2026-05-18)
+
+- Clarified progress-event message text (no functional changes).
+
+---
+
+@pushchain/core@6.0.5 (2026-05-18)
+
+- Added multihop progress markers: `SEND_TX_199_03` / `SEND_TX_199_99` (Route 1
+  intermediate success) and `SEND_TX_399_99` (Route 3 round-trip completion), with
+  improved cascade event sequencing.
+
+---
+
+@pushchain/core@6.0.4 (2026-05-18)
+
+- Fixed payload-builder detection of executable data vs. value-only transfers,
+  including multicall empty-array handling.
+
+- Fixed progress-hook wiring for funds-only execution paths.
+
+---
+
+@pushchain/core@6.0.3 (2026-05-16)
+
+- Added per-call `progressHook` support: `sendTransaction(params, { progressHook })`
+  is additive with the init-time hook, auto-registers on the returned response for
+  wait-phase progress, and dedupes by reference to avoid double-firing.
+
+---
+
+@pushchain/core@6.0.2 (2026-05-16)
 
 - Token constants now expose the missing `USDT.bsc` chain-suffix accessor,
   while keeping `USDT.bnb` as a deprecated alias for backward compatibility.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "6.0.16",
+  "version": "6.0.18",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

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

@@ -1107,7 +1107,7 @@ function composeCascadeDetailed(ctx, segments, ueaAddress, ueaBalance, ueaNonce,
                     else {
                         evmFallbackValue = segGasFee * BigInt(1000000);
                     }
-                    let nativeValueForGas = (_h = (_g = svmOverride !== null && svmOverride !== void 0 ? svmOverride : evmNativeValueBySegment.get(segment)) !== null && _g !== void 0 ? _g : perOutboundNativeValue) !== null && _h !== void 0 ? _h : evmFallbackValue;
+                    const nativeValueForGas = (_h = (_g = svmOverride !== null && svmOverride !== void 0 ? svmOverride : evmNativeValueBySegment.get(segment)) !== null && _g !== void 0 ? _g : perOutboundNativeValue) !== null && _h !== void 0 ? _h : evmFallbackValue;
                     // SDK 5.2 Case C: when the segment's sizing is category C, compose
                     // R2/OUTBOUND_TO_CEA segments no longer apply Case A/B/C sizing
                     // (scoped to R1 + R3 only). segment.sizing may still be populated

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

@@ -158,7 +158,7 @@ function executeFundsWithPayload(ctx, execute, eventBuffer, getResponseCallbacks
             }
         }
         // Final USD(8) -> native conversion reusing the cached price fetched above.
-        let nativeAmount = usdToNative(depositUsd);
+        const nativeAmount = usdToNative(depositUsd);
         (0, context_1.fireProgressHook)(ctx, progress_hook_types_1.PROGRESS_HOOK.SEND_TX_103_03_04, nativeAmount, depositUsd, chain);
         const bridgeAmount = execute.funds.amount;
         const symbol = execute.funds.token.symbol;

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

@@ -25,6 +25,23 @@ export declare function queryOutboundGasFee(ctx: OrchestratorContext, prc20Token
  * Falls back to a percentage of accountBalance if any on-chain query fails.
  */
 export declare function estimateNativeValueForSwap(ctx: OrchestratorContext, universalCoreAddress: `0x${string}`, gasToken: `0x${string}`, gasFee: bigint, accountBalance: bigint): Promise<bigint>;
+/**
+ * Bound the buffered swap estimate by the UEA's affordable PC.
+ *
+ * `result` is the 2.2x-buffered WPC needed for the gas swap; `minNeeded` is the
+ * un-buffered minimum the WPC->gasToken `exactOutput` swap actually consumes.
+ *
+ * Reducing the buffer to fit a tight balance is fine - but ONLY while the
+ * affordable amount (`accountBalance - reserve`) still covers `minNeeded`.
+ * Below that floor the swap cannot complete and reverts on-chain with Uniswap
+ * `STF`. The previous logic returned `accountBalance - reserve` unconditionally,
+ * which (a) under-funded `msg.value` into a doomed swap and (b) made the native
+ * preflight self-satisfying (`balance >= (balance - reserve) + reserve`), so the
+ * shortfall went undetected. When the balance can't cover the floor we now
+ * return the full `result` so the caller's preflight reports the real shortfall
+ * instead of emitting a cryptic STF.
+ */
+export declare function capSwapEstimate(result: bigint, accountBalance: bigint, reserve: bigint, minNeeded?: bigint): bigint;
 export declare function queryRescueGasFee(ctx: OrchestratorContext, prc20Token: `0x${string}`, destinationChain?: CHAIN): Promise<{
     gasToken: `0x${string}`;
     gasFee: bigint;

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

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureErc20Allowance = ensureErc20Allowance;
 exports.queryOutboundGasFee = queryOutboundGasFee;
 exports.estimateNativeValueForSwap = estimateNativeValueForSwap;
+exports.capSwapEstimate = capSwapEstimate;
 exports.queryRescueGasFee = queryRescueGasFee;
 exports.calculateNativeAmountForDeposit = calculateNativeAmountForDeposit;
 exports.calculateGasAmountFromAmountOutMinETH = calculateGasAmountFromAmountOutMinETH;
@@ -309,7 +310,7 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
                     const result = (exactWpcNeeded * SWAP_BUFFER_NUM) / SWAP_BUFFER_DEN;
                     (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — exactOutput quoter=${quoterAddress}, ` +
                         `wpcNeeded=${exactWpcNeeded}, withBuffer(2.2x)=${result}`);
-                    return capSwapEstimate(result, accountBalance, GAS_RESERVE);
+                    return capSwapEstimate(result, accountBalance, GAS_RESERVE, exactWpcNeeded);
                 }
                 catch (quoteErr) {
                     (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — exactOutput quote failed: ${quoteErr instanceof Error ? quoteErr.message : String(quoteErr)}, falling back to slot0 price`);
@@ -355,7 +356,7 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
             const result = (wpcNeeded * SWAP_BUFFER_NUM) / SWAP_BUFFER_DEN;
             (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — pool=${poolAddress}, sqrtPriceX96=${sqrtPriceX96}, ` +
                 `wpcNeeded=${wpcNeeded}, withBuffer(2.2x)=${result}`);
-            return capSwapEstimate(result, accountBalance, GAS_RESERVE);
+            return capSwapEstimate(result, accountBalance, GAS_RESERVE, wpcNeeded);
         }
         catch (err) {
             (0, context_1.printLog)(ctx, `estimateNativeValueForSwap — failed: ${err instanceof Error ? err.message : String(err)}, using balance fallback`);
@@ -363,14 +364,30 @@ function estimateNativeValueForSwap(ctx, universalCoreAddress, gasToken, gasFee,
         }
     });
 }
-function capSwapEstimate(result, accountBalance, reserve) {
+/**
+ * Bound the buffered swap estimate by the UEA's affordable PC.
+ *
+ * `result` is the 2.2x-buffered WPC needed for the gas swap; `minNeeded` is the
+ * un-buffered minimum the WPC->gasToken `exactOutput` swap actually consumes.
+ *
+ * Reducing the buffer to fit a tight balance is fine - but ONLY while the
+ * affordable amount (`accountBalance - reserve`) still covers `minNeeded`.
+ * Below that floor the swap cannot complete and reverts on-chain with Uniswap
+ * `STF`. The previous logic returned `accountBalance - reserve` unconditionally,
+ * which (a) under-funded `msg.value` into a doomed swap and (b) made the native
+ * preflight self-satisfying (`balance >= (balance - reserve) + reserve`), so the
+ * shortfall went undetected. When the balance can't cover the floor we now
+ * return the full `result` so the caller's preflight reports the real shortfall
+ * instead of emitting a cryptic STF.
+ */
+function capSwapEstimate(result, accountBalance, reserve, minNeeded = BigInt(0)) {
     if (accountBalance > result + reserve) {
         return result;
     }
-    if (accountBalance > reserve) {
+    if (accountBalance > reserve && accountBalance - reserve >= minNeeded) {
         return accountBalance - reserve;
     }
-    return result; // let caller decide if balance is too low
+    return result; // balance can't cover the swap floor - surface true need to preflight
 }
 function balanceFallback(balance, divisor, reserve) {
     const fraction = balance / divisor;

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

@@ -213,14 +213,28 @@ function encodeUniversalPayload(payload) {
     ]);
 }
 function encodeUniversalPayloadSvm(payload) {
-    const writeU64 = (val) => {
+    const U64_MAX = (BigInt(1) << BigInt(64)) - BigInt(1);
+    const I64_MIN = -(BigInt(1) << BigInt(63));
+    const I64_MAX = (BigInt(1) << BigInt(63)) - BigInt(1);
+    const viewFor = (buf) => new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    const assertRange = (field, val, min, max) => {
+        if (val < min || val > max) {
+            throw new RangeError(`SVM payload field ${field} out of range: ${val.toString()} ` +
+                `(expected ${min.toString()}..${max.toString()})`);
+        }
+    };
+    const writeU64 = (field, val) => {
+        const n = BigInt(val);
+        assertRange(field, n, BigInt(0), U64_MAX);
         const b = Buffer.alloc(8);
-        b.writeBigUInt64LE(BigInt(val), 0);
+        viewFor(b).setBigUint64(0, n, true);
         return b;
     };
-    const writeI64 = (val) => {
+    const writeI64 = (field, val) => {
+        const n = BigInt(val);
+        assertRange(field, n, I64_MIN, I64_MAX);
         const b = Buffer.alloc(8);
-        b.writeBigInt64LE(BigInt(val), 0);
+        viewFor(b).setBigInt64(0, n, true);
         return b;
     };
     const writeVecU8 = (val) => {
@@ -228,7 +242,7 @@ function encodeUniversalPayloadSvm(payload) {
             ? val
             : Buffer.from(val);
         const len = Buffer.alloc(4);
-        len.writeUInt32LE(bytes.length, 0);
+        viewFor(len).setUint32(0, bytes.length, true);
         return Buffer.concat([len, bytes]);
     };
     const writeU8 = (val) => Buffer.from([val]);
@@ -237,18 +251,18 @@ function encodeUniversalPayloadSvm(payload) {
         const hex = to.slice(2).padStart(40, '0');
         return Buffer.from(hex, 'hex');
     })();
-    const valueBytes = writeU64(payload.value);
+    const valueBytes = writeU64('value', payload.value);
     const dataBytes = (() => {
         const data = payload.data;
         const hex = data.slice(2);
         const buf = hex.length ? Buffer.from(hex, 'hex') : Buffer.alloc(0);
         return writeVecU8(buf);
     })();
-    const gasLimitBytes = writeU64(payload.gasLimit);
-    const maxFeePerGasBytes = writeU64(payload.maxFeePerGas);
-    const maxPriorityFeePerGasBytes = writeU64(payload.maxPriorityFeePerGas);
-    const nonceBytes = writeU64(payload.nonce);
-    const deadlineBytes = writeI64(payload.deadline);
+    const gasLimitBytes = writeU64('gasLimit', payload.gasLimit);
+    const maxFeePerGasBytes = writeU64('maxFeePerGas', payload.maxFeePerGas);
+    const maxPriorityFeePerGasBytes = writeU64('maxPriorityFeePerGas', payload.maxPriorityFeePerGas);
+    const nonceBytes = writeU64('nonce', payload.nonce);
+    const deadlineBytes = writeI64('deadline', payload.deadline);
     const vTypeVal = (() => {
         const v = payload.vType;
         if (typeof v === 'number')

package/src/lib/orchestrator/payload-builders.d.ts

@@ -127,14 +127,14 @@ export declare function buildMigrationPayload(): `0x${string}`;
  * Build approval multicalls + sendUniversalTxOutbound call for Push Chain.
  *
  * Extracted from executeUoaToCea to be reusable in cascade composition.
- * Handles two cases:
- * - gasToken === prc20Token: single approval for burnAmount + gasFee
- * - gasToken !== prc20Token: two separate approvals
+ * The PRC-20 approval covers only the burn amount. Destination gas is funded
+ * through native PC msg.value on sendUniversalTxOutbound; UniversalCore swaps
+ * that native value into the route gas token inside swapAndBurnGas.
  *
  * @param opts.prc20Token - PRC-20 token to burn
- * @param opts.gasToken - Gas token for fee payment
+ * @param opts.gasToken - Gas token for fee payment, used by the outbound request
  * @param opts.burnAmount - Amount to burn
- * @param opts.gasFee - Gas fee amount
+ * @param opts.gasFee - Gas fee amount, used only for fallback native value sizing
  * @param opts.gatewayPcAddress - UniversalGatewayPC precompile address
  * @param opts.outboundRequest - The outbound request struct
  * @returns Array of MultiCall operations (approvals + outbound call)

package/src/lib/orchestrator/payload-builders.js

@@ -342,14 +342,14 @@ function buildMigrationPayload() {
  * Build approval multicalls + sendUniversalTxOutbound call for Push Chain.
  *
  * Extracted from executeUoaToCea to be reusable in cascade composition.
- * Handles two cases:
- * - gasToken === prc20Token: single approval for burnAmount + gasFee
- * - gasToken !== prc20Token: two separate approvals
+ * The PRC-20 approval covers only the burn amount. Destination gas is funded
+ * through native PC msg.value on sendUniversalTxOutbound; UniversalCore swaps
+ * that native value into the route gas token inside swapAndBurnGas.
  *
  * @param opts.prc20Token - PRC-20 token to burn
- * @param opts.gasToken - Gas token for fee payment
+ * @param opts.gasToken - Gas token for fee payment, used by the outbound request
  * @param opts.burnAmount - Amount to burn
- * @param opts.gasFee - Gas fee amount
+ * @param opts.gasFee - Gas fee amount, used only for fallback native value sizing
  * @param opts.gatewayPcAddress - UniversalGatewayPC precompile address
  * @param opts.outboundRequest - The outbound request struct
  * @returns Array of MultiCall operations (approvals + outbound call)