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

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**, which permits no corresponding movement. 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.
+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.
 
 ## 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 (EigenLayer withdrawals excluded); Lido stake, wrap/unwrap and withdrawal requests/claims on Ethereum mainnet. Lido ETH staking defaults to `maxValue: 0`; explicitly set a value cap before use.
+- 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.
 - PREDICTION: no entries yet. Hide categories with empty `chains` lists.
 
 ```ts
@@ -195,11 +195,11 @@ function filledPreset(agent: Address, tokenIn: Address, tokenOut: Address) {
         { token: tokenOut, maxPerCall: BigInt(100), maxTotal: BigInt(1000) },
       ],
     },
-  ).rules;
+  );
 }
 ```
 
-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. With agent and expiry supplied, its return type is `Rule[]`; otherwise it is `PresetRuleTemplate[]`, requiring those fields before `create`. 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 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.
 
 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.
 
@@ -209,6 +209,59 @@ 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.
 
+### 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.
+
+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.
+
+```ts
+async function createConfiguredDex(
+  client: PushChain, agent: Address, tokenIn: Address, tokenOut: Address,
+) {
+  const configured = filledPreset(agent, tokenIn, tokenOut);
+  if (!configured.readiness.ready) {
+    // Render these issues in the configuration screen; do not present it as ready.
+    return { issues: configured.readiness.chains };
+  }
+  return client.agentic.create('My DEX agent', { rules: configured.rules });
+}
+
+async function replaceConfiguredDex(
+  client: PushChain, wallet: Address, rulesId: Hex,
+  agent: Address, tokenIn: Address, tokenOut: Address,
+) {
+  // Re-run get after editing tokens or limits. Changing rule.assets alone
+  // does not regenerate allowedCalls, token pins or approvals.
+  const configured = filledPreset(agent, tokenIn, tokenOut);
+  if (!configured.readiness.ready) throw new Error('Complete the preset inputs');
+  return client.agentic.wallet(wallet).rules.update({
+    rules: [{ rulesId, rule: configured.rules[0] }],
+  });
+}
+```
+
+Save the preset category and editable inputs in the UI if subsequent edits should regenerate the preset. On-chain rules do not retain preset provenance or display metadata. A regenerated result is a replacement: do not append it to the old allowedCalls or keep the old token approvals. An update creates a new rulesId and resets counters, as documented above.
+
+### Amount units and enforcement scope
+
+| Preset operation | Generated restriction |
+| --- | --- |
+| DEX swap | Selected input/output token equality, wallet recipient, maximum input amount |
+| Aave supply/withdraw/borrow/repay | Listed reserve token equality, wallet beneficiary, amount maximum |
+| Moonwell/Venus mint/redeemUnderlying/borrow/repayBorrow | Maximum in the market's underlying-token units |
+| EigenLayer deposit | Selected token equality and deposit amount maximum |
+| Lido wrap/unwrap | stETH/wstETH input limits respectively; their units are not interchangeable |
+| Lido submit | Native-value cap from the selected native asset's maxPerCall |
+
+Aave reserve choices come from the reviewed official address book; fixed-token markets only enable for their actual underlying. Unknown assets do not receive an Aave approval or a positive Aave operation cap. A reserve listing is not a guarantee that its current supply cap, pause state or liquidity allows a transaction.
+
+Market `redeem(uint256)` takes shares: it is excluded and `redeemUnderlying(uint256)` is provided instead. Lido's dynamic withdrawal arrays and position-based claims are also excluded because an underlying amount cap cannot safely be converted into those arguments by this pure helper. Custom rules remain possible through the normal rule API.
+
+**A per-call limit applies to each allowed contract call, not the sum of several calls in one transaction. `maxTotal` is the cumulative Push-outbound amount, not lifetime turnover on the destination.** These statements also hold when a call's tokens are already in the CEA. Destination lifetime or batch-total accounting requires contract support. Bounded approvals do not supply such accounting.
+
+The contract allows at most 32 pins across a universal rule. Expansion fails explicitly if the selected assets/apps exceed that ceiling; no restrictions are silently dropped. Two Aave reserves fit its four-operation template; three do not. Blank/incomplete inputs return zero-cap review calls, and regeneration replaces them with the selected token-specific calls.
+
 ## Validation
 
 Run `node packages/core/scripts/check-agw-docs.js` to typecheck these examples. Unit tests use the normal core Jest configuration. `jest.agw-local.config.ts` uses pinned real AGW contracts and a stub gateway. Live E2Es are opt-in under `__e2e__/agw`; preflight verifies the deployment and funding limits. Local tests do not prove destination delivery, and historical live results do not count as validation of a changed public API.

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+@pushchain/core@6.0.27-alpha.2 (2026-10-16)
+
+- feat: add bounded preset operations and configuration readiness
+
+---
+
 @pushchain/core@6.0.27-alpha.1 (2026-10-15)
 
 - fix: resolve AGW tokens by destination and expand live coverage

