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

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

@@ -1,10 +1,351 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRESET_CATALOG = void 0;
-/** No approved app/address catalog yet. Empty categories must be hidden by UIs. */
+const viem_1 = require("viem");
+const aave_reserves_1 = require("./aave-reserves");
+/** 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, chain) => [
+    ['supply(address,uint256,address,uint16)', 2, 'Supply'],
+    ['withdraw(address,uint256,address)', 2, 'Withdraw'],
+    ['borrow(address,uint256,uint256,uint16,address)', 4, 'Borrow'],
+    ['repay(address,uint256,uint256,address)', 3, 'Repay'],
+].map(([selector, arg, label]) => ({
+    target: pool,
+    selector: selector,
+    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, token) => [
+    'mint(uint256)',
+    'redeem(uint256)',
+    'redeemUnderlying(uint256)',
+    'borrow(uint256)',
+    'repayBorrow(uint256)',
+].map((selector) => ({
+    target,
+    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');
+const arbitrumPool = address('0xBfC91D59fdAA134A4ED45f7B584cAf96D7792Eff');
+const moonUSDBC = address('0x876852425331a113d8E432eFFB3aC5BEf38f033a');
+const moonWETH = address('0x2F39a349A79492a70E152760ce7123A1933eCf28');
+const venusUSDT = address('0xb7526572FFE56AB9D7489838Bf2E18e3323b441A');
+const venusUSDC = address('0xD5C4C2e2facBEB59D0216D0595d63FcDc6F9A1a7');
+const eigen = address('0x2E3D6c0744b10eb0A4e6F679F71554a39Ec47a5D');
+const stETH = address('0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84');
+const wstETH = address('0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0');
+const lidoQueue = address('0x889edC2eDab5f40e902b864aD4d7AdE8E412F9B1');
+const mainnetMarkets = (chain) => {
+    const entries = chain === 'eip155:8453'
+        ? [
+            [
+                '0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22',
+                'Moonwell mUSDC',
+                '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+            ],
+            [
+                '0x628ff693426583D9a7FB391E54366292F509D457',
+                'Moonwell mWETH',
+                '0x4200000000000000000000000000000000000006',
+            ],
+        ]
+        : chain === 'eip155:56'
+            ? [
+                [
+                    '0xfD5840Cd36d94D7229439859C0112a4185BC0255',
+                    'Venus vUSDT',
+                    '0x55d398326f99059fF775485246999027B3197955',
+                ],
+                [
+                    '0xecA88125a5ADbe82614ffC12D0DB554E2e2867C8',
+                    'Venus vUSDC',
+                    '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
+                ],
+            ]
+            : [];
+    const controller = chain === 'eip155:8453'
+        ? '0xfBb21d0380beE3312B33c4353c8936a0F13EF26C'
+        : '0xfD36E2c2a6789Db23113685031d7F16329158384';
+    return {
+        allowedCalls: [
+            ...entries.flatMap(([target, app, token]) => market(address(target), app, address(token))),
+            ...(entries.length
+                ? [
+                    {
+                        target: address(controller),
+                        selector: 'enterMarkets(address[])',
+                        app: chain === 'eip155:8453' ? 'Moonwell' : 'Venus',
+                        label: 'Enter markets',
+                        budget: { kind: 'setup' },
+                    },
+                ]
+                : []),
+        ],
+        approvals: entries.map(([spender, app, token]) => ({
+            spender: address(spender),
+            app,
+            token: address(token),
+        })),
+    };
+};
 exports.PRESET_CATALOG = [
-    { constant: 'DEXES', name: 'Popular DEXes', chains: [] },
-    { constant: 'LENDING', name: 'Lending', chains: [] },
+    {
+        constant: 'DEXES',
+        name: 'Popular DEXes',
+        chains: [
+            ['eip155:1', '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45', 'Uniswap V3'],
+            [
+                'eip155:8453',
+                '0x2626664c2603336E57B271c5C0b26F421741e481',
+                'Uniswap V3',
+            ],
+            [
+                'eip155:42161',
+                '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+                'Uniswap V3',
+            ],
+            [
+                'eip155:56',
+                '0x13f4EA83D0bd40E75C8222255bc855a974568Dd4',
+                'PancakeSwap V3',
+            ],
+            [
+                'eip155:11155111',
+                '0x3bFA4769FB09eefC5a80d6E87c3B9C650f7Ae48E',
+                'Uniswap V3',
+            ],
+            [
+                'eip155:84532',
+                '0x94cC0AaC535CCDB3C01d6787D6413C739ae12bc4',
+                'Uniswap V3',
+            ],
+            [
+                'eip155:421614',
+                '0x101F443B4d1b059569D643917553c771E1b9663E',
+                'Uniswap V3',
+            ],
+            [
+                'eip155:97',
+                '0x9a489505a00cE272eAa5e07Dba6491314CaE3796',
+                'PancakeSwap V3',
+            ],
+        ].map(([chain, router, app]) => ({
+            chainNamespace: chain,
+            allowedCalls: [],
+            swapRouters: [{ address: address(router), app }],
+            approvals: [{ spender: address(router), app }],
+        })),
+    },
+    {
+        constant: 'LENDING',
+        name: 'Lending',
+        chains: [
+            ...[
+                ['eip155:1', '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2'],
+                ['eip155:8453', '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5'],
+                ['eip155:42161', '0x794a61358D6845594F94dc1DB02A252b5b4814aD'],
+                ['eip155:56', '0x6807dc923806fE8Fd134338EABCA509979a7e0cB'],
+            ].map(([chainNamespace, pool]) => ({
+                chainNamespace,
+                allowedCalls: [
+                    ...aave(address(pool), chainNamespace),
+                    ...mainnetMarkets(chainNamespace).allowedCalls,
+                ],
+                approvals: [
+                    {
+                        spender: address(pool),
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES[chainNamespace],
+                    },
+                    ...(mainnetMarkets(chainNamespace).approvals ?? []),
+                ],
+            })),
+            {
+                chainNamespace: '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, 'eip155:421614'),
+                approvals: [
+                    {
+                        spender: arbitrumPool,
+                        app: 'Aave V3',
+                        tokens: aave_reserves_1.AAVE_RESERVES['eip155:421614'],
+                    },
+                ],
+            },
+            {
+                chainNamespace: 'eip155:84532',
+                allowedCalls: [
+                    ...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',
+                        tokens: aave_reserves_1.AAVE_RESERVES['eip155:84532'],
+                    },
+                    {
+                        spender: moonUSDBC,
+                        app: 'Moonwell mUSDbC',
+                        token: address('0x4616975f7E6045FD9737e95bC527e9e14c727BD2'),
+                    },
+                    {
+                        spender: moonWETH,
+                        app: 'Moonwell mWETH',
+                        token: address('0x663A6F02d547dFd639BF689FED298712f2FB69Fb'),
+                    },
+                ],
+            },
+            {
+                chainNamespace: 'eip155:97',
+                allowedCalls: [
+                    ...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: [
+                    {
+                        spender: venusUSDT,
+                        app: 'Venus vUSDT',
+                        token: address('0xA11c8D9DC9b66E209Ef60F0C8D969D3CD988782c'),
+                    },
+                    {
+                        spender: venusUSDC,
+                        app: 'Venus vUSDC',
+                        token: address('0x16227D60f7a0e586C66B005219dfc887D13C9531'),
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        constant: 'STAKING',
+        name: 'Staking',
+        chains: [
+            {
+                chainNamespace: 'eip155:1',
+                allowedCalls: [
+                    {
+                        target: stETH,
+                        selector: 'submit(address)',
+                        maxValue: BigInt(0),
+                        app: 'Lido',
+                        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,
+                        selector: 'requestWithdrawals(uint256[],address)',
+                        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: address('0x858646372CC42E1A627fcE94aa7A7033e7CF075A'),
+                        app: 'EigenLayer',
+                    },
+                ],
+            },
+            {
+                chainNamespace: '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' }],
+            },
+        ],
+    },
     { constant: 'PREDICTION', name: 'Prediction markets', chains: [] },
 ];
 //# sourceMappingURL=catalog.js.map

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

@@ -6,6 +6,7 @@ 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 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) {
@@ -20,12 +21,19 @@ function copyCall(call) {
         ...call,
         ...(call.pins
             ? {
-                pins: call.pins.map((p) => ({
-                    ...p,
-                    ...('token' in p && p.token && typeof p.token === 'object'
-                        ? { token: { ...p.token } }
-                        : {}),
-                })),
+                pins: call.pins.map((pin) => {
+                    if (pin.account !== undefined)
+                        return {
+                            ...pin,
+                            ...(pin.token && typeof pin.token === 'object'
+                                ? { token: { ...pin.token } }
+                                : {}),
+                        };
+                    return {
+                        ...pin,
+                        arg: typeof pin.arg === 'number' ? pin.arg : [...pin.arg],
+                    };
+                }),
             }
             : {}),
     };
@@ -43,8 +51,24 @@ function buildPresetApi(catalog) {
         ...p,
         chains: p.chains.map((c) => ({
             ...c,
-            allowedCalls: c.allowedCalls.map(copyCall),
-            approvals: c.approvals?.map((a) => ({ ...a })),
+            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 })),
         })),
     }));
     if (new Set(entries.map((e) => e.constant)).size !== entries.length ||
@@ -78,6 +102,8 @@ function buildPresetApi(catalog) {
                     options.validUntil <= Math.floor(Date.now() / 1000) ||
                     options.validUntil >= 2 ** 48))
                 throw invalid('preset validUntil must be a future uint48 timestamp');
+            if (options.maxGasPerCall !== undefined)
+                cap(options.maxGasPerCall, 'maxGasPerCall');
             if (options.assets !== undefined && !Array.isArray(options.assets))
                 throw invalid('preset assets must be an array');
             const chains = options.chainNamespace === undefined
@@ -115,9 +141,88 @@ function buildPresetApi(catalog) {
                 });
                 assets.set(chain, group);
             }
+            const readiness = [];
             const rules = chains.map((chain) => {
-                const calls = chain.allowedCalls.map(copyCall);
-                const approvals = new Map();
+                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 ||
+                        (typeof a.token !== 'string' && a.token.mechanism === 'native')))
+                        throw invalid('DEX token pins require explicit ERC20 addresses; use wrapped-native tokens instead of the native marker');
+                    // Keep discovery useful before a swap pair is selected. These review
+                    // calls cannot spend input tokens: the amount maximum is explicitly zero.
+                    // Re-run get with both tokens to generate the executable pair pins.
+                    if (tokens.length < 2)
+                        for (const router of chain.swapRouters)
+                            for (const exactInput of [true, false])
+                                calls.push({
+                                    target: router.address,
+                                    selector: `${exactInput ? 'exactInputSingle' : 'exactOutputSingle'}((address,address,uint24,address,uint256,uint256,uint160))`,
+                                    pins: [
+                                        ...(tokens.length
+                                            ? [
+                                                {
+                                                    arg: [0, 0],
+                                                    expected: (0, viem_1.getAddress)(tokenAddress(tokens[0].token)),
+                                                },
+                                            ]
+                                            : []),
+                                        { arg: [0, 3], expected: 'agentic:wallet' },
+                                        { arg: [0, exactInput ? 4 : 5], max: BigInt(0) },
+                                    ],
+                                    app: router.app,
+                                    label: `${exactInput ? 'Swap exact input' : 'Swap exact output'} (select two tokens to enable)`,
+                                });
+                    for (const router of chain.swapRouters)
+                        for (const input of tokens)
+                            for (const output of tokens) {
+                                if (tokenAddress(input.token).toLowerCase() ===
+                                    tokenAddress(output.token).toLowerCase())
+                                    continue;
+                                for (const exactInput of [true, false])
+                                    calls.push({
+                                        target: router.address,
+                                        selector: `${exactInput ? 'exactInputSingle' : 'exactOutputSingle'}((address,address,uint24,address,uint256,uint256,uint160))`,
+                                        pins: [
+                                            {
+                                                arg: [0, 0],
+                                                expected: (0, viem_1.getAddress)(tokenAddress(input.token)),
+                                            },
+                                            {
+                                                arg: [0, 1],
+                                                expected: (0, viem_1.getAddress)(tokenAddress(output.token)),
+                                            },
+                                            { arg: [0, 3], expected: 'agentic:wallet' },
+                                            { arg: [0, exactInput ? 4 : 5], max: input.maxPerCall },
+                                        ],
+                                        app: router.app,
+                                        label: exactInput
+                                            ? 'Swap exact input'
+                                            : 'Swap exact output',
+                                    });
+                            }
+                }
+                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);
                     if (token === viem_1.zeroAddress ||
@@ -127,14 +232,18 @@ function buildPresetApi(catalog) {
                     for (const approval of chain.approvals ?? []) {
                         if (!chain.chainNamespace.startsWith('eip155:'))
                             throw (0, errors_1.capabilityUnavailable)('presetApproval', 'Solana approvals require a separately reviewed instruction template');
+                        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 previous = approvals.get(target);
-                        if (previous && previous !== spender)
-                            throw (0, errors_1.capabilityUnavailable)('presetApproval', 'multiple spenders for one token need a reviewed policy representation; no unrestricted approval is generated');
-                        if (previous)
+                        const approvalKey = `${target}:${spender}`;
+                        if (approvals.has(approvalKey))
                             continue;
-                        approvals.set(target, spender);
+                        approvals.add(approvalKey);
                         calls.push({
                             target,
                             selector: 'approve(address,uint256)',
@@ -149,7 +258,9 @@ function buildPresetApi(catalog) {
                 }
                 if (!calls.length || calls.length > 32)
                     throw (0, errors_1.capabilityUnavailable)('presetCalls', 'preset must contain 1..32 allowed calls including approvals');
-                const pairs = new Set();
+                if (calls.reduce((n, c) => n + (c.pins?.length ?? 0), 0) > 32)
+                    throw (0, errors_1.capabilityUnavailable)('presetPins', 'preset expansion exceeds 32 pins; reduce the token list or split rules across wallets');
+                const pairs = new Map();
                 for (const call of calls) {
                     if (!/^[A-Za-z_$][\w$]*\(.*\)$/.test(call.selector))
                         throw invalid('preset selectors must be full signatures');
@@ -159,10 +270,55 @@ function buildPresetApi(catalog) {
                     const pair = `${chain.chainNamespace.startsWith('eip155:')
                         ? call.target.toLowerCase()
                         : call.target}:${selector}`;
-                    if (pairs.has(pair))
-                        throw (0, errors_1.capabilityUnavailable)('presetCalls', 'duplicate target/function entries need a reviewed policy representation');
-                    pairs.add(pair);
+                    if (pairs.has(pair) && !chain.chainNamespace.startsWith('eip155:'))
+                        throw (0, errors_1.capabilityUnavailable)('presetCalls', 'Solana does not support alternative entries for one program/instruction');
+                    if (pairs.has(pair) && (!call.pins?.length || !pairs.get(pair)))
+                        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 (!options.validUntil)
+                    issues.push({
+                        code: 'EXPIRY_REQUIRED',
+                        message: 'Choose an expiry.',
+                    });
+                if ((options.maxGasPerCall ?? chain.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.',
+                    });
+                readiness.push({
+                    chainNamespace: chain.chainNamespace,
+                    ready: issues.length === 0,
+                    issues,
+                    disabledCalls: limits.disabledCalls,
+                    excludedCalls: limits.excludedCalls,
+                    knownTokens: limits.knownTokens,
+                    zeroBridgeLimits: selectedAssets
+                        .filter((a) => a.maxPerCall === BigInt(0) || a.maxTotal === BigInt(0))
+                        .map(operation_limits_1.assetAddress),
+                });
                 return {
                     chainNamespace: chain.chainNamespace,
                     allowedCalls: calls,
@@ -175,12 +331,20 @@ function buildPresetApi(catalog) {
                     ...(options.assets !== undefined
                         ? { assets: assets.get(chain.chainNamespace) ?? [] }
                         : {}),
-                    ...(chain.maxGasPerCall !== undefined
-                        ? { maxGasPerCall: cap(chain.maxGasPerCall, 'maxGasPerCall') }
+                    ...((options.maxGasPerCall ?? chain.maxGasPerCall) !== undefined
+                        ? {
+                            maxGasPerCall: cap(options.maxGasPerCall ?? chain.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.

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[];
+};