@pushchain/core 6.0.26 → 6.0.27-alpha.1

package/src/lib/utils.d.ts

@@ -1,7 +1,7 @@
 import { convertOriginToExecutor, fromChainAgnostic, convertExecutorToOriginAccount, toChainAgnostic, toUniversal, deriveExecutorAccount, resolveControllerAccount } from './universal/account';
 import { construct, toUniversal as toUniversalSigner, toUniversalFromKeypair } from './universal/signer';
 import { CHAIN, PUSH_NETWORK } from './constants/enums';
-import { type MoveableToken } from './constants/tokens';
+import { getPRC20Address } from './universal/prc20-address';
 import type { PushChain } from './push-chain/push-chain';
 import type { PC20AddressResult } from './orchestrator/orchestrator.types';
 import type { Idl } from '@coral-xyz/anchor';
@@ -274,18 +274,7 @@ export declare class Utils {
          *   });
          * ```
          */
-        getPRC20Address(token: MoveableToken | {
-            chain: string;
-            address: string;
-        }, options?: {
-            network?: PUSH_NETWORK;
-        }): {
-            address: `0x${string}`;
-            chain: CHAIN;
-            symbol: string;
-            decimals: number;
-            network: PUSH_NETWORK;
-        };
+        getPRC20Address: typeof getPRC20Address;
         /**
          * Resolve a PC20 token against UniversalCore's on-chain registry, and list
          * every confirmed address it has across chains.
@@ -330,6 +319,10 @@ export declare class Utils {
             strict?: boolean;
         }): Promise<PC20AddressResult>;
     };
+    /** Pure preset discovery/templates; internal encoders and identifiers stay private. */
+    static readonly agentic: Readonly<{
+        presets: import("./agentic").AgenticPresets;
+    }>;
     /**
      * Internal: resolves a CHAIN enum from either a CHAIN value or a PushChain client instance.
      */

package/src/lib/utils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
+const presets_1 = require("./agentic/presets");
 const account_1 = require("./universal/account");
 const signer_1 = require("./universal/signer");
 const enums_1 = require("./constants/enums");
 const tokens_1 = require("./constants/tokens");
-const chain_1 = require("./constants/chain");
+const prc20_address_1 = require("./universal/prc20-address");
 const viem_1 = require("viem");
 const resolver_1 = require("./orchestrator/internals/pc20/resolver");
 const errors_1 = require("./orchestrator/internals/pc20/errors");
@@ -584,133 +585,7 @@ class Utils {
          *   });
          * ```
          */
-        getPRC20Address(token, options) {
-            const network = options?.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT;
-            const assertDeployed = (addr, ctx) => {
-                if (!addr || addr === '0xTBD') {
-                    throw new Error(`PRC20 address not available for ${ctx} on network ${network}`);
-                }
-                return addr;
-            };
-            // PushChainMoveableToken (pETH, pSOL, pUSDT(BNB), …) carries its PRC-20 address
-            // and origin `sourceChain` directly — no registry lookup needed.
-            const pcToken = token;
-            if (pcToken.prc20Address) {
-                return {
-                    address: assertDeployed(pcToken.prc20Address, `${pcToken.symbol ?? 'token'} (${pcToken.sourceChain ?? 'unknown'})`),
-                    chain: pcToken.sourceChain,
-                    symbol: pcToken.symbol,
-                    decimals: pcToken.decimals,
-                    network,
-                };
-            }
-            // Infer origin chain, symbol, decimals by matching against MOVEABLE_TOKENS
-            let originChain;
-            let tokenSymbol;
-            let tokenDecimals;
-            if ('symbol' in token) {
-                // MoveableToken path: infer chain by symbol + address
-                for (const [key, list] of Object.entries(tokens_1.MOVEABLE_TOKENS)) {
-                    const k = key;
-                    const match = (list ?? []).find((t) => t.symbol === token.symbol && t.address === token.address);
-                    if (match) {
-                        originChain = k;
-                        tokenSymbol = match.symbol;
-                        tokenDecimals = match.decimals;
-                        break;
-                    }
-                }
-            }
-            else {
-                // { chain, address } path: trust the provided chain and resolve symbol via registry
-                originChain = token.chain;
-                const list = tokens_1.MOVEABLE_TOKENS[originChain] ?? [];
-                const match = list.find((t) => t.address === token.address);
-                if (match) {
-                    tokenSymbol = match.symbol;
-                    tokenDecimals = match.decimals;
-                }
-            }
-            if (!originChain || !tokenSymbol || tokenDecimals === undefined) {
-                throw new Error('Unable to infer origin chain or token symbol for token');
-            }
-            const map = chain_1.SYNTHETIC_PUSH_ERC20[network];
-            if (!map) {
-                throw new Error(`No PRC20 address map configured for network: ${network}`);
-            }
-            // Map token → synthetic key by origin chain family
-            const isEthFamily = originChain === enums_1.CHAIN.ETHEREUM_MAINNET ||
-                originChain === enums_1.CHAIN.ETHEREUM_SEPOLIA;
-            const isArbFamily = originChain === enums_1.CHAIN.ARBITRUM_SEPOLIA;
-            const isBaseFamily = originChain === enums_1.CHAIN.BASE_SEPOLIA;
-            const isBnbFamily = originChain === enums_1.CHAIN.BNB_TESTNET;
-            const isSolFamily = originChain === enums_1.CHAIN.SOLANA_DEVNET;
-            let key;
-            switch (tokenSymbol) {
-                case 'ETH': {
-                    if (isEthFamily)
-                        key = 'pETH';
-                    else if (isArbFamily)
-                        key = 'pETH_ARB';
-                    else if (isBaseFamily)
-                        key = 'pETH_BASE';
-                    else
-                        throw new Error('Unsupported ETH origin chain for synthetic mapping');
-                    break;
-                }
-                case 'SOL': {
-                    if (!isSolFamily)
-                        throw new Error('SOL token provided but origin is not Solana');
-                    key = 'pSOL';
-                    break;
-                }
-                case 'BNB': {
-                    if (!isBnbFamily)
-                        throw new Error('BNB token provided but origin is not BNB Testnet');
-                    key = 'pBNB';
-                    break;
-                }
-                case 'USDT': {
-                    if (isEthFamily)
-                        key = 'USDT_ETH';
-                    else if (isArbFamily)
-                        key = 'USDT_ARB';
-                    else if (isBaseFamily)
-                        key = 'USDT_BASE';
-                    else if (isBnbFamily)
-                        key = 'USDT_BSC';
-                    else if (isSolFamily)
-                        key = 'USDT_SOL';
-                    else
-                        throw new Error('Unsupported USDT origin chain for synthetic mapping');
-                    break;
-                }
-                case 'USDC': {
-                    if (isEthFamily)
-                        key = 'USDC_ETH';
-                    else if (isArbFamily)
-                        key = 'USDC_ARB';
-                    else if (isBaseFamily)
-                        key = 'USDC_BASE';
-                    else if (isBnbFamily)
-                        key = 'USDC_BSC';
-                    else if (isSolFamily)
-                        key = 'USDC_SOL';
-                    else
-                        throw new Error('Unsupported USDC origin chain for synthetic mapping');
-                    break;
-                }
-                default:
-                    throw new Error(`Unsupported token symbol: ${tokenSymbol}`);
-            }
-            return {
-                address: assertDeployed(map[key], `${tokenSymbol} on ${originChain}`),
-                chain: originChain,
-                symbol: tokenSymbol,
-                decimals: tokenDecimals,
-                network,
-            };
-        },
+        getPRC20Address: prc20_address_1.getPRC20Address,
         /**
          * Resolve a PC20 token against UniversalCore's on-chain registry, and list
          * every confirmed address it has across chains.
@@ -788,6 +663,8 @@ class Utils {
             };
         },
     };
+    /** Pure preset discovery/templates; internal encoders and identifiers stay private. */
+    static agentic = Object.freeze({ presets: presets_1.agenticPresets });
     /**
      * Internal: resolves a CHAIN enum from either a CHAIN value or a PushChain client instance.
      */