package/package.json

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

package/src/lib/agentic/index.d.ts

@@ -2,4 +2,4 @@ export type { AgenticAddress, AgenticHex, AgenticDoor, AgenticNamespace, Agentic
 export { AGENTIC_ERROR_CODE, AgenticError, AgenticRevertError } from './errors';
 export type { AgenticErrorCode } from './errors';
 export { AGENTIC } from './constants';
-export type { Preset, PresetCategory, PresetAsset, PresetOptions, ReadyPresetOptions, PresetRuleTemplate, AgenticPresets, } from './presets/types';
+export type { Preset, PresetCategory, PresetAsset, PresetOptions, ReadyPresetOptions, PresetRuleTemplate, PresetResult, PresetChainReadiness, PresetConfigurationIssue, PresetCallIssue, AgenticPresets, } from './presets/types';

package/src/lib/agentic/presets/aave-reserves.d.ts

@@ -0,0 +1,4 @@
+/** Aave V3 reserve addresses from the official bgd-labs/aave-address-book
+ * snapshots reviewed October 15, 2026. Listings are not liquidity/availability guarantees. */
+import type { Address } from 'viem';
+export declare const AAVE_RESERVES: Readonly<Record<string, readonly Address[]>>;

package/src/lib/agentic/presets/aave-reserves.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AAVE_RESERVES = void 0;
+exports.AAVE_RESERVES = {
+    'eip155:1': [
+        '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+        '0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0',
+        '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
+        '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+        '0x6B175474E89094C44Da98b954EedeAC495271d0F',
+        '0x514910771AF9Ca656af840dff83E8264EcF986CA',
+        '0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9',
+        '0xBe9895146f7AF43049ca1c1AE358B0541Ea49704',
+        '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+        '0xae78736Cd615f374D3085123A210448E74Fc6393',
+        '0x5f98805A4E8be255a32880FDeC7F6728C6568bA0',
+        '0xD533a949740bb3306d119CC777fa900bA034cd52',
+        '0x9f8F72aA9304c8B593d555F12eF6589cC3A579A2',
+        '0xC011a73ee8576Fb46F5E1c5751cA3B9Fe0af2a6F',
+        '0xba100000625a3754423978a60c9317c58a424e3D',
+        '0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984',
+        '0x5A98FcBEA516Cf06857215779Fd812CA3beF1B32',
+        '0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72',
+        '0x111111111117dC0aa78b770fA6A738034120C302',
+        '0x853d955aCEf822Db058eb8505911ED77F175b99e',
+        '0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f',
+        '0xD33526068D116cE69F19A9ee46F0bd304F21A51f',
+        '0x83F20F44975D03b1b09e64809B757c47f942BEeA',
+        '0xAf5191B0De278C7286d6C7CC6ab6BB8A73bA2Cd6',
+        '0xdeFA4e8a7bcBA345F687a2f1456F5Edd9CE97202',
+        '0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0',
+        '0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E',
+        '0x6c3ea9036406852006290770BEdFcAbA0e23A0e8',
+        '0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee',
+        '0xf1C9acDc66974dFB6dEcB12aA385b9cD01190E38',
+        '0x4c9EDD5852cd905f086C759E8383e09bff1E68B3',
+        '0xA35b1B31Ce002FBF2058D22F30f95D405200A15b',
+        '0x9D39A5DE30e57443BfF2A8307A4256c8797A3497',
+        '0x18084fbA666a33d37592fA2633fD49a74DD93a88',
+        '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+        '0xdC035D45d973E3EC169d2276DDab16f1e407384F',
+        '0xA1290d69c65A6Fe4DF752f95823fae25cB99e5A7',
+        '0x8236a87084f8B84306f72007F36F2618A5634494',
+        '0x657e8C867D8B37dCC18fA4Caead9C45EB088C642',
+        '0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD',
+        '0x50D2C7992b802Eef16c04FeADAB310f31866a545',
+        '0x3b3fB9C57858EF816833dC91565EFcd85D96f634',
+        '0xC139190F447e929f090Edeb554D95AbB8b18aC1C',
+        '0x917459337CaAC939D41d7493B3999f571D20D667',
+        '0x14Bdc3A3AE09f5518b923b69489CBcAfB238e617',
+        '0x90D2af7d622ca3141efA4d8f1F24d86E5974Cc8F',
+        '0xC96dE26018A54D51c097160568752c4E3BD6C364',
+        '0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c',
+        '0x9F56094C450763769BA0EA9Fe2876070c0fD5F77',
+        '0xBC6736d346a5eBC0dEbc997397912CD9b8FAe10a',
+        '0xD11c452fc99cF405034ee446803b6F6c1F6d5ED8',
+        '0xbf5495Efe5DB9ce00f80364C8B423567e58d2110',
+        '0x68749665FF8D2d112Fa859AA293F07A622782F38',
+        '0xe6A934089BBEe34F832060CE98848359883749B3',
+        '0x62C6E813b9589C3631Ba0Cdb013acdB8544038B7',
+        '0x1F84a51296691320478c98b8d77f2Bbd17D34350',
+        '0xE8483517077afa11A9B07f849cee2552f040d7b2',
+        '0xacA92E438df0B2401fF60dA7E4337B687a2435DA',
+        '0x356B8d89c1e1239Cbbb9dE4815c39A1474d5BA7D',
+        '0xe343167631d89B6Ffc58B88d6b7fB0228795491D',
+        '0xAeBf0Bb9f57E89260d57f31AF34eB58657d96Ce0',
+        '0x3de0ff76E8b528C092d47b9DaC775931cef80F49',
+        '0x9Bf45ab47747F4B4dD09B3C2c73953484b4eB375',
+        '0xB0F70C0bD6FD87dbEb7C10dC692a2a6106817072',
+        '0x619D75E3b790eBC21c289f2805Bb7177A7D732E2',
+        '0x9db38D74a0D29380899aD354121DfB521aDb0548',
+        '0x59bC9FaE5D62B19d4f8d07D758047aCb9EE19d34',
+    ],
+    'eip155:8453': [
+        '0x4200000000000000000000000000000000000006',
+        '0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22',
+        '0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA',
+        '0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452',
+        '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+        '0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A',
+        '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+        '0x2416092f143378750bb29b79eD961ab195CcEea5',
+        '0x6Bb7a212910682DCFdbd5BCBb3e28FB4E8da10Ee',
+        '0xEDfa23602D0EC14714057867A78d01e94176BEA0',
+        '0xecAc9C5F704e954931349Da37F60E39f515c11c1',
+        '0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42',
+        '0x63706e401c06ac8513145b7687A14804d17f814b',
+        '0x236aa50979D5f3De3Bd1Eeb40E81137F22ab794b',
+        '0x660975730059246A68521a3e2FBD4740173100f5',
+    ],
+    'eip155:42161': [
+        '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1',
+        '0xf97f4df75117a78c1A5a0DBb814Af92458539FB4',
+        '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
+        '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f',
+        '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+        '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9',
+        '0xba5DdD1f9d7F570dc94a51479a000E3BCE967196',
+        '0xD22a58f79e9481D1a88e00c343885A588b34b68B',
+        '0x5979D7b546E38E414F7E9822514be443A4800529',
+        '0x3F56e0c36d275367b8C502090EDF38289b3dEa0d',
+        '0xEC70Dcb4A1EFa46b8F2D97C310C9c4790ba5ffA8',
+        '0x93b346b6BC2548dA6A1E7d98E9a421B42541425b',
+        '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        '0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F',
+        '0x912CE59144191C1204E64559FE8253a0e49E6548',
+        '0x35751007a407ca6FEFfE80b3cB397736D2cf4dbe',
+        '0x7dfF72693f6A4149b17e7C6314655f6A9F7c8B33',
+        '0x2416092f143378750bb29b79eD961ab195CcEea5',
+        '0x4186BFC76E2E237523CBC30FD220FE055156b41F',
+        '0x6c84a8f1c29108F47a79964b5Fe888D4f4D0dE40',
+    ],
+    'eip155:56': [
+        '0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82',
+        '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c',
+        '0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c',
+        '0x2170Ed0880ac9A755fd29B2688956BD959F933F8',
+        '0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d',
+        '0x55d398326f99059fF775485246999027B3197955',
+        '0xc5f0f7b66764F6ec8C8Dff7BA683102295E16409',
+        '0x26c5e01524d2E6280A48F2c50fF6De7e52E9611C',
+    ],
+    'eip155:11155111': [
+        '0xFF34B3d4Aee8ddCd6F9AFFFB6Fe49bD371b8a357',
+        '0xf8Fb3713D459D7C1018BD0A49D19b4C44290EBE5',
+        '0x94a9D9AC8a22534E3FaCa9F4e7F2E2cf85d5E4C8',
+        '0x29f2D40B0605204364af54EC677bD022dA425d03',
+        '0xC558DBdd856501FCd9aaF1E62eae57A9F0629a3c',
+        '0xaA8E23Fb1079EA71e0a56F48a2aA51851D8433D0',
+        '0x88541670E55cC00bEEFD87eB59EDd1b7C511AC9a',
+        '0x6d906e526a4e2Ca02097BA9d0caA3c382F52278E',
+        '0xc4bF5CbDaBE595361438F8c6a187bDc330539c60',
+    ],
+    'eip155:84532': [
+        '0xba50Cd2A20f6DA35D788639E581bca8d0B5d4D5f',
+        '0x0a215D8ba66387DCA84B284D18c3B4ec3de6E54a',
+        '0x54114591963CF60EF3aA63bEfD6eC263D98145a4',
+        '0x4200000000000000000000000000000000000006',
+        '0xD171b9694f7A2597Ed006D41f7509aaD4B485c4B',
+        '0x810D46F9a9027E28F9B01F75E2bdde839dA61115',
+    ],
+    'eip155:421614': [
+        '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d',
+        '0x1dF462e2712496373A347f8ad10802a5E95f053D',
+    ],
+};
+//# sourceMappingURL=aave-reserves.js.map

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

@@ -1,10 +1,31 @@
 import { type Address } from 'viem';
 import type { RuleCall, ForeignChainNamespace } from '../agentic.types';
 import type { PresetCategory } from './types';
+export type PresetBudget = {
+    kind: 'token-argument';
+    tokenArg: number;
+    amountArg: number;
+    tokens?: readonly Address[];
+} | {
+    kind: 'fixed-token';
+    token: Address;
+    amountArg: number;
+} | {
+    kind: 'native-value';
+} | {
+    kind: 'setup';
+} | {
+    kind: 'unsupported';
+    reason: 'SHARE_AMOUNT' | 'DYNAMIC_AMOUNT' | 'POSITION_AMOUNT';
+    alternative?: RuleCall['selector'];
+};
+export interface PresetCallDefinition extends RuleCall {
+    budget?: PresetBudget;
+}
 /** Internal catalog: reviewed addresses and explicit calls only; never fetched at runtime. */
 export interface PresetChainDefinition {
     chainNamespace: ForeignChainNamespace;
-    allowedCalls: readonly RuleCall[];
+    allowedCalls: readonly PresetCallDefinition[];
     /** Static single-hop routers; incomplete pairs return zero-input-cap review calls. */
     swapRouters?: readonly {
         address: Address;
@@ -15,6 +36,7 @@ export interface PresetChainDefinition {
         spender: Address;
         app: string;
         token?: Address;
+        tokens?: readonly Address[];
     }[];
     maxGasPerCall?: bigint;
 }

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

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PRESET_CATALOG = void 0;
 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) => [
+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 +20,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 +38,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 +90,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 +98,7 @@ const mainnetMarkets = (chain) => {
                         selector: 'enterMarkets(address[])',
                         app: chain === 'eip155:8453' ? 'Moonwell' : 'Venus',
                         label: 'Enter markets',
+                        budget: { kind: 'setup' },
                     },
                 ]
                 : []),
