@pushchain/core 6.0.26 → 6.0.27-alpha.1

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySvmWallet = verifySvmWallet;
+exports.grantSvmWire = grantSvmWire;
+exports.prepareSvmReplacement = prepareSvmReplacement;
+exports.replaceSvmWire = replaceSvmWire;
+/** Internal explicit-wire operations. Not exported by the SDK entry point. */
+const viem_1 = require("viem");
+const deployments_1 = require("../deployments");
+const snapshot_1 = require("../reads/snapshot");
+const svm_1 = require("../reads/svm");
+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 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");
+async function verifyAssets(snap, input) {
+    if (!/^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(input.chainNamespace))
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'SVM chain must be a full Solana CAIP-2 namespace');
+    for (const cap of input.terms.assets) {
+        if ((await snap.read(cap.token, prc20_metadata_1.PRC20_SOURCE_ABI, 'SOURCE_CHAIN_NAMESPACE')) !== input.chainNamespace)
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.ASSET_CHAIN_MISMATCH, 'SVM asset source-chain mismatch');
+    }
+}
+async function verifySvmWallet(runtime, gen, wallet) {
+    const actual = await (0, deployments_1.resolveWalletGeneration)(runtime.reader, runtime.network, wallet);
+    if (actual.addresses.factory !== gen.addresses.factory)
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.CAPABILITY_UNAVAILABLE, 'SVM wallet generation mismatch');
+    await (0, deployments_1.verifyPolicyVersion)(runtime.reader, gen);
+}
+function session(gen, wallet, owner, input, now) {
+    const agent = (0, viem_1.getAddress)(input.agent);
+    if (agent === owner)
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.AGENT_IS_OWNER, 'agent must differ from owner');
+    const cea = (0, svm_accounts_1.deriveAgwSvmCea)(wallet, input.terms.gatewayProgram).address;
+    if (cea.toLowerCase() !== input.terms.expectedCEA.toLowerCase())
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'SVM expectedCEA does not belong to this wallet/gateway');
+    return (0, session_1.buildSession)({
+        validator: gen.addresses.sessionValidator,
+        rulesPolicy: gen.addresses.rulesPolicy,
+        agent,
+        actions: [
+            {
+                target: gen.addresses.gateway,
+                selector: v6_1.SEND_OUTBOUND_SELECTOR,
+                initData: (0, session_1.encodeEnvelope)(input.chainNamespace, (0, svm_terms_1.encodeSvmTerms)(input.terms, now)),
+            },
+        ],
+    });
+}
+async function grantSvmWire(runtime, gen, wallet, input) {
+    (0, common_1.assertCanSign)(runtime, 'internal SVM grant');
+    await verifySvmWallet(runtime, gen, wallet);
+    const snap = await snapshot_1.Snapshot.at(runtime.reader);
+    const owner = await (0, common_1.assertOwner)(runtime, gen, wallet, snap);
+    await verifyAssets(snap, input);
+    const s = session(gen, wallet, owner, input, runtime.nowSeconds());
+    const nonce = await snap.read(wallet, gen.contracts.abis.wallet, 'grantNonce');
+    const expected = (0, ids_1.rulesId)({
+        validator: gen.addresses.sessionValidator,
+        agent: (0, viem_1.getAddress)(input.agent),
+        grantNonce: nonce,
+    });
+    let tx;
+    try {
+        tx = await runtime.execute({
+            to: wallet,
+            value: BigInt(0),
+            data: gen.contracts.encodeGrantRules(s),
+        });
+    }
+    catch (error) {
+        throw (0, common_1.wrapSendError)(error);
+    }
+    const { logs } = await (0, common_1.confirmedLogs)(runtime, tx);
+    const granted = gen.contracts.parseRulesGranted(logs, wallet);
+    if (granted.length !== 1 ||
+        granted[0].mode !== 0 ||
+        granted[0].chainNamespace !== input.chainNamespace)
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.RECEIPT_MISMATCH, 'SVM grant receipt did not match this operation', { details: { txHash: tx.hash, expected } });
+    // Another owner grant can advance grantNonce between read and inclusion.
+    // The sole matching event from this receipt is the authoritative ID.
+    return { rulesId: granted[0].rulesId, tx };
+}
+/** Snapshot -> all-asset assertion -> revoke -> grant. No sequential fallback. */
+async function prepareSvmReplacement(runtime, gen, wallet, oldId, input) {
+    (0, common_1.assertCanSign)(runtime, 'internal SVM replacement');
+    await verifySvmWallet(runtime, gen, wallet);
+    const snap = await snapshot_1.Snapshot.at(runtime.reader);
+    const owner = await (0, common_1.assertOwner)(runtime, gen, wallet, snap);
+    await verifyAssets(snap, input);
+    const old = await (0, svm_1.readSvmRule)(snap, gen, wallet, oldId, runtime.pushChainNamespace);
+    const s = session(gen, wallet, owner, input, runtime.nowSeconds());
+    const nonce = await snap.read(wallet, gen.contracts.abis.wallet, 'grantNonce');
+    const rulesId = (0, ids_1.rulesId)({
+        validator: gen.addresses.sessionValidator,
+        agent: (0, viem_1.getAddress)(input.agent),
+        grantNonce: nonce,
+    });
+    const calls = [
+        {
+            target: gen.addresses.rulesPolicy,
+            value: BigInt(0),
+            data: gen.contracts.encodeAssertSpentUniversal(old.configId, wallet, old.config.assets.map((a) => a.spent)),
+        },
+        {
+            target: wallet,
+            value: BigInt(0),
+            data: gen.contracts.encodeRevokeRules(oldId),
+        },
+        {
+            target: wallet,
+            value: BigInt(0),
+            data: gen.contracts.encodeGrantRules(s),
+        },
+    ];
+    return {
+        rulesId,
+        oldId,
+        snapshotBlock: snap.blockNumber,
+        data: gen.contracts.encodeExecute(calls),
+    };
+}
+async function replaceSvmWire(runtime, gen, wallet, oldId, input) {
+    const prepared = await prepareSvmReplacement(runtime, gen, wallet, oldId, input);
+    let tx;
+    try {
+        tx = await runtime.execute({
+            to: wallet,
+            value: BigInt(0),
+            data: prepared.data,
+        });
+    }
+    catch (error) {
+        throw (0, common_1.wrapSendError)(error);
+    }
+    const { logs } = await (0, common_1.confirmedLogs)(runtime, tx);
+    const grants = gen.contracts.parseRulesGranted(logs, wallet);
+    const revokes = gen.contracts.parseRulesRevoked(logs, wallet);
+    if (grants.length !== 1 ||
+        grants[0].mode !== 0 ||
+        grants[0].chainNamespace !== input.chainNamespace ||
+        !revokes.some((r) => r.rulesId.toLowerCase() === oldId.toLowerCase()))
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.RECEIPT_MISMATCH, 'SVM replacement receipt mismatch', { details: { txHash: tx.hash } });
+    return { rulesId: grants[0].rulesId, replaced: oldId, tx };
+}
+//# sourceMappingURL=svm.js.map

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

@@ -0,0 +1,26 @@
+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;
+}
+export interface PresetDefinition {
+    constant: PresetCategory;
+    name: string;
+    chains: readonly PresetChainDefinition[];
+}
+export declare const PRESET_CATALOG: readonly PresetDefinition[];

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESET_CATALOG = void 0;
+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: [
+            ['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

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

@@ -0,0 +1,5 @@
+import type { AgenticPresets } from './types';
+import { type PresetDefinition } from './catalog';
+/** Not a public registration API. Tests inject fixtures; production uses the bundled catalog. */
+export declare function buildPresetApi(catalog: readonly PresetDefinition[]): AgenticPresets;
+export declare const agenticPresets: AgenticPresets;