@pushchain/core 5.1.4-alpha.1 → 5.1.4-alpha.11

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

@@ -106,6 +106,14 @@ export type ExecuteParams = {
      * @internal
      */
     _skipFeeLocking?: boolean;
+    /**
+     * Internal: Minimum fee-locking deposit in USD (8 decimals).
+     * Overrides the default $1 floor when the caller needs a larger deposit
+     * (e.g., Route 2 needs enough UPC for the outbound swap).
+     * Still capped at $10 by lockFee.
+     * @internal
+     */
+    _minimumDepositUsd?: bigint;
 };
 /**
  * New Universal Transaction Receipt interface with prioritized field ordering
@@ -465,10 +473,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 +489,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);
             },
@@ -400,6 +400,7 @@ class PushChain {
             // Stored on instance so consumers can await it if needed: await client.accountStatusReady
             const ACCOUNT_STATUS_TIMEOUT = 30000;
             instance.accountStatusReady = Promise.race([
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
                 instance.getAccountStatus().then(() => { }),
                 new Promise((_, reject) => setTimeout(() => reject(new Error('Account status fetch timed out')), ACCOUNT_STATUS_TIMEOUT)),
             ]).catch(() => {

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

@@ -69,29 +69,37 @@ export declare function convertExecutorToOrigin(executorAddress: string, options
     _internal?: boolean;
 }): Promise<OriginAccountInfo>;
 /**
- * Derive the executor account (UEA or CEA) for a given origin account.
+ * Derive the executor account (UEA or CEA) for a given account.
  *
- * @param account - CAIP-10 formatted address string (e.g., "eip155:11155111:0xABC...")
- * @param options.chain - Target chain for CEA derivation. If omitted, derives UEA on Push Chain.
+ * - If account is on an external chain (Ethereum, Solana, etc.):
+ *   Computes the UEA on Push Chain via the factory contract's computeUEA.
+ *   If options.chain is an external chain, further derives the CEA on that chain.
+ *
+ * - If account is on Push Chain:
+ *   Returns the address as-is (it's already a UEA or Push EOA).
+ *   If options.chain is an external chain, derives the CEA on that chain.
+ *
+ * @param account - UniversalAccount with chain and address.
+ * @param options.chain - Target external chain for CEA derivation. If omitted, returns UEA.
  * @param options.skipNetworkCheck - If true, skip deployment check and return deployed: false.
  * @returns The derived executor account address and deployment status.
  */
