@pushchain/core 6.0.26 → 6.0.27-alpha.0

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

@@ -13,6 +13,12 @@ const evm_client_1 = require("../vm-client/evm-client");
 const tokens_1 = require("../constants/tokens");
 const read_params_1 = require("../read-state/read-params");
 const read_executor_1 = require("../read-state/read-executor");
+const agentic_1 = require("../agentic/agentic");
+const context_1 = require("../agentic/context");
+const send_1 = require("../agentic/execution/send");
+const guards_1 = require("../agentic/execution/guards");
+const response_1 = require("../agentic/response");
+const runtime_1 = require("../agentic/runtime");
 /**
  * @class PushChain
  *
@@ -52,6 +58,14 @@ class PushChain {
     moveable;
     payable;
     funds;
+    /**
+     * Agentic wallet management (AGW): derive, create, list and per-wallet
+     * handles. Ownership is the connected signer's Push identity.
+     */
+    agentic;
+    /** @internal AGW execution context when initialized with `agenticWallet`. */
+    agenticContext;
+    agenticRuntime;
     /**
      * Account status including UEA deployment state and version info.
      * Initially unloaded — call getAccountStatus() to populate.
@@ -81,62 +95,96 @@ class PushChain {
         };
         // Default — overwritten in createInstance() with the background fetch
         this.accountStatusReady = Promise.resolve();
+        this.agenticRuntime = (0, runtime_1.createAgenticRuntime)(orchestrator, isReadMode);
+        this.agentic = new agentic_1.AgenticNamespaceImpl(this.agenticRuntime);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- getters below need the instance
+        const self = this;
+        // In agenticWallet mode, request transactions execute through the wallet
+        // and the wallet pays the request value, so its balance gates the read.
+        const readDeps = () => {
+            const actx = self.agenticContext;
+            if (!actx)
+                return orchestrator;
+            return {
+                execute: (params, options) => (0, send_1.agenticSend)(self.agenticRuntime, actx, params, options),
+                trackRead: orchestrator.trackRead.bind(orchestrator),
+                revalidateRead: orchestrator.revalidateRead.bind(orchestrator),
+                getProgressHook: orchestrator.getProgressHook.bind(orchestrator),
+                getReadBalance: () => self.agenticRuntime.reader.getBalance({ address: actx.wallet }),
+            };
+        };
+        // Unspent read budget returns to whoever paid it: the wallet in agentic mode.
+        const withReadRefund = (options) => self.agenticContext && options.refundTo === undefined
+            ? { ...options, refundTo: self.agenticContext.wallet }
+            : options;
         this.universal = {
             get origin() {
                 return orchestrator.getUOA();
             },
             get account() {
-                return orchestrator.computeUEAOffchain();
+                return self.agenticContext?.wallet ?? orchestrator.computeUEAOffchain();
             },
             sendTransaction: (...args) => {
                 if (this.isReadMode) {
                     throw new Error('Read only mode cannot call sendTransaction function');
                 }
+                if (this.agenticContext) {
+                    return (0, send_1.agenticSend)(this.agenticRuntime, this.agenticContext, ...args);
+                }
                 return orchestrator.execute.bind(orchestrator)(...args);
             },
             prepareTransaction: (params, options) => {
+                if (this.agenticContext)
+                    throw (0, guards_1.notAllowedInAgenticMode)('prepareTransaction');
                 return orchestrator.prepareTransaction.bind(orchestrator)(params, options);
             },
             executeTransactions: async (txs, options) => {
                 if (this.isReadMode) {
                     throw new Error('Read only mode cannot call executeTransactions function');
                 }
+                if (this.agenticContext)
+                    throw (0, guards_1.notAllowedInAgenticMode)('executeTransactions');
                 return orchestrator.createCascadedBuilder(txs, options).send();
             },
-            trackTransaction: (txHash, options) => {
-                return orchestrator.trackTransaction.bind(orchestrator)(txHash, options);
+            trackTransaction: async (txHash, options) => {
+                const tracked = await orchestrator.trackTransaction.bind(orchestrator)(txHash, options);
+                return (0, response_1.adaptTrackedResponse)(this.agenticRuntime, tracked);
             },
             migrateCEA: (chain) => {
                 if (this.isReadMode) {
                     throw new Error('Read only mode cannot call migrateCEA function');
                 }
+                if (this.agenticContext)
+                    throw (0, guards_1.notAllowedInAgenticMode)('migrateCEA');
                 return orchestrator.migrateCEA.bind(orchestrator)(chain);
             },
             rescueFunds: (params) => {
                 if (this.isReadMode) {
                     throw new Error('Read only mode cannot call rescueFunds function');
                 }
+                if (this.agenticContext)
+                    throw (0, guards_1.notAllowedInAgenticMode)('rescueFunds');
                 return orchestrator.rescueFunds.bind(orchestrator)(params);
             },
             // Only read()/executeReads() send transactions; prepare/simulate/track remain read-only.
             read: async (subject, options) => {
-                const params = await (0, read_params_1.resolveReadSpecParams)(subject, options, orchestrator.getNetwork(), orchestrator.getRpcUrls());
+                const params = await (0, read_params_1.resolveReadSpecParams)(subject, withReadRefund(options), orchestrator.getNetwork(), orchestrator.getRpcUrls());
                 (0, read_executor_1.assertRequestEntrypoint)(params.callback, 'read');
                 if (this.isReadMode)
                     throw new Error('Read only mode cannot call read function');
                 const prepared = await orchestrator.prepareRead(params, options.progressHook);
-                const { reads: [response] } = await (0, read_executor_1.executeReads)(orchestrator, [prepared], options);
+                const { reads: [response] } = await (0, read_executor_1.executeReads)(readDeps(), [prepared], options);
                 return response;
             },
             prepareRead: async (subject, options) => {
-                const params = await (0, read_params_1.resolveReadSpecParams)(subject, options, orchestrator.getNetwork(), orchestrator.getRpcUrls());
+                const params = await (0, read_params_1.resolveReadSpecParams)(subject, withReadRefund(options), orchestrator.getNetwork(), orchestrator.getRpcUrls());
                 return orchestrator.prepareRead(params);
             },
             executeReads: (async (reads, options) => {
                 reads.forEach((r) => (0, read_executor_1.assertRequestEntrypoint)(r.callback));
                 if (this.isReadMode)
                     throw new Error('Read only mode cannot call executeReads function');
-                return (0, read_executor_1.executeReads)(orchestrator, reads, options);
+                return (0, read_executor_1.executeReads)(readDeps(), reads, options);
             }),
             trackRead: ((ref, options) => {
                 const opts = { ...(0, read_params_1.toLifecycleOptions)(options), progressHook: options?.progressHook };
@@ -451,6 +499,12 @@ class PushChain {
         });
         // Let execute() await the background fetch instead of re-fetching
         orchestrator.accountStatusReadyPromise = instance.accountStatusReady;
+        // Agentic mode: validate the wallet, its generation and the signer's door
+        // before returning a client. A read-only client may hold the context (so
+        // universal.account shows the wallet) but every signing path stays closed.
+        if (options?.agenticWallet !== undefined) {
+            instance.agenticContext = await (0, context_1.resolveAgenticContext)(instance.agenticRuntime, options.agenticWallet);
+        }
         return instance;
     }
     /**
@@ -481,12 +535,17 @@ class PushChain {
      * @returns A new initialized instance of PushChain.
      */
     reinitialize = async (universalSigner, options) => {
+        // agenticWallet is NOT inherited: an omitted value yields an ordinary
+        // client, and a supplied one reruns every wallet/role check.
         const mergedOptions = {
             network: options?.network ?? this.orchestrator.getNetwork(),
             rpcUrls: options?.rpcUrls ?? this.orchestrator.getRpcUrls(),
             blockExplorers: options?.blockExplorers ?? this.blockExplorers,
             printTraces: options?.printTraces ?? this.orchestrator.getPrintTraces(),
             progressHook: options?.progressHook ?? this.orchestrator.getProgressHook(),
+            ...(options?.agenticWallet !== undefined
+                ? { agenticWallet: options.agenticWallet }
+                : {}),
         };
         return PushChain.createInstance(universalSigner, mergedOptions);
     };

