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

package/src/lib/agentic/management/common.js

@@ -25,7 +25,9 @@ async function assertOwner(runtime, gen, wallet, snap) {
     const owner = (0, viem_1.getAddress)(await snap.read(wallet, gen.contracts.abis.wallet, 'owner'));
     const signer = runtime.signerPushAccount();
     if (owner !== signer) {
-        throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.NOT_WALLET_OWNER, `${signer} is not the owner of ${wallet} (owner is ${owner})`, { hint: 'Rule and label writes are owner-only. Initialize with the owner signer.' });
+        throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.NOT_WALLET_OWNER, `${signer} is not the owner of ${wallet} (owner is ${owner})`, {
+            hint: 'Rule and label writes are owner-only. Initialize with the owner signer.',
+        });
     }
     return owner;
 }
@@ -66,7 +68,7 @@ async function confirmedLogs(runtime, tx) {
     if (hashes.length === 1) {
         if (receipt.status !== 1) {
             throw new errors_2.AgenticRevertError(`Push transaction ${tx.hash} reverted`, {
-                transactionHashes: hashes,
+                cause: { txHash: tx.hash },
             });
         }
         return { logs: receipt.logs, hashes };
@@ -81,7 +83,9 @@ async function confirmedLogs(runtime, tx) {
             throw unavailable(cause);
         }
         if (r.status !== 'success') {
-            throw new errors_2.AgenticRevertError(`Push transaction ${hash} reverted`, { transactionHashes: hashes });
+            throw new errors_2.AgenticRevertError(`Push transaction ${hash} reverted`, {
+                cause: { txHash: hash },
+            });
         }
         logs.push(...r.logs);
     }
@@ -95,8 +99,6 @@ function wrapSendError(err) {
     if (err instanceof errors_1.PushChainBatchExecutionError) {
         return new errors_2.AgenticRevertError(err.message, {
             decodedError: decoded ?? err.decodedError,
-            transactionHashes: err.transactionHashes,
-            pendingTransactionHash: err.pendingTransactionHash,
             cause: err,
         });
     }

package/src/lib/agentic/management/create.d.ts

@@ -1,16 +1,4 @@
 import type { AgenticRuntime } from '../runtime';
 import type { InternalCreateOptions, CreateResult } from '../agentic.types';
-/**
- * client.agentic.create(label, { rules }): deploy + grants only. Funding and
- * approvals are separate ordinary sends. Every input is validated and every
- * prediction re-read immediately before signing; IDs are returned from
- * receipts in input order.
- *
- * Strategy follows the signer: an external owner's UEA batches atomically, a
- * Push EOA uses an EIP-7702 batch when available and otherwise the documented
- * sequential fallback. A sequential failure raises CREATE_PARTIAL with the
- * deployed wallet, confirmed/pending hashes and granted IDs so the caller can
- * finish with `wallet(w).rules.add(remaining)` — the SDK never deploys another
- * wallet on its own.
- */
+/** One index-bound v6 factory call deploys and grants atomically for EOA/UEA owners. */
 export declare function createWallet(runtime: AgenticRuntime, label: string, options: InternalCreateOptions): Promise<CreateResult>;

package/src/lib/agentic/management/create.js

@@ -4,34 +4,21 @@ exports.createWallet = createWallet;
 const duplicates_1 = require("./duplicates");
 const viem_1 = require("viem");
 const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
-const errors_1 = require("../../orchestrator/internals/errors");
 const capabilities_1 = require("../capabilities");
 const deployments_1 = require("../deployments");
 const ids_1 = require("../codec/ids");
 const prepare_1 = require("./prepare");
 const label_1 = require("./label");
-const errors_2 = require("../errors");
+const errors_1 = require("../errors");
 const snapshot_1 = require("../reads/snapshot");
 const wallets_1 = require("../reads/wallets");
 const common_1 = require("./common");
-/**
- * client.agentic.create(label, { rules }): deploy + grants only. Funding and
- * approvals are separate ordinary sends. Every input is validated and every
- * prediction re-read immediately before signing; IDs are returned from
- * receipts in input order.
- *
- * Strategy follows the signer: an external owner's UEA batches atomically, a
- * Push EOA uses an EIP-7702 batch when available and otherwise the documented
- * sequential fallback. A sequential failure raises CREATE_PARTIAL with the
- * deployed wallet, confirmed/pending hashes and granted IDs so the caller can
- * finish with `wallet(w).rules.add(remaining)` — the SDK never deploys another
- * wallet on its own.
- */
+/** One index-bound v6 factory call deploys and grants atomically for EOA/UEA owners. */
 async function createWallet(runtime, label, options) {
     const hook = options?.progressHook;
     (0, label_1.assertLabel)(label);
     if (!options || !Array.isArray(options.rules)) {
-        throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INVALID_RULE, 'options.rules is required (use [] for a bare wallet)');
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'options.rules is required (use [] for a bare wallet)');
     }
     (0, common_1.assertCanSign)(runtime, 'agentic.create');
     const gen = (0, deployments_1.currentGeneration)(runtime.network);
@@ -49,13 +36,13 @@ async function createWallet(runtime, label, options) {
         index,
     });
     if (wallet !== mirror || deployed || (await snap.code(wallet))) {
-        throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INDEX_RACE, `next wallet slot ${index} for ${owner} is not a fresh counterfactual address`, { details: { wallet, mirror, deployed } });
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INDEX_RACE, `next wallet slot ${index} for ${owner} is not a fresh counterfactual address`, { details: { wallet, mirror, deployed } });
     }
     const prepared = await (0, prepare_1.prepareWalletRules)(runtime, gen, owner, wallet, options.rules, snap);
     (0, duplicates_1.assertNoDuplicateRules)(prepared);
     const selfTarget = prepared.findIndex((p) => p.nativeTerms?.some((t) => t.target === wallet));
     if (selfTarget >= 0) {
-        throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INVALID_RULE, `rules[${selfTarget}].target is the wallet being created; the contracts refuse it as a native target`);
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `rules[${selfTarget}].target is the wallet being created; the contracts refuse it as a native target`);
     }
     (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_101, wallet, Number(index), false);
     // A fresh wallet's grant nonce starts at 0 and increments per grant.