@@ -155,39 +170,60 @@ exports.PRESET_CATALOG = [
             ].map(([chainNamespace, pool]) => ({
                 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' }],
+                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' }],
+                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),
-                    ...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',
@@ -203,13 +239,14 @@ exports.PRESET_CATALOG = [
             {
                 chainNamespace: '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: [
@@ -239,19 +276,22 @@ exports.PRESET_CATALOG = [
                         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 +299,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',
@@ -296,6 +339,7 @@ exports.PRESET_CATALOG = [
                         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/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) {
@@ -50,8 +51,23 @@ 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 })),
         })),
     }));
@@ -125,8 +141,14 @@ function buildPresetApi(catalog) {
                 });
                 assets.set(chain, group);
             }
+            const readiness = [];
             const rules = chains.map((chain) => {
-                const calls = chain.allowedCalls.map(copyCall);
+                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 +207,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 +235,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,6 +276,49 @@ 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 (!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,
@@ -255,7 +338,13 @@ function buildPresetApi(catalog) {
                         : {}),
                 };
             });
-            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[];
+};

package/src/lib/agentic/presets/operation-limits.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeAsset = exports.assetAddress = void 0;
+exports.applyOperationLimits = applyOperationLimits;
+const viem_1 = require("viem");
+const assetAddress = (asset) => typeof asset.token === 'string' ? asset.token : asset.token.address;
+exports.assetAddress = assetAddress;
+const nativeAsset = (asset) => (0, exports.assetAddress)(asset) === viem_1.zeroAddress ||
+    (typeof asset.token !== 'string' && asset.token.mechanism === 'native');
+exports.nativeAsset = nativeAsset;
+/** Compile reviewed protocol argument positions. No exchange-rate or share guesses. */
+function applyOperationLimits(definitions, assets) {
+    const matches = (definition) => {
+        const b = definition.budget;
+        if (!b)
+            return [];
+        if (b.kind === 'native-value')
+            return assets.filter(exports.nativeAsset);
+        if (b.kind === 'fixed-token')
+            return assets.filter((a) => !(0, exports.nativeAsset)(a) && (0, viem_1.getAddress)((0, exports.assetAddress)(a)) === (0, viem_1.getAddress)(b.token));
+        if (b.kind === 'token-argument')
+            return assets.filter((a) => !(0, exports.nativeAsset)(a) &&
+                (!b.tokens ||
+                    b.tokens.some((t) => (0, viem_1.getAddress)(t) === (0, viem_1.getAddress)((0, exports.assetAddress)(a)))));
+        return [];
+    };
+    const previewAll = !definitions.some((d) => matches(d).length > 0);
+    const calls = [];
+    const disabledCalls = [], excludedCalls = [];
+    const knownTokens = new Set();
+    let enabled = false;
+    for (const definition of definitions) {
+        const { budget, ...call } = definition;
+        if (!budget || budget.kind === 'setup') {
+            calls.push(call);
+            if (!budget)
+                enabled = true; // Non-budgeted internal fixture entries only.
+            continue;
+        }
+        const info = {
+            target: call.target,
+            selector: call.selector,
+            ...(call.app ? { app: call.app } : {}),
+        };
+        if (budget.kind === 'unsupported') {
+            excludedCalls.push({
+                ...info,
+                reason: budget.reason,
+                ...(budget.alternative ? { alternative: budget.alternative } : {}),
+            });
+            continue;
+        }
+        if (budget.kind === 'fixed-token')
+            knownTokens.add((0, viem_1.getAddress)(budget.token));
+        if (budget.kind === 'native-value')
+            knownTokens.add(viem_1.zeroAddress);
+        if (budget.kind === 'token-argument')
+            budget.tokens?.forEach((t) => knownTokens.add((0, viem_1.getAddress)(t)));
+        const selected = matches(definition);
+        if (!selected.length && !previewAll) {
+            excludedCalls.push({
+                ...info,
+                reason: 'UNSELECTED_TOKEN',
+                ...(budget.kind === 'fixed-token'
+                    ? { token: (0, viem_1.getAddress)(budget.token) }
+                    : {}),
+            });
+            continue;
+        }
+        for (const asset of selected.length ? selected : [undefined]) {
+            const maximum = asset?.maxPerCall ?? BigInt(0);
+            const pins = [...(call.pins ?? [])];
+            if (budget.kind === 'token-argument' && asset)
+                pins.push({
+                    arg: budget.tokenArg,
+                    expected: (0, viem_1.getAddress)((0, exports.assetAddress)(asset)),
+                });
+            if (budget.kind !== 'native-value')
+                pins.push({ arg: budget.amountArg, max: maximum });
+            calls.push({
+                ...call,
+                ...(pins.length ? { pins } : {}),
+                ...(budget.kind === 'native-value' ? { maxValue: maximum } : {}),
+            });
+            if (maximum > BigInt(0))
+                enabled = true;
+            else
+                disabledCalls.push({
+                    ...info,
+                    reason: asset
+                        ? 'ZERO_CAP'
+                        : assets.length
+                            ? 'UNSELECTED_TOKEN'
+                            : 'TOKEN_REQUIRED',
+                    ...(asset
+                        ? { token: (0, exports.assetAddress)(asset) }
+                        : budget.kind === 'fixed-token'
+                            ? { token: (0, viem_1.getAddress)(budget.token) }
+                            : {}),
+                });
+        }
+    }
+    return {
+        calls,
+        enabled,
+        disabledCalls,
+        excludedCalls,
+        knownTokens: [...knownTokens],
+    };
+}
+//# sourceMappingURL=operation-limits.js.map

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

