@pushchain/core 5.1.4-alpha.4 → 5.1.4-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "5.1.4-alpha.4",
+  "version": "5.1.4-alpha.5",
   "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, CascadedTransactionBuilder, 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, SvmExecuteParams, 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.d.ts

@@ -5,7 +5,7 @@
  * getSegmentType, composeCascade, createCascadedBuilder, createChainedBuilder.
  */
 import { TransactionRoute } from '../route-detector';
-import type { HopDescriptor, CascadeSegment, CascadeSegmentType, PreparedUniversalTx, CascadedTransactionBuilder, CascadeHopInfo, UniversalTxResponse, UniversalExecuteParams, MultiCall, WaitForOutboundOptions, OutboundTxDetails } from '../orchestrator.types';
+import type { HopDescriptor, CascadeSegment, CascadeSegmentType, PreparedUniversalTx, CascadedTxResponse, CascadeHopInfo, UniversalTxResponse, UniversalExecuteParams, MultiCall, WaitForOutboundOptions, OutboundTxDetails } from '../orchestrator.types';
 import type { OrchestratorContext } from './context';
 export interface CascadeCallbacks {
     executeFn: (params: any) => Promise<UniversalTxResponse>;
@@ -20,4 +20,6 @@ export declare function buildHopDescriptor(ctx: OrchestratorContext, params: Uni
 export declare function classifyIntoSegments(hops: HopDescriptor[]): CascadeSegment[];
 export declare function getSegmentType(route: string): CascadeSegmentType;
 export declare function composeCascade(ctx: OrchestratorContext, segments: CascadeSegment[], ueaAddress: `0x${string}`, ueaBalance?: bigint, ueaNonce?: bigint): MultiCall[];
-export declare function createCascadedBuilder(ctx: OrchestratorContext, preparedTxs: PreparedUniversalTx[], callbacks: CascadeCallbacks): CascadedTransactionBuilder;
+export declare function createCascadedBuilder(ctx: OrchestratorContext, preparedTxs: PreparedUniversalTx[], callbacks: CascadeCallbacks): {
+    send: () => Promise<CascadedTxResponse>;
+};

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

@@ -62,8 +62,6 @@ function prepareTransaction(ctx, params, callbacks) {
             nonce,
             deadline,
             _hop: hop,
-            thenOn: (nextTx) => createCascadedBuilder(ctx, [prepared, nextTx], callbacks),
-            send: () => callbacks.executeFn(params),
         };
         return prepared;
     });
