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

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

@@ -2,13 +2,15 @@
 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.
  */
 const address = (value) => (0, viem_1.getAddress)(value.toLowerCase());
 const wallet = 'agentic:wallet';
-const aave = (pool) => [
+const aave = (pool, chain) => [
     ['supply(address,uint256,address,uint16)', 2, 'Supply'],
     ['withdraw(address,uint256,address)', 2, 'Withdraw'],
     ['borrow(address,uint256,uint256,uint16,address)', 4, 'Borrow'],
@@ -19,8 +21,14 @@ const aave = (pool) => [
     pins: [{ arg: arg, expected: wallet }],
     app: 'Aave V3',
     label: label,
+    budget: {
+        kind: 'token-argument',
+        tokenArg: 0,
+        amountArg: 1,
+        tokens: aave_reserves_1.AAVE_RESERVES[chain],
+    },
 }));
-const market = (target, app) => [
+const market = (target, app, token) => [
     'mint(uint256)',
     'redeem(uint256)',
     'redeemUnderlying(uint256)',
@@ -31,6 +39,13 @@ const market = (target, app) => [
     selector: selector,
     app,
     label: selector.split('(')[0],
+    budget: selector === 'redeem(uint256)'
+        ? {
+            kind: 'unsupported',
+            reason: 'SHARE_AMOUNT',
+            alternative: 'redeemUnderlying(uint256)',
+        }
+        : { kind: 'fixed-token', token, amountArg: 0 },
 }));
 const sepoliaPool = address('0x6Ae43d3271ff6888e7Fc43Fd7321a503ff738951');
 const basePool = address('0x8bAB6d1b75f19e9eD9fCe8b9BD338844fF79aE27');