@@ -1,5 +1,5 @@
 import type { Address } from 'viem';
-import type { Rule, RuleAsset, ForeignChainNamespace } from '../agentic.types';
+import type { Rule, RuleAsset, RuleCall, ForeignChainNamespace } from '../agentic.types';
 export type PresetCategory = 'DEXES' | 'LENDING' | 'STAKING' | 'PREDICTION';
 export interface Preset {
     type: 'CATEGORY';
@@ -15,8 +15,10 @@ export type PresetRuleTemplate = Omit<Rule, 'agent' | 'validUntil'> & {
 export interface PresetAsset {
     chainNamespace?: ForeignChainNamespace;
     token: RuleAsset['token'];
-    /** Omitted caps are zero, by the user's October 12 decision. */
+    /** Per allowed operation and per Push outbound, in raw token units. Omitted = 0.
+     * Does not aggregate multiple destination calls in one transaction. */
     maxPerCall?: bigint;
+    /** Cumulative Push-outbound amount only; not lifetime activity on destination-held assets. Omitted = 0. */
     maxTotal?: bigint;
 }
 export interface PresetOptions {
@@ -33,16 +35,45 @@ export interface ReadyPresetOptions extends PresetOptions {
     agent: Address;
     validUntil: number;
 }
+/** Offline configuration only: does not check deployment, reserves, balances or liquidity. */
+export interface PresetConfigurationIssue {
+    code: 'AGENT_REQUIRED' | 'EXPIRY_REQUIRED' | 'GAS_BUDGET_REQUIRED' | 'ASSETS_REQUIRED' | 'TOKEN_PAIR_REQUIRED' | 'NO_ENABLED_OPERATION';
+    message: string;
+}
+export interface PresetCallIssue {
+    target: string;
+    selector: RuleCall['selector'];
+    app?: string;
+    reason: 'TOKEN_REQUIRED' | 'ZERO_CAP' | 'UNSELECTED_TOKEN' | 'SHARE_AMOUNT' | 'DYNAMIC_AMOUNT' | 'POSITION_AMOUNT';
+    token?: string;
+    alternative?: RuleCall['selector'];
+}
+export interface PresetChainReadiness {
+    chainNamespace: ForeignChainNamespace;
+    ready: boolean;
+    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. */
+    knownTokens: string[];
+    /** Selected tokens with a zero Push-outbound budget; destination-held assets are separate. */
+    zeroBridgeLimits: string[];
+}
+export interface PresetResult<T extends PresetRuleTemplate = PresetRuleTemplate> {
+    rules: T[];
+    readiness: {
+        ready: boolean;
+        chains: PresetChainReadiness[];
+    };
+}
 export interface AgenticPresets {
     list(options?: {
         type?: 'CATEGORY';
     }): {
         presets: Preset[];
     };
-    get(preset: PresetCategory, options: ReadyPresetOptions): {
-        rules: Rule[];
-    };
-    get(preset: PresetCategory, options?: PresetOptions): {
-        rules: PresetRuleTemplate[];
-    };
+    get(preset: PresetCategory, options: ReadyPresetOptions): PresetResult<Rule>;
+    get(preset: PresetCategory, options?: PresetOptions): PresetResult;
 }

package/src/lib/index.d.ts

@@ -26,4 +26,4 @@ export type { PushChainInitializeOptions } from './push-chain/push-chain';
 export { AGENTIC_ERROR_CODE, AgenticError, AgenticRevertError, } from './agentic';
 export type { AgenticAddress, AgenticDoor, AgenticErrorCode, AgenticHex, AgenticNamespace, AgenticProgressHook, AgenticTxMetadata, AgenticWallet, AllowedCall, AssetCap, Checkpoint, CheckpointKind, CreateOptions, CreateResult, ForeignChainNamespace, DecodedSolanaRule, Rule, RuleInput, Pin, Spent, WalletMarker, ArgumentPath, RulesRecord, Selector, WalletInfo, WalletSummary, } from './agentic';
 export { PushChain };
-export type { Preset, PresetCategory, PresetAsset, PresetOptions, ReadyPresetOptions, PresetRuleTemplate, AgenticPresets, } from './agentic';
+export type { Preset, PresetCategory, PresetAsset, PresetOptions, ReadyPresetOptions, PresetRuleTemplate, PresetResult, PresetChainReadiness, PresetConfigurationIssue, PresetCallIssue, AgenticPresets, } from './agentic';