@@ -64,31 +51,22 @@ async function createWallet(runtime, label, options) {
         agent: p.agent,
         grantNonce: BigInt(i),
     }));
+    if (prepared.length > 8)
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'create accepts at most eight initial rules');
     const calls = [
-        // Index-bound: reverts (nothing committed) if another creation took this slot.
         {
             to: gen.addresses.factory,
             value: BigInt(0),
-            data: gen.contracts.encodeDeployWalletAt(owner, index, wallet, label),
+            data: gen.contracts.encodeCreateWalletAt(owner, index, wallet, label, prepared.map((p) => p.session)),
         },
-        ...prepared.map((p) => ({
-            to: wallet,
-            value: BigInt(0),
-            data: gen.contracts.encodeGrantRules(p.session),
-        })),
     ];
-    const strategy = calls.length === 1
-        ? 'single'
-        : runtime.signerIsPushNative()
-            ? 'push-eoa-batch'
-            : 'uea-multicall';
-    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_102, wallet, strategy);
+    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_102, wallet, 'single');
     let tx;
     try {
         tx = await (0, common_1.sendOwnerCalls)(runtime, calls, hook);
     }
     catch (err) {
-        const wrapped = await createFailure(runtime, gen, wallet, Number(index), owner, label, err);
+        const wrapped = atomicCreateFailure(err);
         emitFailure(runtime, hook, wrapped);
         throw wrapped;
     }
@@ -97,7 +75,7 @@ async function createWallet(runtime, label, options) {
         ({ logs } = await (0, common_1.confirmedLogs)(runtime, tx));
     }
     catch (err) {
-        const wrapped = await createFailure(runtime, gen, wallet, Number(index), owner, label, err);
+        const wrapped = atomicCreateFailure(err);
         emitFailure(runtime, hook, wrapped);
         throw wrapped;
     }
@@ -108,9 +86,9 @@ async function createWallet(runtime, label, options) {
     if (deployedEv.length !== 1 ||
         deployedEv[0].wallet !== wallet ||
         deployedEv[0].index !== index) {
-        const err = new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INDEX_RACE, `deployWallet produced ${deployedEv.map((d) => `${d.wallet}#${d.index}`).join(', ') ||
+        const err = new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.RECEIPT_MISMATCH, `createWallet produced ${deployedEv.map((d) => `${d.wallet}#${d.index}`).join(', ') ||
             'no wallet'}, expected ${wallet}#${index}; grants targeted ${wallet}`, {
-            hint: 'Another deployment by this owner raced this call. Inspect both wallets with client.agentic.list() before retrying.',
+            hint: 'The receipt does not describe the requested atomic creation. Inspect the submitted hash before retrying.',
             details: {
                 expected: wallet,
                 deployed: deployedEv,
@@ -122,7 +100,7 @@ async function createWallet(runtime, label, options) {
         throw err;
     }
     if (!sameIds(granted, predictedIds)) {
-        const err = new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.RECEIPT_MISMATCH, 'RulesGranted events do not match the requested rules in order', { details: { granted, predicted: predictedIds, txHash: tx.hash } });
+        const err = new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.RECEIPT_MISMATCH, 'RulesGranted events do not match the requested rules in order', { details: { granted, predicted: predictedIds, txHash: tx.hash } });
         emitFailure(runtime, hook, err);
         throw err;
     }