-export declare function deriveExecutorAccount(account: string, options?: {
+export declare function deriveExecutorAccount(account: UniversalAccount, options?: {
     chain?: CHAIN;
     skipNetworkCheck?: boolean;
 }): Promise<DerivedExecutorAccount>;
 /**
  * Resolve the controller (origin) accounts for a given executor address.
  *
- * Given a UEA or CEA address (as CAIP-10), resolves the full controller chain
+ * Given a UEA or CEA plain address, resolves the full controller chain
  * back to the origin account.
  *
- * @param account - CAIP-10 formatted address string of the executor account
- * @param options.chain - Supplementary chain context (chain info is in CAIP-10)
+ * @param address - Plain address string of the executor account (e.g., "0xABC...")
+ * @param options.chain - Chain context. If external chain, address is treated as CEA on that chain. If omitted or Push chain, address is treated as UEA on Push Chain.
  * @param options.skipNetworkCheck - If true, skip existence checks, set exists: false
  * @returns Resolved accounts in the controller chain
  */
-export declare function resolveControllerAccount(account: string, options?: {
+export declare function resolveControllerAccount(address: string, options?: {
     chain?: CHAIN;
     skipNetworkCheck?: boolean;
 }): Promise<ResolvedControllerAccounts>;

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

@@ -10,6 +10,7 @@ exports.deriveExecutorAccount = deriveExecutorAccount;
 exports.resolveControllerAccount = resolveControllerAccount;
 const tslib_1 = require("tslib");
 const viem_1 = require("viem");
+const web3_js_1 = require("@solana/web3.js");
 const chain_1 = require("../../constants/chain");
 const enums_1 = require("../../constants/enums");
 const bs58_1 = require("../../internal/bs58");
@@ -431,120 +432,161 @@ function getChainName(chain) {
     return entry ? entry[0] : chain;
 }
 /**
- * Derive the executor account (UEA or CEA) for a given origin account.
+ * Derive the SVM CEA (PDA) for a UEA address on a Solana-based chain.
  *
- * @param account - CAIP-10 formatted address string (e.g., "eip155:11155111:0xABC...")
- * @param options.chain - Target chain for CEA derivation. If omitted, derives UEA on Push Chain.
+ * Solana doesn't use a CEAFactory contract — instead, the CEA is a
+ * Program Derived Address (PDA) with seeds: ["push_identity", ueaBytes]
+ * and the SVM gateway program as the program ID.
+ *
+ * @param ueaAddress - The UEA (or Push EOA) hex address (20 bytes).
+ * @param targetChain - The SVM target chain.
+ * @param skipNetworkCheck - Whether to skip deployment status check.
+ * @returns The derived 32-byte Solana PDA address (as 0x-prefixed hex) and deployment status.
+ */
+function deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck) {
+    const gatewayAddress = chain_1.CHAIN_INFO[targetChain].lockerContract;
+    if (!gatewayAddress) {
+        throw new Error(`SVM gateway program not configured for chain ${targetChain}`);
+    }
+    const gatewayProgramId = new web3_js_1.PublicKey(gatewayAddress);
+    const ueaBytes = Buffer.from(ueaAddress.slice(2), 'hex'); // 20 bytes
+    const [ceaPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('push_identity'), ueaBytes], gatewayProgramId);
+    const ceaPdaHex = ('0x' +
+        Buffer.from(ceaPda.toBytes()).toString('hex'));
+    return { address: ceaPdaHex, deployed: skipNetworkCheck ? null : null };
+}
+/**
+ * Derive the executor account (UEA or CEA) for a given account.
+ *
+ * - If account is on an external chain (Ethereum, Solana, etc.):
+ *   Computes the UEA on Push Chain via the factory contract's computeUEA.
+ *   If options.chain is an external chain, further derives the CEA on that chain.
+ *
+ * - If account is on Push Chain:
+ *   Returns the address as-is (it's already a UEA or Push EOA).
+ *   If options.chain is an external chain, derives the CEA on that chain.
+ *
+ * @param account - UniversalAccount with chain and address.
+ * @param options.chain - Target external chain for CEA derivation. If omitted, returns UEA.
  * @param options.skipNetworkCheck - If true, skip deployment check and return deployed: false.
  * @returns The derived executor account address and deployment status.
  */
 function deriveExecutorAccount(account, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a;
-        const { chain: originChain, address } = fromChainAgnostic(account);
         const skipNetworkCheck = (_a = options === null || options === void 0 ? void 0 : options.skipNetworkCheck) !== null && _a !== void 0 ? _a : false;
         const targetChain = options === null || options === void 0 ? void 0 : options.chain;
-        // If target chain is external, derive CEA on that chain
-        if (targetChain && !isPushChain(targetChain)) {
-            // First get the UEA on Push Chain
+        const { chain, address } = account;
+        // --- Case 1: Input is on an external chain ---
+        if (!isPushChain(chain)) {
+            const { vm, chainId } = chain_1.CHAIN_INFO[chain];
+            const pushNetwork = getPushNetworkFromChain(chain);
+            // Check cache for previously computed UEA
+            const cachedUea = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm));
             let ueaAddress;
-            if (isPushChain(originChain)) {
-                ueaAddress = address;
+            if (cachedUea) {
+                ueaAddress = cachedUea;
             }
             else {
-                const ueaResult = yield deriveExecutorAccount(account);
-                ueaAddress = ueaResult.address;
+                // Compute UEA via factory contract
+                const pushChainKey = pushNetworkToChainKey(pushNetwork);
+                const pushClient = new push_client_1.PushClient({
+                    rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
+                    network: pushNetwork,
+                });
+                ueaAddress = yield pushClient.readContract({
+                    address: pushClient.pushChainInfo.factoryAddress,
+                    abi: factoryV1_1.FACTORY_V1,
+                    functionName: 'computeUEA',
+                    args: [
+                        {
+                            chainNamespace: chain_1.VM_NAMESPACE[vm],
+                            chainId: chainId,
+                            owner: vm === enums_1.VM.EVM
+                                ? address
+                                : vm === enums_1.VM.SVM
+                                    ? (0, viem_1.bytesToHex)(Uint8Array.from(bs58_1.bs58.decode(address)))
+                                    : address,
+                        },
+                    ],
+                });
+                // Cache the computed address
+                accountCache.set(cache_1.CacheKeys.ueaAddressOnchain(chain, address, pushNetwork, vm), ueaAddress);
             }
-            // Get CEA on the target external chain
-            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
-            return { address: cea, deployed: skipNetworkCheck ? false : isDeployed };
-        }
-        // If origin is Push chain, return the address directly
-        if (isPushChain(originChain)) {
+            // If target chain is external, derive CEA from the computed UEA
+            if (targetChain && !isPushChain(targetChain)) {
+                // SVM chains use PDA derivation, not CEAFactory
+                if (chain_1.CHAIN_INFO[targetChain].vm === enums_1.VM.SVM) {
+                    return deriveSvmCeaPda(ueaAddress, targetChain, skipNetworkCheck);
+                }
+                const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(ueaAddress, targetChain);
+                return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
+            }
+            // Return UEA with deployment check
             if (skipNetworkCheck) {
-                return { address: address, deployed: false };
+                return { address: ueaAddress, deployed: null };
             }
-            const pushNetwork = getPushNetworkFromChain(originChain);
             const pushChainKey = pushNetworkToChainKey(pushNetwork);
             const pushClient = new push_client_1.PushClient({
                 rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
                 network: pushNetwork,
             });
             const byteCode = yield pushClient.publicClient.getCode({
-                address: address,
+                address: ueaAddress,
             });
-            return { address: address, deployed: byteCode !== undefined };
+            const isDeployed = byteCode !== undefined;
+            accountCache.set(cache_1.CacheKeys.deploymentStatus(ueaAddress), isDeployed);
+            return { address: ueaAddress, deployed: isDeployed };
         }
-        // Origin is external chain → compute UEA on Push Chain
-        const { vm, chainId } = chain_1.CHAIN_INFO[originChain];
-        const pushNetwork = getPushNetworkFromChain(originChain);
-        // Check cache
-        const cachedAddress = accountCache.get(cache_1.CacheKeys.ueaAddressOnchain(originChain, address, pushNetwork, vm));
-        if (cachedAddress) {
-            if (skipNetworkCheck) {
-                return { address: cachedAddress, deployed: false };
-            }
-            const cachedDeploymentStatus = accountCache.get(cache_1.CacheKeys.deploymentStatus(cachedAddress));
-            if (cachedDeploymentStatus !== null) {
-                return {
-                    address: cachedAddress,
-                    deployed: cachedDeploymentStatus,
-                };
+        // --- Case 2: Input is on Push Chain ---
+        // If target chain is external, derive CEA
+        if (targetChain && !isPushChain(targetChain)) {
+            // SVM chains use PDA derivation, not CEAFactory
+            if (chain_1.CHAIN_INFO[targetChain].vm === enums_1.VM.SVM) {
+                return deriveSvmCeaPda(address, targetChain, skipNetworkCheck);
             }
+            const { cea, isDeployed } = yield (0, cea_utils_1.getCEAAddress)(address, targetChain);
+            return { address: cea, deployed: skipNetworkCheck ? null : isDeployed };
         }
+        // Push address, no external target — return with deployment check
+        if (skipNetworkCheck) {
+            return { address: address, deployed: null };
+        }
+        const pushNetwork = targetChain && isPushChain(targetChain)
+            ? getPushNetworkFromChain(targetChain)
+            : getPushNetworkFromChain(chain);
         const pushChainKey = pushNetworkToChainKey(pushNetwork);
         const pushClient = new push_client_1.PushClient({
             rpcUrls: chain_1.CHAIN_INFO[pushChainKey].defaultRPC,
             network: pushNetwork,
         });
-        const computedAddress = yield pushClient.readContract({
-            address: pushClient.pushChainInfo.factoryAddress,
-            abi: factoryV1_1.FACTORY_V1,
-            functionName: 'computeUEA',
-            args: [
-                {
-                    chainNamespace: chain_1.VM_NAMESPACE[vm],
-                    chainId: chainId,
-                    owner: vm === enums_1.VM.EVM
-                        ? address
-                        : vm === enums_1.VM.SVM
-                            ? (0, viem_1.bytesToHex)(Uint8Array.from(bs58_1.bs58.decode(address)))
-                            : address,
-                },
-            ],
-        });
-        // Cache the computed address
-        accountCache.set(cache_1.CacheKeys.ueaAddressOnchain(originChain, address, pushNetwork, vm), computedAddress);
-        if (skipNetworkCheck) {
-            return { address: computedAddress, deployed: false };
-        }
         const byteCode = yield pushClient.publicClient.getCode({
-            address: computedAddress,
+            address: address,
         });
-        const isDeployed = byteCode !== undefined;
-        // Cache the deployment status
-        accountCache.set(cache_1.CacheKeys.deploymentStatus(computedAddress), isDeployed);
-        return { address: computedAddress, deployed: isDeployed };
+        return {
+            address: address,
+            deployed: byteCode !== undefined,
+        };
     });
 }
 /**
  * Resolve the controller (origin) accounts for a given executor address.
  *
- * Given a UEA or CEA address (as CAIP-10), resolves the full controller chain
+ * Given a UEA or CEA plain address, resolves the full controller chain
  * back to the origin account.
  *
- * @param account - CAIP-10 formatted address string of the executor account
- * @param options.chain - Supplementary chain context (chain info is in CAIP-10)
+ * @param address - Plain address string of the executor account (e.g., "0xABC...")
+ * @param options.chain - Chain context. If external chain, address is treated as CEA on that chain. If omitted or Push chain, address is treated as UEA on Push Chain.
  * @param options.skipNetworkCheck - If true, skip existence checks, set exists: false
  * @returns Resolved accounts in the controller chain
  */
-function resolveControllerAccount(account, options) {
+function resolveControllerAccount(address, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         var _a;
-        const { chain: inputChain, address } = fromChainAgnostic(account);
+        const inputChain = options === null || options === void 0 ? void 0 : options.chain;
         const skipNetworkCheck = (_a = options === null || options === void 0 ? void 0 : options.skipNetworkCheck) !== null && _a !== void 0 ? _a : false;
-        // Case A: Input is on an external chain (CEA)
-        if (!isPushChain(inputChain)) {
+        // Case A: External chain → address is a CEA on that chain
+        if (inputChain && !isPushChain(inputChain)) {
             // Look up UEA on Push Chain from CEA
             const pushAccountAddress = yield (0, cea_utils_1.getPushAccountForCEA)(address, inputChain);
             if (pushAccountAddress === '0x0000000000000000000000000000000000000000') {
@@ -597,9 +639,12 @@ function resolveControllerAccount(account, options) {
             }
             return { accounts };
         }
-        // Case B: Input is on Push Chain (UEA or EOA)
-        const pushNetwork = getPushNetworkFromChain(inputChain);
+        // Case B: No chain or Push chain → address is a UEA or EOA on Push Chain
+        const pushNetwork = inputChain && isPushChain(inputChain)
+            ? getPushNetworkFromChain(inputChain)
+            : enums_1.PUSH_NETWORK.TESTNET_DONUT;
         const pushChainKey = pushNetworkToChainKey(pushNetwork);
+        const pushChainId = pushChainKey;
         const RPC_URL = chain_1.PUSH_CHAIN_INFO[pushChainKey].defaultRPC[0];
         const FACTORY_ADDRESS = chain_1.PUSH_CHAIN_INFO[pushChainKey].factoryAddress;
         const client = (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(RPC_URL) });
@@ -639,8 +684,8 @@ function resolveControllerAccount(account, options) {
         return {
             accounts: [
                 {
-                    chain: inputChain,
-                    chainName: getChainName(inputChain),
+                    chain: pushChainId,
+                    chainName: getChainName(pushChainId),
                     address: address,
                     type: 'uoa',
                     exists: skipNetworkCheck ? false : true,

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.