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

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,6 +1,6 @@
 import type { Address } from 'viem';
-import type { Rule, RuleAsset, ForeignChainNamespace } from '../agentic.types';
-export type PresetCategory = 'DEXES' | 'LENDING' | 'PREDICTION';
+import type { Rule, RuleAsset, RuleCall, ForeignChainNamespace } from '../agentic.types';
+export type PresetCategory = 'DEXES' | 'LENDING' | 'STAKING' | 'PREDICTION';
 export interface Preset {
     type: 'CATEGORY';
     constant: PresetCategory;
@@ -15,30 +15,65 @@ 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 {
+    /** Explicit Push-PC gas budget per outbound; omitted = zero. */
+    maxGasPerCall?: bigint;
     chainNamespace?: ForeignChainNamespace;
     agent?: Address;
     validUntil?: number;
+    /** DEX swaps with fewer than two tokens are zero-input-cap review templates.
+     * Call get again with a complete pair to generate token pins and amount limits. */
     assets?: PresetAsset[];
 }
 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/agentic/public-rule.d.ts

@@ -1,9 +1,9 @@
 import { type Address } from 'viem';
-import type { Rule, RuleInput, InternalRule } from './agentic.types';
+import type { Rule, RuleInput, InternalRule, ArgumentPath } from './agentic.types';
 import type { AgenticRuntime } from './runtime';
 export declare const WALLET: "agentic:wallet";
 /** Mark authored inputs for normalization after the wallet address is fixed. */
 export declare function publicRules(rules: readonly RuleInput[]): InternalRule[];
 export declare function isPublicRule(rule: InternalRule): boolean;
-export declare function evmPinOffset(selector: Rule['allowedCalls'][number]['selector'], arg: number): number;
+export declare function evmPinOffset(selector: Rule['allowedCalls'][number]['selector'], arg: ArgumentPath): number;
 export declare function normalizePublicRule(input: InternalRule, wallet: Address, runtime: AgenticRuntime): Promise<InternalRule>;

package/src/lib/agentic/public-rule.js

@@ -28,6 +28,7 @@ exports.publicRules = publicRules;
 exports.isPublicRule = isPublicRule;
 exports.evmPinOffset = evmPinOffset;
 exports.normalizePublicRule = normalizePublicRule;
+const pins_1 = require("./codec/pins");
 const web3_js_1 = require("@solana/web3.js");
 const viem_1 = require("viem");
 const errors_1 = require("./errors");
@@ -64,21 +65,22 @@ function uint(value, name) {
     return value;
 }
 function evmPinOffset(selector, arg) {
-    if (!Number.isInteger(arg) || arg < 0 || 4 + 32 * arg + 32 > 65535)
-        throw invalid('pin arg is outside the supported calldata range');
     const parsed = (0, selectors_1.parseSelector)(selector);
     if (parsed.valueOnly)
         throw invalid('value-only calls cannot have argument pins');
-    if (!parsed.inputs)
-        return 4 + 32 * arg;
-    if (parsed.inputs.slice(0, arg).some((p) => (0, abi_layout_1.headSize)(p) !== 32))
-        throw (0, errors_1.capabilityUnavailable)('argumentLayout', 'pins after multi-word tuple/array arguments need an explicit lossless index convention');
-    return (0, abi_layout_1.argumentOffset)(parsed.inputs, arg, 'pin');
+    if (parsed.inputs)
+        return (0, abi_layout_1.argumentLocation)(parsed.inputs, arg, 'pin').offset;
+    if (typeof arg !== 'number' ||
+        !Number.isSafeInteger(arg) ||
+        arg < 0 ||
+        4 + 32 * arg + 32 > 65535)
+        throw invalid('a raw selector needs a valid scalar ABI word index');
+    return 4 + 32 * arg;
 }
 function expectedWord(selector, arg, value) {
     const parsed = (0, selectors_1.parseSelector)(selector);
     if (parsed.inputs)
-        return (0, abi_layout_1.encodeArgWord)(parsed.inputs[arg], value, 'pin');
+        return (0, abi_layout_1.encodeArgWord)((0, abi_layout_1.argumentLocation)(parsed.inputs, arg, 'pin').param, value, 'pin');
     if (typeof value === 'bigint')
         return (0, viem_1.numberToHex)(uint(value, 'pin.expected'), { size: 32 });
     if (typeof value === 'string' && (0, viem_1.isAddress)(value, { strict: false }))
@@ -151,19 +153,17 @@ async function normalizePublicRule(input, wallet, runtime) {
     if (r.chainNamespace === runtime.pushChainNamespace)
         throw invalid('omit chainNamespace for Push rules');
     if (native && r.allowedCalls.length > 8)
-        throw (0, errors_1.capabilityUnavailable)('nativeActions', 'the deployed v5 wallet permits at most eight native actions');
+        throw (0, errors_1.capabilityUnavailable)('nativeActions', 'the deployed v6 wallet permits at most eight native actions');
     if (native && (r.assets !== undefined || r.maxGasPerCall !== undefined))
         throw invalid('native rules do not carry assets or maxGasPerCall');
     const own = native
         ? wallet
-        : (await runtime.resolveCEA(wallet, r.chainNamespace)).cea;
+        : (0, viem_1.getAddress)((await runtime.resolveCEA(wallet, r.chainNamespace)).cea);
     const nativeActions = [];
     const calls = [];
     for (const call of r.allowedCalls) {
         const pins = call.pins ?? [];
-        let amount;
-        const eq = [];
-        let beneficiaryOffset;
+        const wirePins = [];
         const occupied = new Set();
         for (const pin of pins) {
             if ('account' in pin)
@@ -172,44 +172,28 @@ async function normalizePublicRule(input, wallet, runtime) {
             if (occupied.has(offset))
                 throw invalid('duplicate pin argument');
             occupied.add(offset);
-            if (!native) {
-                if (!('expected' in pin) ||
-                    pin.expected !== exports.WALLET ||
-                    beneficiaryOffset !== undefined)
-                    throw (0, errors_1.capabilityUnavailable)('evmDestinationPins', 'general or multiple EVM destination pins require contract change 6.3; v5 supports one WALLET pin per call');
-                beneficiaryOffset = offset;
-            }
-            else if ('max' in pin) {
-                if (amount)
-                    throw (0, errors_1.capabilityUnavailable)('nativeMaxPins', 'v5 supports one max pin per native call');
-                amount = {
-                    offset,
-                    maxPerCall: uint(pin.max, 'pin.max'),
-                    maxTotal: defaults_1.UINT256_MAX,
-                };
-            }
-            else {
-                eq.push({
-                    offset,
-                    expected: expectedWord(call.selector, pin.arg, pin.expected === exports.WALLET ? own : pin.expected),
-                });
-            }
+            wirePins.push({
+                offset,
+                op: 'max' in pin ? 1 : 0,
+                value: 'max' in pin
+                    ? (0, viem_1.numberToHex)(uint(pin.max, 'pin.max'), { size: 32 })
+                    : expectedWord(call.selector, pin.arg, pin.expected === exports.WALLET ? own : pin.expected),
+            });
         }
         if (native)
             nativeActions.push({
                 target: (0, viem_1.getAddress)(call.target),
                 selector: call.selector,
-                pins: eq,
-                amount,
+                wirePins,
                 maxValuePerCall: call.maxValue ?? BigInt(0),
                 maxValueTotal: defaults_1.UINT256_MAX,
-                maxCalls: 0,
+                maxCalls: pins_1.UNLIMITED_CALLS,
             });
         else
             calls.push({
                 target: (0, viem_1.getAddress)(call.target),
                 selector: call.selector,
-                beneficiaryOffset,
+                pins: wirePins,
                 maxValue: call.maxValue ?? BigInt(0),
             });
     }
@@ -302,7 +286,7 @@ function svmRule(rule, cea) {
                 ],
             };
             return {
-                maxAccounts: 0,
+                maxAccounts: pins_1.ANY_ACCOUNT_COUNT,
                 program: call.target,
                 instruction: { idl, name },
                 accounts: accounts.map((p) => ({

package/src/lib/agentic/reads/rules.js

@@ -171,9 +171,23 @@ async function decodeActiveRule(snap, gen, wallet, rule, pushChainNamespace) {
                     target: c.target,
                     selector: c.selector,
                     maxValue: c.maxValue,
-                    pins: c.hasBeneficiary
-                        ? [{ arg: storedArg(c.beneficiaryOffset), expected: public_rule_1.WALLET }]
-                        : [],
+                    pins: [
+                        ...c.pins.map((p) => p.op === 1
+                            ? { arg: storedArg(p.offset), max: BigInt(p.value) }
+                            : {
+                                arg: storedArg(p.offset),
+                                expected: p.value.toLowerCase() ===
+                                    `0x${cfg.expectedCEA
+                                        .slice(2)
+                                        .toLowerCase()
+                                        .padStart(64, '0')}`
+                                    ? public_rule_1.WALLET
+                                    : p.value,
+                            }),
+                        ...(c.hasBeneficiary
+                            ? [{ arg: storedArg(c.beneficiaryOffset), expected: public_rule_1.WALLET }]
+                            : []),
+                    ],
                 })),
             },
         };
@@ -188,7 +202,7 @@ async function decodeActiveRule(snap, gen, wallet, rule, pushChainNamespace) {
     }
     const decoded = (0, native_1.nativeActionTermsToRule)(configs, rule.agent);
     if (configs.some((c) => c.maxValueTotal !== defaults_1.UINT256_MAX ||
-        Number(c.maxCalls) !== 0 ||
+        Number(c.maxCalls) !== 0xffffffff ||
         (c.amount.enabled && c.amount.maxTotal !== defaults_1.UINT256_MAX) ||
         Number(c.validUntil) !== decoded.validUntil)) {
         throw (0, errors_1.capabilityUnavailable)('nativeRuleRead', 'stored lifetime limits or differing action expiries cannot be represented by section-6 rules without losing constraints');
@@ -198,13 +212,15 @@ async function decodeActiveRule(snap, gen, wallet, rule, pushChainNamespace) {
         selector: c.selector === '0xffffffff' ? 'value-only' : c.selector,
         maxValue: c.maxValuePerCall,
         pins: [
-            ...c.pins.map((p) => ({
-                arg: storedArg(p.offset),
-                expected: p.expected.toLowerCase() ===
-                    `0x${wallet.slice(2).toLowerCase().padStart(64, '0')}`
-                    ? public_rule_1.WALLET
-                    : p.expected,
-            })),
+            ...c.pins.map((p) => p.op === 1
+                ? { arg: storedArg(p.offset), max: BigInt(p.value) }
+                : {
+                    arg: storedArg(p.offset),
+                    expected: p.value.toLowerCase() ===
+                        `0x${wallet.slice(2).toLowerCase().padStart(64, '0')}`
+                        ? public_rule_1.WALLET
+                        : p.value,
+                }),
             ...(c.amount.enabled
                 ? [{ arg: storedArg(c.amount.offset), max: c.amount.maxPerCall }]
                 : []),

package/src/lib/agentic/reads/svm.d.ts

@@ -1,7 +1,7 @@
 /** Internal lossless SVM state shared by public reads and execution. */
 import type { Address, Hex } from 'viem';
 import type { AgenticGeneration } from '../deployments';
-import type { SvmConfigRead } from '../contracts/v5';
+import type { SvmConfigRead } from '../contracts/v6';
 import { type ActiveRule } from './rules';
 import type { Snapshot } from './snapshot';
 export interface SvmRuleSnapshot {

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

@@ -4,7 +4,7 @@ exports.readSvmRule = readSvmRule;
 exports.readSvmConfig = readSvmConfig;
 const errors_1 = require("../errors");
 const ids_1 = require("../codec/ids");
-const v5_1 = require("../contracts/v5");
+const v6_1 = require("../contracts/v6");
 const svm_terms_1 = require("../codec/svm-terms");
 const rules_1 = require("./rules");
 async function readSvmRule(snap, gen, wallet, rulesId, pushChainNamespace) {
@@ -15,7 +15,7 @@ async function readSvmRule(snap, gen, wallet, rulesId, pushChainNamespace) {
 }
 async function readSvmConfig(snap, gen, wallet, active, pushChainNamespace) {
     const chain = (0, rules_1.chainFromHash)(active.chainHash, pushChainNamespace);
-    const expectedAction = (0, ids_1.actionId)(gen.addresses.gateway, v5_1.SEND_OUTBOUND_SELECTOR);
+    const expectedAction = (0, ids_1.actionId)(gen.addresses.gateway, v6_1.SEND_OUTBOUND_SELECTOR);
     if (active.mode !== 0 ||
         active.vm !== 1 ||
         !chain?.startsWith('solana:') ||

package/src/lib/agentic/response.js

@@ -15,7 +15,7 @@ const helpers_1 = require("../orchestrator/internals/helpers");
 const account_1 = require("../universal/account/account");
 const chain_3 = require("./chain");
 const abi_1 = require("../constants/abi");
-const v5_1 = require("./contracts/v5");
+const v6_1 = require("./contracts/v6");
 const deployments_1 = require("./deployments");
 /**
  * Present an AGW send as the wallet's own transaction: `from` is the AGW and
@@ -83,7 +83,7 @@ async function adaptTrackedResponse(runtime, resp) {
     const batch = await adaptNativeAgentBatch(runtime, resp);
     if (batch)
         return batch;
-    const decoded = v5_1.v5.decodeWalletCall(resp.data);
+    const decoded = v6_1.v6.decodeWalletCall(resp.data);
     if (!decoded ||
         (decoded.kind !== 'execute' && decoded.kind !== 'executeAsAgent'))
         return resp;
@@ -107,7 +107,7 @@ async function adaptTrackedResponse(runtime, resp) {
         : undefined;
     const calls = decoded.calls;
     const outbound = calls.find((c) => (0, viem_2.getAddress)(c.target) === gen.addresses.gateway &&
-        c.data.toLowerCase().startsWith(v5_1.SEND_OUTBOUND_SELECTOR));
+        c.data.toLowerCase().startsWith(v6_1.SEND_OUTBOUND_SELECTOR));
     if (outbound) {
         const out = decodeOutbound(outbound.data);
         const chain = await tokenChain(runtime, out.token);
@@ -204,7 +204,7 @@ async function adaptTrackedResponse(runtime, resp) {
 /** Decode only supported sender-account batches, never an arbitrary forwarding helper. */
 async function adaptNativeAgentBatch(runtime, resp) {
     let outer;
-    const isUea = resp.data.toLowerCase().startsWith(v5_1.UEA_MULTICALL_PREFIX);
+    const isUea = resp.data.toLowerCase().startsWith(v6_1.UEA_MULTICALL_PREFIX);
     try {
         if (isUea) {
             const [entries] = (0, viem_2.decodeAbiParameters)([
@@ -224,7 +224,7 @@ async function adaptNativeAgentBatch(runtime, resp) {
             }));
         }
         else {
-            const batch = v5_1.v5.decodeWalletCall(resp.data);
+            const batch = v6_1.v6.decodeWalletCall(resp.data);
             if (batch?.kind !== 'execute' || batch.mode !== `0x01${'00'.repeat(31)}`)
                 return;
             outer = batch.calls;
@@ -232,7 +232,7 @@ async function adaptNativeAgentBatch(runtime, resp) {
         if (outer.length < 2 ||
             outer.some((c) => c.value !== BigInt(0) || c.target !== outer[0].target))
             return;
-        const inner = outer.map((c) => v5_1.v5.decodeWalletCall(c.data));
+        const inner = outer.map((c) => v6_1.v6.decodeWalletCall(c.data));
         const first = inner[0];
         if (first?.kind !== 'executeAsAgent' || first.calls.length !== 1)
             return;
@@ -305,7 +305,7 @@ function decodeOutbound(data) {
     const { args } = (0, viem_2.decodeFunctionData)({ abi: abi_1.UNIVERSAL_GATEWAY_PC, data });
     const req = args?.[0];
     let calls = [];
-    if (req.payload.toLowerCase().startsWith(v5_1.UEA_MULTICALL_PREFIX)) {
+    if (req.payload.toLowerCase().startsWith(v6_1.UEA_MULTICALL_PREFIX)) {
         try {
             const [decodedCalls] = (0, viem_2.decodeAbiParameters)([
                 {

package/src/lib/agentic/revert.js

@@ -5,14 +5,14 @@ exports.decodeAgwErrorData = decodeAgwErrorData;
 exports.decodeAgenticRevert = decodeAgenticRevert;
 const viem_1 = require("viem");
 const utils_1 = require("viem/utils");
-const v5_1 = require("./contracts/abi/v5");
+const v6_1 = require("./contracts/abi/v6");
 /** URP reverts reached through the engine are truncated to this wrapper. */
 exports.POLICY_CHECK_REVERTED_SELECTOR = '0xf4270752';
 const ERROR_ABIS = [
-    v5_1.AGW_ABI,
-    v5_1.UNIVERSAL_RULES_POLICY_ABI,
-    v5_1.AGW_FACTORY_ABI,
-    v5_1.SMART_SESSION_ABI,
+    v6_1.AGW_ABI,
+    v6_1.UNIVERSAL_RULES_POLICY_ABI,
+    v6_1.AGW_FACTORY_ABI,
+    v6_1.SMART_SESSION_ABI,
 ];
 /** selector → error name across the AGW/URP/factory/engine ABIs. */
 const ERROR_NAMES = new Map(ERROR_ABIS.flatMap((abi) => abi

package/src/lib/agentic/runtime.js

@@ -86,9 +86,18 @@ function createAgenticRuntime(orchestrator, isReadOnly) {
             const r = await (0, cea_utils_1.getCEAAddress)(account, chain, orchestrator.getRpcUrls()[chain]?.[0]);
             return { cea: (0, viem_1.getAddress)(r.cea), isDeployed: r.isDeployed };
         },
-        resolvePrc20: (token, chain) => (0, viem_1.getAddress)(token
-            ? (0, prc20_address_1.getPRC20Address)(typeof token === 'string' ? { chain, address: token } : token, { network }).address
-            : (0, helpers_1.getNativePRC20ForChain)(chain, network)),
+        resolvePrc20: (token, chain) => {
+            if (!token)
+                return (0, viem_1.getAddress)((0, helpers_1.getNativePRC20ForChain)(chain, network));
+            // Native ETH shares a symbol/address across chains. A plain token must
+            // resolve within the known destination, never the first global match.
+            if (typeof token === 'object' && 'prc20Address' in token) {
+                if (!('sourceChain' in token) || token.sourceChain !== chain)
+                    throw new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.ASSET_CHAIN_MISMATCH, 'Push token source chain must match the destination chain');
+                return (0, viem_1.getAddress)((0, prc20_address_1.getPRC20Address)(token, { network }).address);
+            }
+            return (0, viem_1.getAddress)((0, prc20_address_1.getPRC20Address)({ chain, address: typeof token === 'string' ? token : token.address }, { network }).address);
+        },
         nowSeconds: () => Math.floor(Date.now() / 1000),
     };
 }

package/src/lib/agentic/utils.js

@@ -62,7 +62,7 @@ exports.internalAgenticUtils = {
             rulesPolicy: (0, viem_1.getAddress)(ctx.rulesPolicy),
             gateway: ctx.gateway,
             universal: ctx.universal,
-            capabilities: deployments_1.V5_CAPABILITIES,
+            capabilities: deployments_1.V6_CAPABILITIES,
             nowSeconds: ctx.nowSeconds ?? Math.floor(Date.now() / 1000),
         }).map((p) => (0, session_1.encodeSession)(p.session));
     },

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

@@ -115,6 +115,7 @@ export declare const CONSTANTS: {
             CATEGORY: Readonly<{
                 DEXES: "DEXES";
                 LENDING: "LENDING";
+                STAKING: "STAKING";
                 PREDICTION: "PREDICTION";
             }>;
         }>;

package/src/lib/index.d.ts

@@ -24,6 +24,6 @@ export { PushChainExecutionError, PushChainBatchExecutionError, } from './orches
 export type { DecodedErrorPayload } from './orchestrator/internals/errors';
 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, RulesRecord, Selector, WalletInfo, WalletSummary, } 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';

package/src/lib/push-chain/push-chain.d.ts

@@ -100,6 +100,7 @@ export declare class PushChain {
                 CATEGORY: Readonly<{
                     DEXES: "DEXES";
                     LENDING: "LENDING";
+                    STAKING: "STAKING";
                     PREDICTION: "PREDICTION";
                 }>;
             }>;

package/src/lib/agentic/contracts/donut-v5.d.ts

@@ -1,11 +0,0 @@
-/** Source 2e61e13; code/proxy wiring checked at Donut block 23991912. */
-export declare const V5_SOURCE_COMMIT = "2e61e133e641b4e0e1ddbdc9306b0903b60e4dbb";
-export declare const DONUT_V5_START_BLOCK: bigint;
-export declare const DONUT_V5_ADDRESSES: {
-    readonly factory: "0x8137F96A50EBF41d904e3678c84c391a0D1BCcc5";
-    readonly walletImplementation: "0x4D459Da499C14548aa16c46c57fD92880A88EBb4";
-    readonly sessionEngine: "0x165A5E6782f39D30B38c7D97e1303e4CB2aD102a";
-    readonly rulesPolicy: "0x603E7f0aF6e1aAFf46DDfb28b1e99364f8BC59af";
-    readonly sessionValidator: "0x068EE2388475A98EE1f5a434C58bFF3444fffFe6";
-    readonly gateway: "0x00000000000000000000000000000000000000C1";
-};

package/src/lib/agentic/contracts/donut-v5.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DONUT_V5_ADDRESSES = exports.DONUT_V5_START_BLOCK = exports.V5_SOURCE_COMMIT = void 0;
-/** Source 2e61e13; code/proxy wiring checked at Donut block 23991912. */
-exports.V5_SOURCE_COMMIT = '2e61e133e641b4e0e1ddbdc9306b0903b60e4dbb';
-exports.DONUT_V5_START_BLOCK = BigInt(23989983);
-exports.DONUT_V5_ADDRESSES = {
-    factory: '0x8137F96A50EBF41d904e3678c84c391a0D1BCcc5',
-    walletImplementation: '0x4D459Da499C14548aa16c46c57fD92880A88EBb4',
-    sessionEngine: '0x165A5E6782f39D30B38c7D97e1303e4CB2aD102a',
-    rulesPolicy: '0x603E7f0aF6e1aAFf46DDfb28b1e99364f8BC59af',
-    sessionValidator: '0x068EE2388475A98EE1f5a434C58bFF3444fffFe6',
-    gateway: '0x00000000000000000000000000000000000000C1',
-};
-//# sourceMappingURL=donut-v5.js.map