@@ -140,129 +118,18 @@ function sameIds(a, b) {
     return (a.length === b.length &&
         a.every((x, i) => x.toLowerCase() === b[i].toLowerCase()));
 }
-const RACE_ERRORS = new Set(['IndexMismatch', 'IntentWalletMismatch']);
-/**
- * Turn a create failure into an exact report. What committed is derived from
- * THIS operation's own receipts, never from a later state read; when those
- * receipts cannot be fetched the outcome is reported as unknown so callers do
- * not retry a creation that may have landed.
- */
-async function createFailure(runtime, gen, wallet, index, owner, label, err) {
-    const wrapped = (0, common_1.wrapSendError)(err);
-    const batch = err instanceof errors_1.PushChainBatchExecutionError ? err : undefined;
-    const confirmed = (batch?.transactionHashes ?? []);
-    const pending = batch?.pendingTransactionHash;
-    const receiptUnavailable = wrapped instanceof errors_2.AgenticError &&
-        wrapped.code === errors_2.AGENTIC_ERROR_CODE.RECEIPT_UNAVAILABLE;
-    // The index-bound deploy reverted: another creation took the slot first and
-    // nothing from this call committed.
-    const decodedName = wrapped
-        .decodedError?.name;
-    if (confirmed.length === 0 &&
-        !pending &&
-        decodedName &&
-        RACE_ERRORS.has(decodedName)) {
-        return new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INDEX_RACE, `wallet slot ${index} (${wallet}) was taken by a concurrent creation; nothing was committed`, {
-            hint: 'Retry agentic.create; it re-reads the next slot.',
-            details: { wallet, index, committed: false },
+function atomicCreateFailure(error) {
+    const wrapped = (0, common_1.wrapSendError)(error);
+    if (['IndexMismatch', 'IntentWalletMismatch'].includes(wrapped?.decodedError?.name ?? ''))
+        return new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INDEX_RACE, 'the predicted wallet slot changed; atomic creation committed nothing', {
             cause: wrapped,
+            details: {
+                committed: false,
+                walletDeployed: false,
+                grantedRulesIds: [],
+            },
         });
-    }
-    if (confirmed.length === 0 && !pending && !receiptUnavailable) {
-        // Some send paths flatten the factory revert to a generic execution
-        // error, losing the IndexMismatch selector. If the owner's next index has
-        // moved and immutable deployment metadata proves another label owns the
-        // predicted slot, this call could not have deployed or granted.
-        try {
-            const snap = await snapshot_1.Snapshot.at(runtime.reader);
-            const next = await (0, wallets_1.walletCount)(snap, gen, owner);
-            if (next > BigInt(index)) {
-                const competing = await (0, wallets_1.walletInfo)(runtime.reader, gen, wallet);
-                // label() is mutable in v5: only the immutable deploy event proves
-                // which creation occupied this slot. A later rename proves nothing.
-                const logs = await (0, snapshot_1.scanLogs)(runtime.reader, {
-                    address: gen.addresses.factory,
-                    event: gen.contracts.events.walletDeployed,
-                    args: { wallet },
-                }, gen.startBlock, snap.blockNumber);
-                const deployed = gen.contracts
-                    .parseWalletDeployed(logs, gen.addresses.factory)
-                    .find((entry) => entry.wallet === wallet);
-                const competingLabel = deployed?.label;
-                if (competing.deployed &&
-                    competing.index === index &&
-                    (0, viem_1.getAddress)(competing.owner) === owner &&
-                    competingLabel !== undefined &&
-                    competingLabel !== label) {
-                    return new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.INDEX_RACE, 'wallet slot ' + index + ' was consumed by a concurrent deployment', {
-                        hint: 'Slot ' +
-                            index +
-                            ' belongs to "' +
-                            competingLabel +
-                            '". No wallet or rules from this create call were committed; retry agentic.create to use the next slot.',
-                        details: {
-                            wallet,
-                            index,
-                            committed: false,
-                            competingLabel,
-                        },
-                        cause: wrapped,
-                    });
-                }
-            }
-        }
-        catch {
-            // If the owner counter/event cannot be reconciled, preserve the original
-            // error; never infer that a retry is safe from an incomplete read.
-        }
-        // Nothing was confirmed (pre-broadcast failure or a reverted atomic batch).
-        return wrapped;
-    }
-    let walletDeployed = 'unknown';
-    let grantedRulesIds;
-    let recoveryError;
-    if (!receiptUnavailable) {
-        try {
-            const logs = [];
-            for (const hash of confirmed) {
-                const r = await runtime.reader.getTransactionReceipt({ hash });
-                if (r.status === 'success')
-                    logs.push(...r.logs);
-            }
-            const deployed = gen.contracts
-                .parseWalletDeployed(logs, gen.addresses.factory)
-                .some((d) => d.wallet === wallet);
-            grantedRulesIds = gen.contracts
-                .parseRulesGranted(logs, wallet)
-                .map((g) => g.rulesId);
-            // A pending hash may itself be the deployment; only a confirmed deploy is certain.
-            walletDeployed = deployed ? true : pending ? 'unknown' : false;
-        }
-        catch (e) {
-            recoveryError = e instanceof Error ? e.message : String(e);
-        }
-    }
-    const hint = walletDeployed === true
-        ? `Wallet ${wallet} is deployed. Do not call create again; once any pending hash settles, finish with client.agentic.wallet('${wallet}').rules.add(<remaining rules>).`
-        : walletDeployed === false
-            ? 'No wallet was deployed by this call; it is safe to retry.'
-            : 'The outcome is unknown. Do not retry create until the listed hashes are reconciled (client.agentic.list() shows deployed wallets).';
-    return new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.CREATE_PARTIAL, `agentic.create did not complete: ${wrapped?.message ?? String(err)}`, {
-        hint,
-        details: {
-            wallet,
-            index,
-            walletDeployed,
-            grantedRulesIds,
-            confirmedHashes: confirmed,
-            pendingHash: pending,
-            ...(receiptUnavailable
-                ? { submitted: wrapped.details }
-                : {}),
-            ...(recoveryError ? { recoveryError } : {}),
-        },
-        cause: wrapped,
-    });
+    return wrapped;
 }
 function emitFailure(runtime, hook, err) {
     const e = err;

package/src/lib/agentic/management/svm.js

@@ -13,7 +13,7 @@ const common_1 = require("./common");
 const svm_terms_1 = require("../codec/svm-terms");
 const session_1 = require("../codec/session");
 const ids_1 = require("../codec/ids");
-const v5_1 = require("../contracts/v5");
+const v6_1 = require("../contracts/v6");
 const svm_accounts_1 = require("../codec/svm-accounts");
 const errors_1 = require("../errors");
 const prc20_metadata_1 = require("../contracts/prc20-metadata");
@@ -45,7 +45,7 @@ function session(gen, wallet, owner, input, now) {
         actions: [
             {
                 target: gen.addresses.gateway,
-                selector: v5_1.SEND_OUTBOUND_SELECTOR,
+                selector: v6_1.SEND_OUTBOUND_SELECTOR,
                 initData: (0, session_1.encodeEnvelope)(input.chainNamespace, (0, svm_terms_1.encodeSvmTerms)(input.terms, now)),
             },
         ],

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

@@ -1,14 +1,20 @@
-import type { Address } from 'viem';
+import { type Address } from 'viem';
 import type { RuleCall, ForeignChainNamespace } from '../agentic.types';
 import type { PresetCategory } from './types';
 /** Internal catalog: reviewed addresses and explicit calls only; never fetched at runtime. */
 export interface PresetChainDefinition {
     chainNamespace: ForeignChainNamespace;
     allowedCalls: readonly RuleCall[];
+    /** Static single-hop routers; incomplete pairs return zero-input-cap review calls. */
+    swapRouters?: readonly {
+        address: Address;
+        app: string;
+    }[];
     /** Exact spenders that need an approval for each non-native supplied asset. */
     approvals?: readonly {
         spender: Address;
         app: string;
+        token?: Address;
     }[];
     maxGasPerCall?: bigint;
 }
@@ -17,5 +23,4 @@ export interface PresetDefinition {
     name: string;
     chains: readonly PresetChainDefinition[];
 }
-/** No approved app/address catalog yet. Empty categories must be hidden by UIs. */
 export declare const PRESET_CATALOG: readonly PresetDefinition[];

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

@@ -1,10 +1,307 @@
 "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");
+/** 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) => [
+    ['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,
+}));
+const market = (target, app) => [
+    'mint(uint256)',
+    'redeem(uint256)',
+    'redeemUnderlying(uint256)',
+    'borrow(uint256)',
+    'repayBorrow(uint256)',
+].map((selector) => ({
+    target,
+    selector: selector,
+    app,
+    label: selector.split('(')[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]) => market(address(target), app)),
+            ...(entries.length
+                ? [
+                    {
+                        target: address(controller),
+                        selector: 'enterMarkets(address[])',
+                        app: chain === 'eip155:8453' ? 'Moonwell' : 'Venus',
+                        label: 'Enter markets',
+                    },
+                ]
+                : []),
+        ],
+        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)),
+                    ...mainnetMarkets(chainNamespace).allowedCalls,
+                ],
+                approvals: [
+                    { spender: address(pool), app: 'Aave V3' },
+                    ...(mainnetMarkets(chainNamespace).approvals ?? []),
+                ],
+            })),
+            {
+                chainNamespace: 'eip155:11155111',
+                allowedCalls: aave(sepoliaPool),
+                approvals: [{ spender: sepoliaPool, app: 'Aave V3' }],
+            },
+            {
+                chainNamespace: 'eip155:421614',
+                allowedCalls: aave(arbitrumPool),
+                approvals: [{ spender: arbitrumPool, app: 'Aave V3' }],
+            },
+            {
+                chainNamespace: 'eip155:84532',
+                allowedCalls: [
+                    ...aave(basePool),
+                    ...market(moonUSDBC, 'Moonwell mUSDbC'),
+                    ...market(moonWETH, 'Moonwell mWETH'),
+                    {
+                        target: address('0xC72ba45f2Ae134F21DAEb2b7B5fd5De0064Ee9bB'),
+                        selector: 'enterMarkets(address[])',
+                        app: 'Moonwell',
+                        label: 'Enter markets',
+                    },
+                ],
+                approvals: [
+                    { spender: basePool, app: 'Aave V3' },
+                    {
+                        spender: moonUSDBC,
+                        app: 'Moonwell mUSDbC',
+                        token: address('0x4616975f7E6045FD9737e95bC527e9e14c727BD2'),
+                    },
+                    {
+                        spender: moonWETH,
+                        app: 'Moonwell mWETH',
+                        token: address('0x663A6F02d547dFd639BF689FED298712f2FB69Fb'),
+                    },
+                ],
+            },
+            {
+                chainNamespace: 'eip155:97',
+                allowedCalls: [
+                    ...market(venusUSDT, 'Venus vUSDT'),
+                    ...market(venusUSDC, 'Venus vUSDC'),
+                    {
+                        target: address('0x94d1820b2D1c7c7452A163983Dc888CEC546b77D'),
+                        selector: 'enterMarkets(address[])',
+                        app: 'Venus',
+                        label: 'Enter markets',
+                    },
+                ],
+                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 (set an explicit value cap)',
+                    },
+                    {
+                        target: wstETH,
+                        selector: 'wrap(uint256)',
+                        app: 'Lido wstETH',
+                        label: 'Wrap stETH',
+                    },
+                    {
+                        target: wstETH,
+                        selector: 'unwrap(uint256)',
+                        app: 'Lido wstETH',
+                        label: 'Unwrap wstETH',
+                    },
+                    {
+                        target: lidoQueue,
+                        selector: 'requestWithdrawals(uint256[],address)',
+                        pins: [{ arg: 1, expected: wallet }],
+                        app: 'Lido withdrawal queue',
+                        label: 'Request withdrawal',
+                    },
+                    {
+                        target: lidoQueue,
+                        selector: 'claimWithdrawals(uint256[],uint256[])',
+                        app: 'Lido withdrawal queue',
+                        label: 'Claim finalized withdrawals',
+                    },
+                    {
+                        target: lidoQueue,
+                        selector: 'claimWithdrawal(uint256)',
+                        app: 'Lido withdrawal queue',
+                        label: 'Claim finalized withdrawal',
+                    },
+                    {
+                        target: address('0x858646372CC42E1A627fcE94aa7A7033e7CF075A'),
+                        selector: 'depositIntoStrategy(address,address,uint256)',
+                        app: 'EigenLayer',
+                        label: 'Deposit into strategy (withdrawals not included)',
+                    },
+                ],
+                approvals: [
+                    { spender: wstETH, token: stETH, app: 'Lido wstETH' },
+                    { spender: lidoQueue, token: stETH, app: 'Lido withdrawal queue' },
+                    {
+                        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)',
+                    },
+                ],
+                approvals: [{ spender: eigen, app: 'EigenLayer' }],
+            },
+        ],
+    },
     { constant: 'PREDICTION', name: 'Prediction markets', chains: [] },
 ];
 //# sourceMappingURL=catalog.js.map