@@ -653,7 +651,6 @@ function composeCascade(ctx, segments, ueaAddress, ueaBalance, ueaNonce) {
 // ============================================================================
 function createCascadedBuilder(ctx, preparedTxs, callbacks) {
     return {
-        thenOn: (nextTx) => createCascadedBuilder(ctx, [...preparedTxs, nextTx], callbacks),
         send: () => tslib_1.__awaiter(this, void 0, void 0, function* () {
             const ueaAddress = (0, uea_manager_1.computeUEAOffchain)(ctx);
             // Extract HopDescriptors

package/src/lib/orchestrator/internals/route-handlers.js

@@ -939,7 +939,7 @@ function executeCeaToCea(ctx, params, executeFn) {
         // CEA -> CEA requires chaining Route 3 (CEA -> Push) and Route 2 (Push -> CEA)
         // This is a complex flow that requires coordination
         throw new Error('CEA -> CEA transactions are not yet fully implemented. ' +
-            'Use prepareTransaction().thenOn() to chain Route 3 -> Route 2 manually.');
+            'Use prepareTransaction() and executeTransactions() to chain Route 3 -> Route 2 manually.');
     });
 }
 // ---------------------------------------------------------------------------

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

@@ -4,7 +4,7 @@ import type { AccountStatus, UniversalTxResponse } from './orchestrator.types';
 import { ProgressEvent } from '../progress-hook/progress-hook.types';
 import { PushClient } from '../push-client/push-client';
 import type { UniversalAccount, UniversalSigner } from '../universal/universal.types';
-import { ExecuteParams, UniversalExecuteParams, PreparedUniversalTx, CascadedTransactionBuilder, RescueFundsParams } from './orchestrator.types';
+import { ExecuteParams, UniversalExecuteParams, PreparedUniversalTx, CascadedTxResponse, RescueFundsParams } from './orchestrator.types';
 export declare class Orchestrator {
     private readonly universalSigner;
     private pushNetwork;
@@ -79,9 +79,11 @@ export declare class Orchestrator {
      * The cascade composes all hops bottom-to-top into a single Push Chain tx.
      *
      * @param preparedTxs - Array of prepared transactions
-     * @returns CascadedTransactionBuilder
+     * @returns Object with send() method
      */
-    createCascadedBuilder(preparedTxs: PreparedUniversalTx[]): CascadedTransactionBuilder;
+    createCascadedBuilder(preparedTxs: PreparedUniversalTx[]): {
+        send: () => Promise<CascadedTxResponse>;
+    };
     /**
      * Queries gas fee for an outbound transaction from the UniversalCore contract.
      */

package/src/lib/orchestrator/orchestrator.js

@@ -211,7 +211,7 @@ class Orchestrator {
      * The cascade composes all hops bottom-to-top into a single Push Chain tx.
      *
      * @param preparedTxs - Array of prepared transactions
-     * @returns CascadedTransactionBuilder
+     * @returns Object with send() method
      */
     createCascadedBuilder(preparedTxs) {
         return (0, internals_1.createCascadedBuilder)(this.ctx, preparedTxs, this._getCascadeCallbacks());

package/src/lib/orchestrator/orchestrator.types.d.ts

@@ -465,10 +465,6 @@ export interface PreparedUniversalTx {
     deadline: bigint;
     /** Internal hop descriptor for cascade nesting @internal */
     _hop: HopDescriptor;
-    /** Chain additional transactions after this one (cascade) */
-    thenOn: (nextTx: PreparedUniversalTx) => CascadedTransactionBuilder;
-    /** Execute this prepared transaction */
-    send: () => Promise<UniversalTxResponse>;
 }
 /**
  * @deprecated Use CascadedTxResponse instead.
@@ -485,17 +481,6 @@ export interface MultiChainTxResponse {
         status: 'pending' | 'confirmed' | 'failed';
     }[];
 }
-/**
- * Builder for composing cascaded (nested) multi-chain transactions.
- * Each call to thenOn() adds another hop to the cascade.
- * send() composes all hops bottom-to-top and executes a single Push Chain tx.
- */
-export interface CascadedTransactionBuilder {
-    /** Add another hop to the cascade */
-    thenOn: (nextTx: PreparedUniversalTx) => CascadedTransactionBuilder;
-    /** Compose all hops bottom-to-top and execute the single initial tx */
-    send: () => Promise<CascadedTxResponse>;
-}
 /**
  * Response for cascaded multi-chain transactions.
  * Contains the initial tx and tracking info for all hops.

package/src/lib/progress-hook/progress-hook.js

@@ -35,7 +35,7 @@ const RAW_HOOKS = {
     [progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01]: () => ({
         id: progress_hook_types_1.PROGRESS_HOOK.SEND_TX_03_01,
         title: 'Resolving UEA',
-        message: 'Resolving Execution Account (UEA) – computing address, checking deployment status and balance',
+        message: 'Resolving Executor Account (UEA) – computing address, checking deployment status and balance',
         response: null,
         level: 'INFO',
     }),

package/src/lib/push-chain/push-chain.d.ts

@@ -6,7 +6,7 @@ import { TypedData, TypedDataDomain } from 'viem';
 import { ProgressEvent } from '../progress-hook/progress-hook.types';
 import type { AccountStatus } from '../orchestrator/orchestrator.types';
 import { MoveableToken, PayableToken, ConversionQuote, MoveableTokenAccessor, PayableTokenAccessor } from '../constants/tokens';
-import type { PreparedUniversalTx, CascadedTransactionBuilder } from '../orchestrator/orchestrator.types';
+import type { PreparedUniversalTx, CascadedTxResponse } from '../orchestrator/orchestrator.types';
 /**
  * @class PushChain
  *
@@ -71,15 +71,14 @@ export declare class PushChain {
         sendTransaction: Orchestrator['execute'];
         /**
          * Prepare a universal transaction without executing it.
-         * Returns a PreparedUniversalTx that can be chained with thenOn() or sent.
+         * Returns a PreparedUniversalTx that can be passed to executeTransactions.
          */
         prepareTransaction: Orchestrator['prepareTransaction'];
         /**
-         * Execute multiple transactions in sequence across chains.
-         * Accepts PreparedUniversalTx (from prepareTransaction) and returns
-         * a CascadedTransactionBuilder that supports .thenOn() for chaining.
+         * Execute one or more prepared transactions as a cascade across chains.
+         * Accepts an array of PreparedUniversalTx (from prepareTransaction).
          */
-        executeTransactions: (firstTx: PreparedUniversalTx) => CascadedTransactionBuilder;
+        executeTransactions: (txs: PreparedUniversalTx[]) => Promise<CascadedTxResponse>;
         /**
          * Tracks a transaction by hash on Push Chain
          */

package/src/lib/push-chain/push-chain.js

@@ -87,12 +87,12 @@ class PushChain {
                 }
                 return orchestrator.prepareTransaction.bind(orchestrator)(params);
             },
-            executeTransactions: (firstTx) => {
+            executeTransactions: (txs) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 if (this.isReadMode) {
                     throw new Error('Read only mode cannot call executeTransactions function');
                 }
-                return orchestrator.createCascadedBuilder([firstTx]);
-            },
+                return orchestrator.createCascadedBuilder(txs).send();
+            }),
             trackTransaction: (txHash, options) => {
                 return orchestrator.trackTransaction.bind(orchestrator)(txHash, options);
             },

package/src/lib/universal/account/account.js

@@ -491,11 +491,11 @@ function deriveExecutorAccount(account, options) {
             // If target chain is external, derive CEA from the computed UEA
             if (targetChain && !isPushChain(targetChain)) {
                 const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
-                return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
+                return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
             }
             // Return UEA with deployment check
             if (skipNetworkCheck) {
-                return { address: ueaAddress, deployed: false };
+                return { address: ueaAddress, deployed: null };
             }
             const pushChainKey = pushNetworkToChainKey(pushNetwork);
             const pushClient = new push_client_1.PushClient({
@@ -513,11 +513,11 @@ function deriveExecutorAccount(account, options) {
         // If target chain is external, derive CEA
         if (targetChain && !isPushChain(targetChain)) {
             const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
-            return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
+            return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
         }
         // Push address, no external target — return with deployment check
         if (skipNetworkCheck) {
-            return { address: address, deployed: false };
+            return { address: address, deployed: null };
         }
         const pushNetwork = targetChain && isPushChain(targetChain)
             ? getPushNetworkFromChain(targetChain)

package/src/lib/universal/signer/signer.js

@@ -23,7 +23,7 @@ const bs58_1 = require("../../internal/bs58");
  * viem uses `gas` while ethers expects `gasLimit`.
  */
 function toEthersTxRequest(viemTx) {
-    const _a = viemTx, { gas } = _a, rest = tslib_1.__rest(_a, ["gas"]);
+    const _a = viemTx, { gas, type } = _a, rest = tslib_1.__rest(_a, ["gas", "type"]);
     return Object.assign(Object.assign({}, rest), { gasLimit: gas });
 }
 /**

package/src/lib/universal/universal.types.d.ts

@@ -137,8 +137,8 @@ export type AccountRole = 'controller';
 export interface DerivedExecutorAccount {
     /** The computed executor address on Push Chain (or CEA on external chain) */
     address: `0x${string}`;
-    /** Whether the executor account is deployed on-chain */
-    deployed: boolean;
+    /** Whether the executor account is deployed on-chain. null when skipNetworkCheck is true. */
+    deployed: boolean | null;
 }
 /**
  * A single resolved account entry in the resolveControllerAccount response.