@pushchain/core 6.0.27-alpha.2 → 6.0.27-alpha.3

package/AGW.md

@@ -91,7 +91,7 @@ An equality pin fixes an argument; a maximum pin bounds it. For EVM signatures,
 
 `PushChain.CONSTANTS.AGENTIC.WALLET` resolves to the AGW on Push, its CEA on an EVM destination, or its CEA/selected token ATA on Solana. Deployment addresses and encoding helpers are internal.
 
-Omitted `maxValue`, `assets[].maxTotal`, and `maxGasPerCall` default to **zero**. Asset totals meter tokens sent from Push; they do not meter trading or lending using capital already in the destination CEA. Specify positive caps for sends that need value, tokens or destination gas. Native value is limited per call; there is no public native lifetime-total cap.
+For directly authored rules, omitted `maxValue`, `assets[].maxTotal`, and `maxGasPerCall` default to **zero**. Presets supply explicit policy values as described below. Asset totals meter tokens sent from Push; they do not meter trading or lending using capital already in the destination CEA. Specify positive caps for sends that need value, tokens or destination gas. Native value is limited per call; there is no public native lifetime-total cap.
 
 ## EVM destinations
 
@@ -171,7 +171,7 @@ The wire encoder uses uint32 maximum for unlimited native calls and 255 for unsp
 
 - DEXES: Uniswap V3 on Ethereum, Base and Arbitrum (mainnet and their Sepolia testnets); PancakeSwap V3 on BNB mainnet and BSC testnet.
 - LENDING: Aave on Ethereum, Base, Arbitrum and BNB mainnets, plus Sepolia/Base Sepolia/Arbitrum Sepolia; Moonwell on Base mainnet/testnet and Venus on BNB mainnet/testnet.
-- STAKING: EigenLayer deposits on Ethereum mainnet and Sepolia; Lido stake and wrap/unwrap on Ethereum mainnet. Withdrawal requests with dynamic amounts, claims with position-derived amounts and EigenLayer withdrawals are excluded from these bounded presets. A selected native asset supplies the Lido `submit` value cap; omitted caps remain zero.
+- STAKING: EigenLayer deposits on Ethereum mainnet and Sepolia; Lido stake and wrap/unwrap on Ethereum mainnet. Withdrawal requests with dynamic amounts, claims with position-derived amounts and EigenLayer withdrawals are excluded from these bounded presets. A selected native asset supplies the Lido `submit` value cap; omitted caps in explicitly supplied assets remain zero.
 - PREDICTION: no entries yet. Hide categories with empty `chains` lists.
 
 ```ts
@@ -180,13 +180,24 @@ const availablePresets = presets.filter(preset => preset.chains.length > 0);
 const { rules: reviewTemplates } = PushChain.utils.agentic.presets.get(
   PushChain.CONSTANTS.AGENTIC.PRESETS.CATEGORY.DEXES,
 );
-// Choose tokens in the review UI, then call get again as below.
+// Every populated chain includes curated destination tokens in rule.assets.
+// The SDK supplies spending limits, a PC budget and a seven-day expiry.
+// Supply the agent to get complete Rule[] configuration.
+const configuredPreset = PushChain.utils.agentic.presets.get(
+  PushChain.CONSTANTS.AGENTIC.PRESETS.CATEGORY.LENDING,
+  { chainNamespace: 'eip155:11155111', agent: '0x0000000000000000000000000000000000001234', funding: 'destination' },
+);
+// Destination assets must already be funded; no Push token exports are granted.
+// Show configuredPreset.readiness.chains[0].selectedAssets in the review UI.
+// Pass configuredPreset.rules directly to create after checking readiness.
+// The helper below illustrates explicit overrides, rather than required UI input.
 
 function filledPreset(agent: Address, tokenIn: Address, tokenOut: Address) {
   return PushChain.utils.agentic.presets.get(
     PushChain.CONSTANTS.AGENTIC.PRESETS.CATEGORY.DEXES,
     {
       chainNamespace: 'eip155:11155111',
+      funding: 'destination',
       agent,
       validUntil: Math.floor(Date.now() / 1000) + 3600,
       maxGasPerCall: BigInt(10) ** BigInt(18),
@@ -199,9 +210,9 @@ function filledPreset(agent: Address, tokenIn: Address, tokenOut: Address) {
 }
 ```
 
-The example caps are illustrative raw units; choose caps for the actual token decimals and gas requirements. `get` groups calls into one rule per chain. The result is `{ rules, readiness }`. With agent and expiry supplied, `rules` is typed as `Rule[]`; otherwise it is `PresetRuleTemplate[]`. This type distinction alone does not establish readiness. Assets must name their chain unless a single chain filter is supplied. Omitted asset caps and `maxGasPerCall` default to zero.
+The example caps are illustrative raw units; choose caps for the actual token decimals and gas requirements. `get` groups calls into one rule per chain. The result is `{ rules, readiness }`. With an agent supplied, `rules` is typed as `Rule[]`; otherwise it is `PresetRuleTemplate[]` with a generated expiry and missing agent. This type distinction alone does not establish readiness. When `assets` is omitted, each chain includes its curated destination tokens with the explicit spending limits below. An explicit `assets` array replaces the defaults for every returned chain; `[]` selects no tokens. Assets in an explicit list must name their chain unless a single chain filter is supplied. For an explicit asset list, omitted caps still default to zero. An omitted gas budget uses the preset policy; an explicit zero remains zero.
 