package/src/lib/read-state/destination.js

@@ -17,7 +17,12 @@ const KNOWN = new Set(Object.values(read_state_1.READ_NAMESPACE));
 function resolveDestination(dest) {
     let chainNamespace;
     let chainId;
-    if ('chain' in dest) {
+    if ('chain' in dest && dest.chain === read_state_1.WEB2_READ_CHAIN) {
+        // The public 'web2' spelling has no ':'; its wire identity is web2:https.
+        chainNamespace = read_state_1.WEB2_DESTINATION.chainNamespace;
+        chainId = read_state_1.WEB2_DESTINATION.chainId;
+    }
+    else if ('chain' in dest) {
         const idx = dest.chain.indexOf(':');
         if (idx <= 0) {
             throw new errors_1.UnsupportedReadDestinationError(`chain is not CAIP-2: ${dest.chain}`);

package/src/lib/read-state/read-params.d.ts

@@ -15,7 +15,7 @@ import type { Abi, AbiStateMutability, Address, Hex, ContractFunctionReturnType,
 import type { Idl, IdlAccounts } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { CHAIN, PUSH_NETWORK } from '../constants/enums';
-import type { BuildReadSpecParams, ReadChain, ReadDestination, ReadLifecycleOptions, ReadQuery, ReadResultShape, Web2Extract } from './read-state.types';
+import type { BuildReadSpecParams, ReadChain, ReadDestination, ReadLifecycleOptions, ReadQuery, ReadResultShape, Web2Extract, Web2ReadChain } from './read-state.types';
 import type { ReadCallback } from './read-state.types';
 import type { ProgressEvent } from '../progress-hook/progress-hook.types';
 export interface ReadWeb2Options {
@@ -116,7 +116,7 @@ export type ReadQueryOptions = ({
 } & Query<'storageSlot', {
     storageSlot: Hex | bigint;
 }>) | ({
-    chain: typeof CHAIN.WEB2;
+    chain: Web2ReadChain;
 } & Query<'web2', {
     web2: ReadWeb2Options;
 }>);
@@ -146,7 +146,7 @@ type FinalizedDestinationOptions = {
 export type ReadPrepareOptions = SharedPrepareOptions & ((Extract<ReadQueryOptions, {
     chain: EvmChain;
 }> & EvmPinningOptions) | (Extract<ReadQueryOptions, {
-    chain: SvmChain | typeof CHAIN.WEB2;
+    chain: SvmChain | Web2ReadChain;
 }> & FinalizedDestinationOptions));
 export type ReadExecuteOptions = Pick<ReadOptionsInput, 'advanced' | 'waitForCompletion' | 'progressHook'>;
 type WithExecutionOptions<T> = T extends unknown ? Omit<T, 'advanced' | 'waitForCompletion' | 'progressHook'> & ReadExecuteOptions : never;

package/src/lib/read-state/read-params.js

@@ -43,7 +43,8 @@ function queryKind(o) {
     return present[0] ?? 'native';
 }
 function toReadDestination(chain) {
-    return chain === enums_1.CHAIN.WEB2 ? read_state_1.WEB2_DESTINATION : { chain };
+    // Both public spellings normalize to the unchanged wire identity web2:https.
+    return (0, read_state_1.isWeb2ReadChain)(chain) ? read_state_1.WEB2_DESTINATION : { chain };
 }
 /** Build the internal query from the public grammar. Pure. */
 function toReadQuery(subject, o, resolvedTokenProgram) {
@@ -57,7 +58,7 @@ function toReadQuery(subject, o, resolvedTokenProgram) {
         return { type: 'http', url: subject, ...o.web2 };
     }
     if (kind === 'web2')
-        throw new errors_1.InvalidReadQueryError('`web2` is only valid with chain CHAIN.WEB2');
+        throw new errors_1.InvalidReadQueryError('`web2` is only valid with chain READ.CHAIN.WEB2');
     if (dest.namespace === read_state_1.READ_NAMESPACE.EVM) {
         if (!(0, viem_1.isAddress)(subject))
             throw new errors_1.InvalidReadQueryError(`EVM subject must be an address, got ${subject}`);

package/src/lib/read-state/read-state.types.d.ts

@@ -6,7 +6,9 @@ import type { ReadNamespace } from '../constants/read-state';
  * Where a read goes. `CHAIN` enum values are CAIP-2 and split cleanly; the
  * explicit form is the low-level escape hatch; the public API uses `CHAIN.WEB2`.
  */
-export type ReadChain = CHAIN | typeof CHAIN.WEB2;
+/** Web2 read source: `READ.CHAIN.WEB2` (`'web2'`) or the legacy `'web2:https'` literal. */
+export type Web2ReadChain = 'web2' | 'web2:https';
+export type ReadChain = CHAIN | Web2ReadChain;
 export type ReadDestination = {
     chain: ReadChain;
 } | {

package/src/lib/read-state/read-tracker.js

@@ -309,8 +309,8 @@ function inferResultShape(namespace, query) {
     }
 }
 function chainFromCaip2(caip2) {
-    if (caip2 === enums_1.CHAIN.WEB2)
-        return enums_1.CHAIN.WEB2;
+    if ((0, read_state_1.isWeb2ReadChain)(caip2))
+        return read_state_1.WEB2_READ_CHAIN;
     return Object.values(enums_1.CHAIN).includes(caip2) ? caip2 : undefined;
 }
 function explorerTxUrl(network, txHash) {

package/src/lib/read-state/spec-builder.js

@@ -106,7 +106,7 @@ function buildReadSpecFromPreflight(preflight, params, defaults = {}) {
     return {
         callback: params.callback,
         queryKey: (0, registry_1.computeReadQueryKey)(params.destination, params.query),
-        chain: dest.caip2,
+        chain: (isWeb2 ? read_state_1.WEB2_READ_CHAIN : dest.caip2),
         spec,
         specTuple: toTuple(spec),
         encodedSpec: encodeSpec(spec),

package/src/lib/universal/prc20-address.d.ts

@@ -0,0 +1,15 @@
+import { CHAIN, PUSH_NETWORK } from '../constants/enums';
+import { type MoveableToken } from '../constants/tokens';
+/** Shared pure origin-to-PRC20 mapping; no signer or network reads. */
+export declare function getPRC20Address(token: MoveableToken | {
+    chain: string;
+    address: string;
+}, options?: {
+    network?: PUSH_NETWORK;
+}): {
+    address: `0x${string}`;
+    chain: CHAIN;
+    symbol: string;
+    decimals: number;
+    network: PUSH_NETWORK;
+};

package/src/lib/universal/prc20-address.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPRC20Address = getPRC20Address;
+const enums_1 = require("../constants/enums");
+const tokens_1 = require("../constants/tokens");
+const chain_1 = require("../constants/chain");
+/** Shared pure origin-to-PRC20 mapping; no signer or network reads. */
+function 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,
+    };
+}
+//# sourceMappingURL=prc20-address.js.map

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.
      */