package/src/lib/vm-client/evm-client.js

@@ -205,12 +205,19 @@ class EvmClient {
         const resolveGas = async () => {
             if (explicitGas)
                 return explicitGas;
-            const estimate = () => this.publicClient.estimateGas({
-                account: signer.account.address,
-                to,
-                data,
-                value,
-            });
+            const estimate = async () => {
+                const estimatedGas = await this.publicClient.estimateGas({
+                    account: signer.account.address,
+                    to,
+                    data,
+                    value,
+                });
+                // Leave headroom for nested calls and state changes before inclusion,
+                // as on the EIP-7702 batch path. Donut can return an estimate that
+                // reverts inside an AGW -> gateway -> token call even at the same state.
+                // This is the Push execution limit, separate from destination gas.
+                return (estimatedGas * BigInt(120) + BigInt(99)) / BigInt(100);
+            };
             if (data !== '0x')
                 return estimate();
             // A plain native transfer to a code-free EOA always costs 21k. Empty
@@ -323,30 +330,37 @@ class EvmClient {
         catch (err) {
             throw new EIP7702NotSupportedError(err);
         }
-        // Estimate gas against the delegated account: override the EOA's code with
-        // the 7702 delegation designator (0xef0100 || executor) so estimation runs
-        // the executor. Fall back to a safe ceiling if the node rejects overrides.
+        // Prefer authorization-aware estimation of the actual type-4 transaction.
+        // Some RPCs reject that format or state overrides. An ordinary estimate is
+        // valid only if the account is already delegated to this exact executor.
+        // Never guess a per-call ceiling: contract deployment/grants vary in cost.
+        const delegation = ('0xef0100' + executor.slice(2));
         let gas;
         try {
             gas = await this.publicClient.estimateGas({
                 account,
                 to: account,
                 data,
-                stateOverride: [
-                    {
-                        address: account,
-                        code: ('0xef0100' + executor.slice(2)),
-                    },
-                ],
+                authorizationList: [authorization],
             });
-            gas = (gas * BigInt(120)) / BigInt(100); // headroom for delegation + auth
         }
         catch {
-            // Estimation unavailable (e.g. node rejects state overrides). Scale the
-            // ceiling with the batch size so large batches don't OOG — the legacy
-            // per-call loop budgeted ~500k gas per call; mirror that plus overhead.
-            gas = BigInt(500_000) * BigInt(calls.length) + BigInt(100_000);
+            const code = await this.publicClient.getCode({ address: account });
+            if (code?.toLowerCase() === delegation.toLowerCase()) {
+                gas = await this.publicClient.estimateGas({ account, to: account, data });
+            }
+            else {
+                gas = await this.publicClient.estimateGas({
+                    account,
+                    to: account,
+                    data,
+                    stateOverride: [{ address: account, code: delegation }],
+                });
+            }
         }
+        // The fallback estimates omit authorization processing (25k intrinsic).
+        // Include it conservatively on every path, plus 20% execution headroom.
+        gas = (gas * BigInt(120) + BigInt(99)) / BigInt(100) + BigInt(25_000);
         const unsignedTx = (0, viem_1.serializeTransaction)({
             chainId,
             type: 'eip7702',