-DEX discovery works without options, with an empty asset list, or with assets for only some chains. A chain with fewer than two tokens returns full-signature review calls with wallet-recipient pins and an explicit zero input-amount maximum. A single supplied token is also pinned as the input. These calls cannot spend swap input tokens, even if asset budgets are filled later. Call `get` again after selecting both tokens to replace the review calls with the complete token-pinned rules; merely assigning `rule.assets` is insufficient.
+DEX discovery without `assets` includes a curated wrapped-native/stablecoin pair per chain, with both swap directions, exact-input/output functions and the token-specific input caps below. It does not require the UI to select tokens separately for every network. DEX discovery also works with an explicit empty asset list or with assets for only some chains. A chain with fewer than two explicitly supplied tokens returns full-signature review calls with wallet-recipient pins and an explicit zero input-amount maximum. A single supplied token is also pinned as the input. These calls cannot spend swap input tokens, even if asset budgets are filled later. Call `get` again after selecting both tokens to replace the review calls with the complete token-pinned rules; merely assigning `rule.assets` is insufficient.
 
 With two ERC20 tokens, `get` expands ordered pairs into exact-input and exact-output calls with token, wallet-recipient and input-amount pins. Native markers and expansions exceeding the policy's 32-pin limit are rejected. Two tokens fit the shipped router template; three do not. Static tuple fields use paths such as `[0, 3]`.
 
@@ -209,11 +220,55 @@ Reviewed EVM spenders generate approvals pinned to that spender and bounded by t
 
 Templates describe permissions, not available liquidity or guaranteed execution. Verify destination token balances, supported reserves and source PRC20 routes before use: protocol testnet mock tokens may differ from MOVEABLE tokens. Presets do not sign, fetch app ABIs or modify wallets. Dynamic-path swaps, Solana protocol templates and unconfirmed deployments are excluded. Mainnet addresses were checked read-only; no mainnet transactions were executed. Other mainnet protocols in the proposal remain excluded until their deployment and permission constraints are verified. Local policy tests do not execute the destination protocols.
 
+### Curated token defaults
+
+These are small, protocol-specific subsets chosen to fit the 32-call/32-pin ceilings. The full reserve catalog is not automatically granted.
+
+| Network | DEX pair | Lending tokens |
+| --- | --- | --- |
+| Ethereum | WETH / USDC | WETH, USDC |
+| Base | WETH / USDC | USDC (Aave and Moonwell) |
+| Arbitrum | WETH / native USDC | WETH, native USDC |
+| BNB | WBNB / USDT | USDT (Aave and Venus) |
+| Sepolia | DEX WETH / Circle USDC | Aave faucet LINK |
+| Base Sepolia | WETH / Circle USDC | Aave faucet LINK, Moonwell mock USDbC and WETH |
+| Arbitrum Sepolia | WETH / Circle USDC | Aave USDC |
+| BSC testnet | WBNB / Venus USDT | Venus USDT, USDC |
+
+Staking defaults are ETH/stETH/wstETH on Ethereum and the reviewed EigenLayer strategy's WETH on Sepolia. Testnet tokens with similar names can have different addresses; the returned addresses are authoritative. These tokens may lack Push PRC20 routes and can instead be used with destination-held balances. Defaults do not guarantee active reserves, liquidity, a Push PRC20 route or execution. In particular, an unmodified preset can fail rule preparation if its default assets lack PRC20 mappings. For destination-only use, pass `funding: 'destination'`: the SDK generates the operation constraints, returns empty rule bridge assets and retains selected token limits in readiness metadata. This grants no token export budget from Push and requires already-funded destination balances. Token addresses are returned as before; metadata was verified when defining the policy. No runtime metadata/price fetch is added to get.
+
+### Funding and release-network checks
+
+`funding` defaults to `'push'`. Missing PRC20 registry entries produce `BRIDGE_ASSET_UNAVAILABLE`, and readiness is false while the returned rule retains all requested assets. No address or cap is silently replaced. `network` defaults to `TESTNET_DONUT` (`TESTNET` is accepted as an alias); use the connected client's Push network when supplying it. Networks without a verified AGW deployment report `AGW_NETWORK_UNAVAILABLE`.
+
+Use `funding: 'destination'` for the prefunded CEA workflow. Selected tokens still generate the same target/function/amount/recipient/spender restrictions, exposed alongside their caps in `readiness.chains[].selectedAssets`. Returned `rule.assets` is intentionally empty, which grants zero Push token-export authority. It is safe to pass these returned rules directly to create/update. The mode does not fund the destination, wrap ETH, mint testnet tokens or enable an unsupported network. Do not relabel it as bridge funding in the UI.
+
+Existing mappings distinguish token identity by chain and address, including address casing for EVM. WETH/stETH Sepolia mappings and string/address-word source metadata are supported; mainnet or other-chain WETH is never aliased to them. Protocol mock LINK, Moonwell/Venus mocks and Circle testnet USDC can differ from the supported source tokens; they remain unavailable for bridge funding until real matching routes exist.
+
+### Default permission policy
+
+Only preset-generated assets receive these positive values. Direct rules, unknown tokens and explicit asset lists do not acquire guessed limits.
+
+| Selected token | Per allowed call / Push outbound | Cumulative Push-outbound total |
+| --- | --- | --- |
+| USDC / USDT / mock USDbC | 10 tokens | 100 tokens |
+| ETH / WETH / stETH / wstETH | 0.001 token | 0.01 token |
+| WBNB | 0.01 token | 0.1 token |
+| LINK | 1 token | 10 tokens |
+
+Amounts use verified token decimals, keyed by chain and address, rather than symbol or live prices. For example, the USDT per-call limit is `10 * 10^18` on BNB mainnet and `10 * 10^6` on BSC testnet. These are fixed token quantities, not USD budgets.
+
+The default expiry is seven days from each get call, computed once for all returned rules. The default gas ceiling is **20 PC per outbound**, including the value checked by URP; it is not a flat fee or a reservation. Actual sends obtain a fresh quote and remain subject to the rule cap. This ceiling has testnet protocol-flow coverage; mainnet templates do not have funded execution acceptance. Quotes may exceed the cap, requiring an explicit higher budget.
+
+Explicit `validUntil` and `maxGasPerCall` override policy values; zero gas is preserved and reports incomplete readiness. An explicit `assets` array replaces all default tokens and limits, and omitted caps inside it remain zero. To change a preset cap while retaining its token set, take the returned assets, replace the caps and pass them back to get. Do not just edit the returned rule assets: the allowed-call pins and approvals also need regeneration.
+
+`maxPerCall` applies to each allowed destination call; multiple calls may each consume that amount. `maxTotal` meters assets sent from Push, not aggregate destination activity. No destination lifetime limit is implied by these defaults. The general rules API continues to treat omitted caps as zero.
+
 ### Configure, inspect and regenerate
 