@@ -76,7 +91,7 @@ const mainnetMarkets = (chain) => {
         : '0xfD36E2c2a6789Db23113685031d7F16329158384';
     return {
         allowedCalls: [
-            ...entries.flatMap(([target, app]) => market(address(target), app)),
+            ...entries.flatMap(([target, app, token]) => market(address(target), app, address(token))),
             ...(entries.length
                 ? [
                     {
@@ -84,6 +99,7 @@ const mainnetMarkets = (chain) => {
                         selector: 'enterMarkets(address[])',
                         app: chain === 'eip155:8453' ? 'Moonwell' : 'Venus',
                         label: 'Enter markets',
+                        budget: { kind: 'setup' },
                     },
                 ]
                 : []),
@@ -138,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 }],
@@ -154,40 +171,65 @@ exports.PRESET_CATALOG = [
                 ['eip155:56', '0x6807dc923806fE8Fd134338EABCA509979a7e0cB'],
             ].map(([chainNamespace, pool]) => ({
                 chainNamespace,
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS[chainNamespace],
                 allowedCalls: [
-                    ...aave(address(pool)),
+                    ...aave(address(pool), chainNamespace),
                     ...mainnetMarkets(chainNamespace).allowedCalls,
                 ],
                 approvals: [
-                    { spender: address(pool), app: 'Aave V3' },
+                    {
+                        spender: address(pool),
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES[chainNamespace],
+                    },
                     ...(mainnetMarkets(chainNamespace).approvals ?? []),
                 ],
             })),
             {
                 chainNamespace: 'eip155:11155111',
-                allowedCalls: aave(sepoliaPool),
-                approvals: [{ spender: sepoliaPool, app: 'Aave V3' }],
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:11155111'],
+                allowedCalls: aave(sepoliaPool, 'eip155:11155111'),
+                approvals: [
+                    {
+                        spender: sepoliaPool,
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES['eip155:11155111'],
+                    },
+                ],
             },
             {
                 chainNamespace: 'eip155:421614',
-                allowedCalls: aave(arbitrumPool),
-                approvals: [{ spender: arbitrumPool, app: 'Aave V3' }],
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:421614'],
+                allowedCalls: aave(arbitrumPool, 'eip155:421614'),
+                approvals: [
+                    {
+                        spender: arbitrumPool,
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES['eip155:421614'],
+                    },
+                ],
             },
             {
                 chainNamespace: 'eip155:84532',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:84532'],
                 allowedCalls: [
-                    ...aave(basePool),
-                    ...market(moonUSDBC, 'Moonwell mUSDbC'),
-                    ...market(moonWETH, 'Moonwell mWETH'),
+                    ...aave(basePool, 'eip155:84532'),
+                    ...market(moonUSDBC, 'Moonwell mUSDbC', address('0x4616975f7E6045FD9737e95bC527e9e14c727BD2')),
+                    ...market(moonWETH, 'Moonwell mWETH', address('0x663A6F02d547dFd639BF689FED298712f2FB69Fb')),
                     {
                         target: address('0xC72ba45f2Ae134F21DAEb2b7B5fd5De0064Ee9bB'),
                         selector: 'enterMarkets(address[])',
                         app: 'Moonwell',
                         label: 'Enter markets',
+                        budget: { kind: 'setup' },
                     },
                 ],
                 approvals: [
-                    { spender: basePool, app: 'Aave V3' },
+                    {
+                        spender: basePool,
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES['eip155:84532'],
+                    },
                     {
                         spender: moonUSDBC,
                         app: 'Moonwell mUSDbC',
@@ -202,14 +244,16 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:97',
+                defaultTokens: default_tokens_1.LENDING_DEFAULT_TOKENS['eip155:97'],
                 allowedCalls: [
-                    ...market(venusUSDT, 'Venus vUSDT'),
-                    ...market(venusUSDC, 'Venus vUSDC'),
+                    ...market(venusUSDT, 'Venus vUSDT', address('0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c')),
+                    ...market(venusUSDC, 'Venus vUSDC', address('0x16227D60f7a0e586C66B005219dfc887D13C9531')),
                     {
                         target: address('0x94d1820b2D1c7c7452A163983Dc888CEC546b77D'),
                         selector: 'enterMarkets(address[])',
                         app: 'Venus',
                         label: 'Enter markets',
+                        budget: { kind: 'setup' },
                     },
                 ],
                 approvals: [
@@ -233,25 +277,29 @@ exports.PRESET_CATALOG = [
         chains: [
             {
                 chainNamespace: 'eip155:1',
+                defaultTokens: default_tokens_1.STAKING_DEFAULT_TOKENS['eip155:1'],
                 allowedCalls: [
                     {
                         target: stETH,
                         selector: 'submit(address)',
                         maxValue: BigInt(0),
                         app: 'Lido',
-                        label: 'Stake ETH (set an explicit value cap)',
+                        label: 'Stake ETH',
+                        budget: { kind: 'native-value' },
                     },
                     {
                         target: wstETH,
                         selector: 'wrap(uint256)',
                         app: 'Lido wstETH',
                         label: 'Wrap stETH',
+                        budget: { kind: 'fixed-token', token: stETH, amountArg: 0 },
                     },
                     {
                         target: wstETH,
                         selector: 'unwrap(uint256)',
                         app: 'Lido wstETH',
                         label: 'Unwrap wstETH',
+                        budget: { kind: 'fixed-token', token: wstETH, amountArg: 0 },
                     },
                     {
                         target: lidoQueue,
@@ -259,29 +307,32 @@ exports.PRESET_CATALOG = [
                         pins: [{ arg: 1, expected: wallet }],
                         app: 'Lido withdrawal queue',
                         label: 'Request withdrawal',
+                        budget: { kind: 'unsupported', reason: 'DYNAMIC_AMOUNT' },
                     },
                     {
                         target: lidoQueue,
                         selector: 'claimWithdrawals(uint256[],uint256[])',
                         app: 'Lido withdrawal queue',
                         label: 'Claim finalized withdrawals',
+                        budget: { kind: 'unsupported', reason: 'POSITION_AMOUNT' },
                     },
                     {
                         target: lidoQueue,
                         selector: 'claimWithdrawal(uint256)',
                         app: 'Lido withdrawal queue',
                         label: 'Claim finalized withdrawal',
+                        budget: { kind: 'unsupported', reason: 'POSITION_AMOUNT' },
                     },
                     {
                         target: address('0x858646372CC42E1A627fcE94aa7A7033e7CF075A'),
                         selector: 'depositIntoStrategy(address,address,uint256)',
                         app: 'EigenLayer',
                         label: 'Deposit into strategy (withdrawals not included)',
+                        budget: { kind: 'token-argument', tokenArg: 1, amountArg: 2 },
                     },
                 ],
                 approvals: [
                     { spender: wstETH, token: stETH, app: 'Lido wstETH' },
-                    { spender: lidoQueue, token: stETH, app: 'Lido withdrawal queue' },
                     {
                         spender: address('0x858646372CC42E1A627fcE94aa7A7033e7CF075A'),
                         app: 'EigenLayer',
@@ -290,12 +341,14 @@ exports.PRESET_CATALOG = [
             },
             {
                 chainNamespace: 'eip155:11155111',
+                defaultTokens: default_tokens_1.STAKING_DEFAULT_TOKENS['eip155:11155111'],
                 allowedCalls: [
                     {
                         target: eigen,
                         selector: 'depositIntoStrategy(address,address,uint256)',
                         app: 'EigenLayer',
                         label: 'Deposit into strategy (withdrawals not included)',
+                        budget: { kind: 'token-argument', tokenArg: 1, amountArg: 2 },
                     },
                 ],
                 approvals: [{ spender: eigen, app: 'EigenLayer' }],

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

@@ -6,6 +6,10 @@ const viem_1 = require("viem");
 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) {
@@ -50,8 +54,24 @@ function buildPresetApi(catalog) {
         ...p,
         chains: p.chains.map((c) => ({
             ...c,
-            allowedCalls: c.allowedCalls.map(copyCall),
-            approvals: c.approvals?.map((a) => ({ ...a })),
+            ...(c.defaultTokens ? { defaultTokens: [...c.defaultTokens] } : {}),
+            allowedCalls: c.allowedCalls.map((call) => ({
+                ...copyCall(call),
+                ...(call.budget
+                    ? {
+                        budget: {
+                            ...call.budget,
+                            ...(call.budget.kind === 'token-argument' && call.budget.tokens
+                                ? { tokens: [...call.budget.tokens] }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            })),
+            approvals: c.approvals?.map((a) => ({
+                ...a,
+                ...(a.tokens ? { tokens: [...a.tokens] } : {}),
+            })),
             swapRouters: c.swapRouters?.map((r) => ({ ...r })),
         })),
     }));
@@ -77,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))
@@ -98,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');
@@ -125,8 +159,19 @@ function buildPresetApi(catalog) {
                 });
                 assets.set(chain, group);
             }
+            const readiness = [];
             const rules = chains.map((chain) => {
-                const calls = chain.allowedCalls.map(copyCall);
+                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),
+                    ...(c.budget ? { budget: c.budget } : {}),
+                })), selectedAssets);
+                const calls = limits.calls;
                 if (chain.swapRouters?.length) {
                     const tokens = assets.get(chain.chainNamespace) ?? [];
                     if (tokens.some((a) => tokenAddress(a.token) === viem_1.zeroAddress ||
@@ -185,6 +230,21 @@ function buildPresetApi(catalog) {
                                     });
                             }
                 }
+                if (chain.swapRouters?.length) {
+                    const swaps = calls.filter((c) => c.selector.startsWith('exact'));
+                    for (const c of swaps) {
+                        const positive = c.pins?.some((p) => 'max' in p && p.max !== undefined && p.max > BigInt(0));
+                        if (positive)
+                            limits.enabled = true;
+                        else
+                            limits.disabledCalls.push({
+                                target: c.target,
+                                selector: c.selector,
+                                app: c.app,
+                                reason: selectedAssets.length < 2 ? 'TOKEN_REQUIRED' : 'ZERO_CAP',
+                            });
+                    }
+                }
                 const approvals = new Set();
                 for (const asset of assets.get(chain.chainNamespace) ?? []) {
                     const token = tokenAddress(asset.token);
@@ -198,6 +258,9 @@ function buildPresetApi(catalog) {
                         if (approval.token &&
                             (0, viem_1.getAddress)(token) !== (0, viem_1.getAddress)(approval.token))
                             continue;
+                        if (approval.tokens &&
+                            !approval.tokens.some((t) => (0, viem_1.getAddress)(t) === (0, viem_1.getAddress)(token)))
+                            continue;
                         const spender = (0, viem_1.getAddress)(approval.spender);
                         const target = (0, viem_1.getAddress)(token);
                         const approvalKey = `${target}:${spender}`;
@@ -236,29 +299,81 @@ function buildPresetApi(catalog) {
                         throw (0, errors_1.capabilityUnavailable)('presetCalls', 'an unpinned alternative would bypass restrictions for this target/function');
                     pairs.set(pair, !!call.pins?.length);
                 }
+                const issues = [];
+                if (!options.agent)
+                    issues.push({
+                        code: 'AGENT_REQUIRED',
+                        message: 'Choose the agent Push address.',
+                    });
+                if ((maxGasPerCall ?? BigInt(0)) === BigInt(0))
+                    issues.push({
+                        code: 'GAS_BUDGET_REQUIRED',
+                        message: 'Set a positive PC gas budget per outbound.',
+                    });
+                if (!selectedAssets.length)
+                    issues.push({
+                        code: 'ASSETS_REQUIRED',
+                        message: 'Choose tokens and their limits, then regenerate this preset.',
+                    });
+                if (chain.swapRouters?.length && selectedAssets.length < 2)
+                    issues.push({
+                        code: 'TOKEN_PAIR_REQUIRED',
+                        message: 'Choose both swap tokens, then regenerate this preset.',
+                    });
+                if (!limits.enabled)
+                    issues.push({
+                        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: [
+                        ...new Set([...limits.knownTokens, ...(chain.defaultTokens ?? [])]),
+                    ],
+                    zeroBridgeLimits: bridgeAssets
+                        .filter((a) => a.maxPerCall === BigInt(0) || a.maxTotal === BigInt(0))
+                        .map(operation_limits_1.assetAddress),
+                });
                 return {
                     chainNamespace: chain.chainNamespace,
                     allowedCalls: calls,
                     ...(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') }
                         : {}),
                 };
             });
-            return { rules };
+            return {
+                rules,
+                readiness: {
+                    ready: readiness.length > 0 && readiness.every((c) => c.ready),
+                    chains: readiness,
+                },
+            };
         },
     };
-    // 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/operation-limits.d.ts

@@ -0,0 +1,13 @@
+import type { RuleAsset, RuleCall } from '../agentic.types';
+import type { PresetCallDefinition } from './catalog';
+import type { PresetCallIssue } from './types';
+export declare const assetAddress: (asset: RuleAsset) => string;
+export declare const nativeAsset: (asset: RuleAsset) => boolean;
+/** Compile reviewed protocol argument positions. No exchange-rate or share guesses. */
+export declare function applyOperationLimits(definitions: readonly PresetCallDefinition[], assets: RuleAsset[]): {
+    calls: RuleCall[];
+    enabled: boolean;
+    disabledCalls: PresetCallIssue[];
+    excludedCalls: PresetCallIssue[];
+    knownTokens: string[];
+};