-`readiness.ready` means the returned chains have locally complete inputs and at least one enabled asset operation. It does not check PRC20 availability, deployments, balances, live reserve flags or liquidity. `readiness.chains` gives per-chain `issues`, `disabledCalls`, `excludedCalls`, catalog `knownTokens` and `zeroBridgeLimits`. These are additive result fields; `rules` remains accepted by the existing create/update methods.
+`readiness.ready` requires complete configuration plus offline SDK deployment/destination/bridge-registry support for the selected funding mode. Per-chain `configurationReady` reports input completeness separately. These checks do not verify live balances, reserve flags, liquidity, current deployed bytecode or source identity; grant preparation still verifies wiring and token metadata on-chain before signing. `readiness.chains` gives per-chain `issues`, `disabledCalls`, `excludedCalls`, catalog `knownTokens`, `selectedAssets`, `bridgeAssets`, `funding` and `zeroBridgeLimits`. Display `selectedAssets` as the reviewed token/amount permissions in either mode; `rule.assets` describes Push bridge permissions only. `bridgeAssets` reports registry presence, not verified live deployment. Mainnet templates remain discoverable but have `DESTINATION_UNAVAILABLE` on Donut. These are additive result fields; `rules` remains accepted by the existing create/update methods.
 
-The UI should collect chain, agent, token selections, raw-unit limits, gas budget and expiry. Show zero-cap calls as disabled. Present excluded calls explicitly. There is no SDK-selected 0.1 PC gas budget or 30-day expiry. A zero bridge limit can be intentional when assets are already at the destination; it is reported separately from operation readiness.
+Tokens and permission defaults come directly from the SDK: omitted `assets` populates the curated subset and its caps in every returned `rule.assets`. Omitted gas and expiry use the policy below. The caller supplies the agent and can filter chains; no per-network token selection is required. Show the generated permissions for owner review and allow explicit overrides. Regenerate via get after an edit so operation pins/approvals match the new caps. Show explicitly zero-cap calls as disabled and present excluded calls clearly. A zero bridge limit can be intentional when assets are already at the destination; it is reported separately from operation readiness.
 
 ```ts
 async function createConfiguredDex(

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+@pushchain/core@6.0.27-alpha.3 (2026-10-18)
+
+- feat: ship bounded preset defaults with funding checks
+
+---
+
 @pushchain/core@6.0.27-alpha.2 (2026-10-16)
 
 - feat: add bounded preset operations and configuration readiness

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushchain/core",
-  "version": "6.0.27-alpha.2",
+  "version": "6.0.27-alpha.3",
   "homepage": "https://push.org",
   "keywords": [
     "pushchain",

package/src/lib/agentic/contracts/prc20-metadata.d.ts

@@ -22,5 +22,5 @@ export declare const PRC20_SOURCE_ABI: readonly [{
 export declare function readSvmSourceToken(snap: Snapshot, token: Address, chain: string, network?: PUSH_NETWORK): Promise<Hex>;
 export declare const CORE_ADDRESS: Address;
 export declare function readGasPrc20(snap: Snapshot, chain: string): Promise<Address>;
-/** Donut native precompile returns a zero word; ERC20 metadata is a dynamic string. */
+/** Solidity PRC20s return a string; Donut precompiles can return an address word. */
 export declare function readOriginToken(snap: Snapshot, token: Address, chain: string): Promise<Address>;

package/src/lib/agentic/contracts/prc20-metadata.js

@@ -64,19 +64,25 @@ exports.CORE_ADDRESS = '0x00000000000000000000000000000000000000C0';
 async function readGasPrc20(snap, chain) {
     return (0, viem_1.getAddress)(await snap.read(exports.CORE_ADDRESS, prc20_evm_1.UNIVERSAL_CORE_EVM, 'gasTokenPRC20ByChainNamespace', [chain]));
 }
-/** Donut native precompile returns a zero word; ERC20 metadata is a dynamic string. */
+/** Solidity PRC20s return a string; Donut precompiles can return an address word. */
 async function readOriginToken(snap, token, chain) {
     let source;
     try {
         source = await snap.read(token, exports.PRC20_SOURCE_ABI, 'SOURCE_TOKEN_ADDRESS');
     }
     catch (cause) {
-        if ((await readGasPrc20(snap, chain)) !== (0, viem_1.getAddress)(token))
+        let sourceWord;
+        try {
+            sourceWord = (0, viem_1.getAddress)(await snap.read(token, NATIVE_SOURCE_ABI, 'SOURCE_TOKEN_ADDRESS'));
+        }
+        catch {
             throw cause;
-        const native = await snap.read(token, NATIVE_SOURCE_ABI, 'SOURCE_TOKEN_ADDRESS');
-        if ((0, viem_1.getAddress)(native) === viem_1.zeroAddress)
+        }
+        if (sourceWord !== viem_1.zeroAddress)
+            return sourceWord;
+        if ((await readGasPrc20(snap, chain)) === (0, viem_1.getAddress)(token))
             return viem_1.zeroAddress;
-        throw cause;
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.RULE_READ_FAILED, `non-native PRC20 ${token} has an empty source token address`);
     }
     if ((0, viem_1.isAddress)(source, { strict: false }))
         return (0, viem_1.getAddress)(source);

package/src/lib/agentic/presets/catalog.d.ts

@@ -25,6 +25,8 @@ export interface PresetCallDefinition extends RuleCall {
 /** Internal catalog: reviewed addresses and explicit calls only; never fetched at runtime. */
 export interface PresetChainDefinition {
     chainNamespace: ForeignChainNamespace;
+    /** Used with the bundled permission policy only when assets is omitted. */
+    defaultTokens?: readonly Address[];
     allowedCalls: readonly PresetCallDefinition[];
     /** Static single-hop routers; incomplete pairs return zero-input-cap review calls. */
     swapRouters?: readonly {

package/src/lib/agentic/presets/catalog.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRESET_CATALOG = void 0;
 const viem_1 = require("viem");
 const aave_reserves_1 = require("./aave-reserves");
+const default_tokens_1 = require("./default-tokens");
 /** Mainnet and testnet templates from the October 15 Notion export and protocol sources.
  * Read-only deployment/code evidence and exclusions: plan/agw/research/preset-catalog-2026-10-15/.
  * Mainnet entries are templates only; no mainnet deployment or execution guarantee.
@@ -153,6 +154,7 @@ exports.PRESET_CATALOG = [
             ],
         ].map(([chain, router, app]) => ({
             chainNamespace: chain,
+            defaultTokens: default_tokens_1.DEX_DEFAULT_TOKENS[chain],
             allowedCalls: [],
             swapRouters: [{ address: address(router), app }],
             approvals: [{ spender: address(router), app }],
@@ -169,6 +171,7 @@ exports.PRESET_CATALOG = [
                 ['eip155:56', '0x6807dc923806fE8Fd134338EABCA509979a7e0cB'],
             ].map(([chainNamespace, pool]) => ({
                 chainNamespace,
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS[chainNamespace],
                 allowedCalls: [
                     ...aave(address(pool), chainNamespace),
                     ...mainnetMarkets(chainNamespace).allowedCalls,
@@ -184,6 +187,7 @@ exports.PRESET_CATALOG = [
             })),
             {
                 chainNamespace: 'eip155:11155111',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:11155111'],
                 allowedCalls: aave(sepoliaPool, 'eip155:11155111'),
                 approvals: [
                     {
@@ -195,6 +199,7 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:421614',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:421614'],
                 allowedCalls: aave(arbitrumPool, 'eip155:421614'),
                 approvals: [
                     {
@@ -206,6 +211,7 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:84532',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:84532'],
                 allowedCalls: [
                     ...aave(basePool, 'eip155:84532'),
                     ...market(moonUSDBC, 'Moonwell mUSDbC', address('0x4616975f7E6045FD9737e95bC527e9e14c727BD2')),
@@ -238,6 +244,7 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:97',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:97'],
                 allowedCalls: [
                     ...market(venusUSDT, 'Venus vUSDT', address('0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c')),
                     ...market(venusUSDC, 'Venus vUSDC', address('0x16227D60f7a0e586C66B005219dfc887D13C9531')),
@@ -270,6 +277,7 @@ exports.PRESET_CATALOG = [
         chains: [
             {
                 chainNamespace: 'eip155:1',
+                defaultTokens: default_tokens_1.STAKING_DEFAULT_TOKENS['eip155:1'],
                 allowedCalls: [
                     {
                         target: stETH,
@@ -333,6 +341,7 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:11155111',
+                defaultTokens: default_tokens_1.STAKING_DEFAULT_TOKENS['eip155:11155111'],
                 allowedCalls: [
                     {
                         target: eigen,

package/src/lib/agentic/presets/default-policy.d.ts

@@ -0,0 +1,9 @@
+import type { Address } from 'viem';
+import type { RuleAsset } from '../agentic.types';
+/** Preset-only permission policy. Ordinary rule authoring retains zero defaults.
+ * Amounts are token quantities, not USD valuations or destination lifetime caps.
+ * Metadata verified read-only on October 18; evidence is retained under plan/agw/.
+ */
+export declare const PRESET_VALIDITY_SECONDS: number;
+export declare const PRESET_GAS_BUDGETS: Readonly<Record<string, bigint>>;
+export declare function defaultPresetAsset(chain: string, token: Address): RuleAsset;

package/src/lib/agentic/presets/default-policy.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESET_GAS_BUDGETS = exports.PRESET_VALIDITY_SECONDS = void 0;
+exports.defaultPresetAsset = defaultPresetAsset;
+const viem_1 = require("viem");
+const errors_1 = require("../errors");
+/** Preset-only permission policy. Ordinary rule authoring retains zero defaults.
+ * Amounts are token quantities, not USD valuations or destination lifetime caps.
+ * Metadata verified read-only on October 18; evidence is retained under plan/agw/.
+ */
+exports.PRESET_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+// Explicit profiles keep future chains from inheriting an unreviewed budget.
+// 20 PC is a ceiling, not the amount charged: execution obtains a fresh quote.
+// This budget has testnet protocol-flow coverage; mainnet remains template-only.
+exports.PRESET_GAS_BUDGETS = Object.fromEntries([
+    'eip155:1',
+    'eip155:8453',
+    'eip155:42161',
+    'eip155:56',
+    'eip155:11155111',
+    'eip155:84532',
+    'eip155:421614',
+    'eip155:97',
+].map((chain) => [chain, (0, viem_1.parseUnits)('20', 18)]));
+const stable6 = { decimals: 6, perCall: '10', total: '100' };
+const stable18 = { ...stable6, decimals: 18 };
+const eth = { decimals: 18, perCall: '0.001', total: '0.01' };
+const bnb = { decimals: 18, perCall: '0.01', total: '0.1' };
+const link = { decimals: 18, perCall: '1', total: '10' };
+// Match by chain AND address. Never infer decimals or limits from a symbol,
+// caller metadata, or the position of a token in an arbitrary selection.
+const TOKEN_BUDGETS = {
+    'eip155:1': [
+        ['0x0000000000000000000000000000000000000000', eth],
+        ['0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', eth],
+        ['0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', stable6],
+        ['0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84', eth],
+        ['0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0', eth],
+    ],
+    'eip155:8453': [
+        ['0x4200000000000000000000000000000000000006', eth],
+        ['0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', stable6],
+    ],
+    'eip155:42161': [
+        ['0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', eth],
+        ['0xaf88d065e77c8cC2239327C5EDb3A432268e5831', stable6],
+    ],
+    'eip155:56': [
+        ['0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', bnb],
+        ['0x55d398326f99059fF775485246999027B3197955', stable18],
+    ],
+    'eip155:11155111': [
+        ['0xfff9976782d46cc05630d1f6ebab18b2324d6b14', eth],
+        ['0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', stable6],
+        ['0xf8Fb3713D459D7C1018BD0A49D19b4C44290EBE5', link],
+        ['0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9', eth],
+    ],
+    'eip155:84532': [
+        ['0x4200000000000000000000000000000000000006', eth],
+        ['0x036CbD53842c5426634e7929541eC2318f3dCF7e', stable6],
+        ['0x810D46F9a9027E28F9B01F75E2bdde839dA61115', link],
+        ['0x4616975f7E6045FD9737e95bC527e9e14c727BD2', stable6],
+        ['0x663A6F02d547dFd639BF689FED298712f2FB69Fb', eth],
+    ],
+    'eip155:421614': [
+        ['0x980B62Da83eFf3D4576C647993b0c1D7faf17c73', eth],
+        ['0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d', stable6],
+    ],
+    'eip155:97': [
+        ['0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd', bnb],
+        ['0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c', stable6],
+        ['0x16227D60f7a0e586C66B005219dfc887D13C9531', stable6],
+    ],
+};
+function defaultPresetAsset(chain, token) {
+    const budget = TOKEN_BUDGETS[chain]?.find(([address]) => (0, viem_1.getAddress)(address) === (0, viem_1.getAddress)(token))?.[1];
+    if (!budget)
+        throw (0, errors_1.capabilityUnavailable)('presetPolicy', `No reviewed default spending policy for ${chain}:${token}`);
+    return {
+        token,
+        maxPerCall: (0, viem_1.parseUnits)(budget.perCall, budget.decimals),
+        maxTotal: (0, viem_1.parseUnits)(budget.total, budget.decimals),
+    };
+}
+//# sourceMappingURL=default-policy.js.map

package/src/lib/agentic/presets/default-tokens.d.ts

@@ -0,0 +1,4 @@
+import { type Address } from 'viem';
+export declare const DEX_DEFAULT_TOKENS: Readonly<Record<string, readonly Address[]>>;
+export declare const LENDING_DEFAULT_TOKENS: Readonly<Record<string, readonly Address[]>>;
+export declare const STAKING_DEFAULT_TOKENS: Readonly<Record<string, readonly Address[]>>;

package/src/lib/agentic/presets/default-tokens.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STAKING_DEFAULT_TOKENS = exports.LENDING_DEFAULT_TOKENS = exports.DEX_DEFAULT_TOKENS = void 0;
+const viem_1 = require("viem");
+/** Curated subsets of the reviewed catalog. Addresses are destination tokens,
+ * not a promise that a Push PRC20 route or protocol liquidity is available.
+ * Keep these sets within the policy's 32-call/32-pin limits after expansion.
+ * Testnet DEX pairs and lending/staking assets match the live preset fixtures.
+ * Mainnet addresses share the catalog's October 15 read-only source baseline.
+ * Spending caps are intentionally separate from token selection.
+ */
+const addresses = (...values) => values.map((value) => (0, viem_1.getAddress)(value.toLowerCase()));
+exports.DEX_DEFAULT_TOKENS = {
+    'eip155:1': addresses('0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'),
+    'eip155:8453': addresses('0x4200000000000000000000000000000000000006', '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'),
+    'eip155:42161': addresses('0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'),
+    'eip155:56': addresses('0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c', '0x55d398326f99059fF775485246999027B3197955'),
+    'eip155:11155111': addresses('0xfff9976782d46cc05630d1f6ebab18b2324d6b14', '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238'),
+    'eip155:84532': addresses('0x4200000000000000000000000000000000000006', '0x036CbD53842c5426634e7929541eC2318f3dCF7e'),
+    'eip155:421614': addresses('0x980B62Da83eFf3D4576C647993b0c1D7faf17c73', '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'),
+    'eip155:97': addresses('0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd', '0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c'),
+};
+exports.LENDING_DEFAULT_TOKENS = {
+    'eip155:1': exports.DEX_DEFAULT_TOKENS['eip155:1'],
+    // One shared reserve/market token keeps Aave + Moonwell/Venus within 32 pins.
+    'eip155:8453': addresses('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'),
+    'eip155:42161': exports.DEX_DEFAULT_TOKENS['eip155:42161'],
+    'eip155:56': addresses('0x55d398326f99059fF775485246999027B3197955'),
+    // Protocol testnet reserves differ from Circle USDC and DEX wrapped ETH.
+    'eip155:11155111': addresses('0xf8Fb3713D459D7C1018BD0A49D19b4C44290EBE5'),
+    'eip155:84532': addresses('0x810D46F9a9027E28F9B01F75E2bdde839dA61115', '0x4616975f7E6045FD9737e95bC527e9e14c727BD2', '0x663A6F02d547dFd639BF689FED298712f2FB69Fb'),
+    'eip155:421614': addresses('0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'),
+    'eip155:97': addresses('0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c', '0x16227D60f7a0e586C66B005219dfc887D13C9531'),
+};
+exports.STAKING_DEFAULT_TOKENS = {
+    'eip155:1': addresses(viem_1.zeroAddress, '0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84', '0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0'),
+    'eip155:11155111': addresses('0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9'),
+};
+//# sourceMappingURL=default-tokens.js.map

package/src/lib/agentic/presets/index.js

@@ -7,6 +7,9 @@ const errors_1 = require("../errors");
 const selectors_1 = require("../codec/selectors");
 const catalog_1 = require("./catalog");
 const operation_limits_1 = require("./operation-limits");
+const enums_1 = require("../../constants/enums");
+const routes_1 = require("./routes");
+const default_policy_1 = require("./default-policy");
 const MAX_UINT256 = (BigInt(1) << BigInt(256)) - BigInt(1);
 const invalid = (message) => new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, message);
 function cap(value, name) {
@@ -51,6 +54,7 @@ function buildPresetApi(catalog) {
         ...p,
         chains: p.chains.map((c) => ({
             ...c,
+            ...(c.defaultTokens ? { defaultTokens: [...c.defaultTokens] } : {}),
             allowedCalls: c.allowedCalls.map((call) => ({
                 ...copyCall(call),
                 ...(call.budget
@@ -93,15 +97,23 @@ function buildPresetApi(catalog) {
                 throw invalid(`unknown preset ${String(preset)}`);
             if (!options || typeof options !== 'object' || Array.isArray(options))
                 throw invalid('preset options must be an object');
+            const now = Math.floor(Date.now() / 1000);
+            const network = options.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT;
+            const funding = options.funding ?? 'push';
+            if (!Object.values(enums_1.PUSH_NETWORK).includes(network))
+                throw invalid('unknown preset Push network');
+            if (funding !== 'push' && funding !== 'destination')
+                throw invalid('preset funding must be push or destination');
             if (options.agent !== undefined &&
                 (!(0, viem_1.isAddress)(options.agent, { strict: false }) ||
                     (0, viem_1.getAddress)(options.agent) === viem_1.zeroAddress))
                 throw invalid('preset agent must be a nonzero Push address');
             if (options.validUntil !== undefined &&
                 (!Number.isSafeInteger(options.validUntil) ||
-                    options.validUntil <= Math.floor(Date.now() / 1000) ||
+                    options.validUntil <= now ||
                     options.validUntil >= 2 ** 48))
                 throw invalid('preset validUntil must be a future uint48 timestamp');
+            const validUntil = options.validUntil ?? now + default_policy_1.PRESET_VALIDITY_SECONDS;
             if (options.maxGasPerCall !== undefined)
                 cap(options.maxGasPerCall, 'maxGasPerCall');
             if (options.assets !== undefined && !Array.isArray(options.assets))
@@ -114,6 +126,12 @@ function buildPresetApi(catalog) {
             if (!chains.length && options.assets?.length)
                 throw (0, errors_1.capabilityUnavailable)('presetCatalog', `preset ${preset} has no approved app entries`);
             const assets = new Map();
+            // An explicit array (including []) replaces the defaults for all selected
+            // chains. Never add permissions on chains the caller left unconfigured.
+            if (options.assets === undefined)
+                for (const chain of chains)
+                    if (chain.defaultTokens)
+                        assets.set(chain.chainNamespace, chain.defaultTokens.map((token) => (0, default_policy_1.defaultPresetAsset)(chain.chainNamespace, token)));
             for (const asset of options.assets ?? []) {
                 if (!asset || typeof asset !== 'object')
                     throw invalid('preset asset must be an object');
@@ -143,6 +161,11 @@ function buildPresetApi(catalog) {
             }
             const readiness = [];
             const rules = chains.map((chain) => {
+                const maxGasPerCall = options.maxGasPerCall ??
+                    chain.maxGasPerCall ??
+                    (chain.defaultTokens
+                        ? default_policy_1.PRESET_GAS_BUDGETS[chain.chainNamespace]
+                        : undefined);
                 const selectedAssets = assets.get(chain.chainNamespace) ?? [];
                 const limits = (0, operation_limits_1.applyOperationLimits)(chain.allowedCalls.map((c) => ({
                     ...copyCall(c),
@@ -282,13 +305,7 @@ function buildPresetApi(catalog) {
                         code: 'AGENT_REQUIRED',
                         message: 'Choose the agent Push address.',
                     });
-                if (!options.validUntil)
-                    issues.push({
-                        code: 'EXPIRY_REQUIRED',
-                        message: 'Choose an expiry.',
-                    });
-                if ((options.maxGasPerCall ?? chain.maxGasPerCall ?? BigInt(0)) ===
-                    BigInt(0))
+                if ((maxGasPerCall ?? BigInt(0)) === BigInt(0))
                     issues.push({
                         code: 'GAS_BUDGET_REQUIRED',
                         message: 'Set a positive PC gas budget per outbound.',
@@ -308,14 +325,27 @@ function buildPresetApi(catalog) {
                         code: 'NO_ENABLED_OPERATION',
                         message: 'No asset operation has a positive per-call limit.',
                     });
+                const configurationReady = issues.length === 0;
+                const routes = (0, routes_1.presetRoutes)(chain.chainNamespace, selectedAssets, network, funding);
+                issues.push(...routes.issues);
+                const bridgeAssets = funding === 'destination' ? [] : selectedAssets;
                 readiness.push({
                     chainNamespace: chain.chainNamespace,
                     ready: issues.length === 0,
+                    configurationReady,
+                    funding,
+                    selectedAssets: selectedAssets.map((a) => ({
+                        ...a,
+                        token: typeof a.token === 'string' ? a.token : { ...a.token },
+                    })),
+                    bridgeAssets: routes.bridgeAssets,
                     issues,
                     disabledCalls: limits.disabledCalls,
                     excludedCalls: limits.excludedCalls,
-                    knownTokens: limits.knownTokens,
-                    zeroBridgeLimits: selectedAssets
+                    knownTokens: [
+                        ...new Set([...limits.knownTokens, ...(chain.defaultTokens ?? [])]),
+                    ],
+                    zeroBridgeLimits: bridgeAssets
                         .filter((a) => a.maxPerCall === BigInt(0) || a.maxTotal === BigInt(0))
                         .map(operation_limits_1.assetAddress),
                 });
@@ -325,16 +355,12 @@ function buildPresetApi(catalog) {
                     ...(options.agent !== undefined
                         ? { agent: (0, viem_1.getAddress)(options.agent) }
                         : {}),
-                    ...(options.validUntil !== undefined
-                        ? { validUntil: options.validUntil }
-                        : {}),
-                    ...(options.assets !== undefined
-                        ? { assets: assets.get(chain.chainNamespace) ?? [] }
+                    validUntil,
+                    ...(options.assets !== undefined || chain.defaultTokens
+                        ? { assets: bridgeAssets }
                         : {}),
-                    ...((options.maxGasPerCall ?? chain.maxGasPerCall) !== undefined
-                        ? {
-                            maxGasPerCall: cap(options.maxGasPerCall ?? chain.maxGasPerCall, 'maxGasPerCall'),
-                        }
+                    ...(maxGasPerCall !== undefined
+                        ? { maxGasPerCall: cap(maxGasPerCall, 'maxGasPerCall') }
                         : {}),
                 };
             });
@@ -347,7 +373,7 @@ function buildPresetApi(catalog) {
             };
         },
     };
-    // The overload narrows templates only when both required fields were supplied and validated.
+    // Expiry is generated; the overload narrows templates when the agent is supplied.
     return Object.freeze(api);
 }
 exports.agenticPresets = buildPresetApi(catalog_1.PRESET_CATALOG);

package/src/lib/agentic/presets/routes.d.ts

@@ -0,0 +1,9 @@
+import { PUSH_NETWORK } from '../../constants/enums';
+import type { RuleAsset } from '../agentic.types';
+import type { PresetChainReadiness, PresetConfigurationIssue } from './types';
+/** Offline registry checks only. Grant preparation still verifies source metadata
+ * and wiring against chain state before any signature or transaction. */
+export declare function presetRoutes(chain: string, assets: RuleAsset[], network: PUSH_NETWORK, funding: 'push' | 'destination'): {
+    bridgeAssets: PresetChainReadiness['bridgeAssets'];
+    issues: PresetConfigurationIssue[];
+};

package/src/lib/agentic/presets/routes.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetRoutes = presetRoutes;
+const viem_1 = require("viem");
+const enums_1 = require("../../constants/enums");
+const helpers_1 = require("../../orchestrator/internals/helpers");
+const prc20_address_1 = require("../../universal/prc20-address");
+const deployments_1 = require("../deployments");
+const operation_limits_1 = require("./operation-limits");
+/** Offline registry checks only. Grant preparation still verifies source metadata
+ * and wiring against chain state before any signature or transaction. */
+function presetRoutes(chain, assets, network, funding) {
+    const issues = [];
+    network =
+        network === enums_1.PUSH_NETWORK.TESTNET ? enums_1.PUSH_NETWORK.TESTNET_DONUT : network;
+    if (!(0, deployments_1.generationsFor)(network).some((g) => g.advertised))
+        issues.push({
+            code: 'AGW_NETWORK_UNAVAILABLE',
+            message: `No verified AGW deployment is registered for ${network}.`,
+        });
+    const supported = helpers_1.SUPPORTED_GATEWAY_CHAINS.includes(chain);
+    if (!supported)
+        issues.push({
+            code: 'DESTINATION_UNAVAILABLE',
+            message: `The SDK has no supported gateway route to ${chain}; this is a catalog template.`,
+        });
+    const bridgeAssets = assets.map((asset) => {
+        const token = (0, operation_limits_1.assetAddress)(asset);
+        try {
+            if (!supported)
+                throw new Error(`No supported gateway route to ${chain}`);
+            const prc20 = (0, prc20_address_1.getPRC20Address)({ chain, address: token }, { network });
+            return {
+                token,
+                prc20: (0, viem_1.getAddress)(prc20.address),
+                status: 'registered',
+            };
+        }
+        catch {
+            if (funding === 'push')
+                issues.push({
+                    code: 'BRIDGE_ASSET_UNAVAILABLE',
+                    token,
+                    message: `No SDK PRC20 mapping for ${chain}:${token} on ${network}. Use a supported source asset or explicitly choose destination funding for assets already at the CEA.`,
+                });
+            return { token, status: 'unavailable' };
+        }
+    });
+    return { bridgeAssets, issues };
+}
+//# sourceMappingURL=routes.js.map

package/src/lib/agentic/presets/types.d.ts

@@ -1,4 +1,5 @@
 import type { Address } from 'viem';
+import type { PUSH_NETWORK } from '../../constants/enums';
 import type { Rule, RuleAsset, RuleCall, ForeignChainNamespace } from '../agentic.types';
 export type PresetCategory = 'DEXES' | 'LENDING' | 'STAKING' | 'PREDICTION';
 export interface Preset {
@@ -7,7 +8,7 @@ export interface Preset {
     name: string;
     chains: ForeignChainNamespace[];
 }
-/** An editable review-screen template; both identity and expiry are required by create. */
+/** Presets generate expiry; optional fields retain editable-template compatibility. */
 export type PresetRuleTemplate = Omit<Rule, 'agent' | 'validUntil'> & {
     agent?: Address;
     validUntil?: number;
@@ -22,23 +23,33 @@ export interface PresetAsset {
     maxTotal?: bigint;
 }
 export interface PresetOptions {
-    /** Explicit Push-PC gas budget per outbound; omitted = zero. */
+    /** Offline route/deployment checks; defaults to TESTNET_DONUT. */
+    network?: PUSH_NETWORK;
+    /** Push funding requires PRC20 routes. Destination funding explicitly emits
+     * empty bridge assets while preserving selected token/call limits in metadata.
+     * The CEA must already hold the required destination assets. Default: push. */
+    funding?: 'push' | 'destination';
+    /** Push-PC budget ceiling per outbound; omitted uses the catalog policy (20 PC).
+     * Explicit zero is preserved. This is not the fee charged. */
     maxGasPerCall?: bigint;
     chainNamespace?: ForeignChainNamespace;
     agent?: Address;
+    /** Omitted: seven days from generation time. Explicit expiry is preserved. */
     validUntil?: number;
-    /** DEX swaps with fewer than two tokens are zero-input-cap review templates.
-     * Call get again with a complete pair to generate token pins and amount limits. */
+    /** Omitted: include the catalog's curated tokens and explicit spending policy.
+     * An explicit array replaces all defaults (including [] to select no tokens).
+     * Supplied assets retain zero for omitted caps; no policy is guessed for them.
+     * DEX swaps with fewer than two tokens remain zero-input-cap review templates. */
     assets?: PresetAsset[];
 }
 export interface ReadyPresetOptions extends PresetOptions {
     agent: Address;
-    validUntil: number;
 }
-/** Offline configuration only: does not check deployment, reserves, balances or liquidity. */
+/** Offline configuration/registry checks; chain state and balances are not checked. */
 export interface PresetConfigurationIssue {
-    code: 'AGENT_REQUIRED' | 'EXPIRY_REQUIRED' | 'GAS_BUDGET_REQUIRED' | 'ASSETS_REQUIRED' | 'TOKEN_PAIR_REQUIRED' | 'NO_ENABLED_OPERATION';
+    code: 'AGENT_REQUIRED' | 'EXPIRY_REQUIRED' | 'GAS_BUDGET_REQUIRED' | 'ASSETS_REQUIRED' | 'TOKEN_PAIR_REQUIRED' | 'NO_ENABLED_OPERATION' | 'AGW_NETWORK_UNAVAILABLE' | 'DESTINATION_UNAVAILABLE' | 'BRIDGE_ASSET_UNAVAILABLE';
     message: string;
+    token?: string;
 }
 export interface PresetCallIssue {
     target: string;
@@ -51,12 +62,22 @@ export interface PresetCallIssue {
 export interface PresetChainReadiness {
     chainNamespace: ForeignChainNamespace;
     ready: boolean;
+    configurationReady: boolean;
+    funding: 'push' | 'destination';
+    /** Selected destination permissions, retained even when bridge assets is empty. */
+    selectedAssets: RuleAsset[];
+    /** Registry presence only; grant preparation verifies exact on-chain identity. */
+    bridgeAssets: {
+        token: string;
+        status: 'registered' | 'unavailable';
+        prc20?: Address;
+    }[];
     issues: PresetConfigurationIssue[];
     /** Calls present in the rule but disabled by a zero amount/value maximum. */
     disabledCalls: PresetCallIssue[];
     /** Calls deliberately omitted, including operations with incompatible amount units. */
     excludedCalls: PresetCallIssue[];
-    /** Known fixed-token/reserve addresses in this catalog, not selected defaults. */
+    /** Known catalog token addresses, including the curated default subset. */
     knownTokens: string[];
     /** Selected tokens with a zero Push-outbound budget; destination-held assets are separate. */
     zeroBridgeLimits: string[];

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

@@ -4,6 +4,10 @@ exports.getPRC20Address = getPRC20Address;
 const enums_1 = require("../constants/enums");
 const tokens_1 = require("../constants/tokens");
 const chain_1 = require("../constants/chain");
+const viem_1 = require("viem");
+const sameTokenAddress = (a, b) => (0, viem_1.isAddress)(a, { strict: false }) && (0, viem_1.isAddress)(b, { strict: false })
+    ? a.toLowerCase() === b.toLowerCase()
+    : a === b;
 /** 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;
@@ -33,7 +37,8 @@ function getPRC20Address(token, options) {
         // 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);
+            const match = (list ?? []).find((t) => t.symbol === token.symbol &&
+                sameTokenAddress(t.address, token.address));
             if (match) {
                 originChain = k;
                 tokenSymbol = match.symbol;
@@ -46,7 +51,7 @@ function getPRC20Address(token, options) {
         // { 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);
+        const match = list.find((t) => sameTokenAddress(t.address, token.address));
         if (match) {
             tokenSymbol = match.symbol;
             tokenDecimals = match.decimals;
@@ -60,14 +65,23 @@ function getPRC20Address(token, options) {
         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;
+    // Current synthetic keys represent testnet sources. Mainnet assets must never
+    // resolve to a same-symbol Sepolia token on Donut.
+    const isEthFamily = 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 'WETH':
+        case 'stETH': {
+            // These deployments represent Sepolia tokens, not other chains' assets.
+            if (originChain !== enums_1.CHAIN.ETHEREUM_SEPOLIA)
+                throw new Error(`Unsupported ${tokenSymbol} origin chain for synthetic mapping`);
+            key = tokenSymbol === 'WETH' ? 'WETH_ETH' : 'stETH_ETH';
+            break;
+        }
         case 'ETH': {
             if (isEthFamily)
                 key = 'pETH';