@pushchain/core 6.0.27-alpha.3 → 6.0.27-alpha.4

package/src/lib/agentic/contracts/reader.js

@@ -7,10 +7,13 @@ function chainReaderFromPublicClient(client) {
     return {
         readContract: (args) => client.readContract(args),
         getBlockNumber: () => client.getBlockNumber({ cacheTime: 0 }),
+        getBlock: (args) => client.getBlock(args),
         getCode: (args) => client.getCode(args),
         getBalance: (args) => client.getBalance(args),
         getLogs: (args) => client.getLogs(args),
         getTransactionReceipt: (args) => client.getTransactionReceipt(args),
+        getTransaction: (args) => client.getTransaction(args),
+        call: (args) => client.call(args),
     };
 }
 //# sourceMappingURL=reader.js.map

package/src/lib/agentic/error-messages.d.ts

@@ -0,0 +1,3 @@
+import type { AgenticErrorCode } from './errors';
+export declare function agenticUserMessage(code: AgenticErrorCode, diagnostic: string, details?: Readonly<Record<string, unknown>>): string;
+export declare function agenticRevertUserMessage(name?: string): string;

package/src/lib/agentic/error-messages.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agenticUserMessage = agenticUserMessage;
+exports.agenticRevertUserMessage = agenticRevertUserMessage;
+/** UI copy only. Codes, original messages, hints and causes remain diagnostic data. */
+const MESSAGES = {
+    DUPLICATE_RULE: 'Keep one rule per agent and network. Edit the existing rule or remove the duplicate.',
+    AGENT_IS_OWNER: 'Choose an agent address different from the wallet owner.',
+    AMBIGUOUS_RULE: 'More than one rule matches this agent and network. Keep one active matching rule before sending.',
+    TARGET_NOT_ON_RULE_CHAIN: 'Choose an app on the network selected for this rule.',
+    ASSET_CHAIN_MISMATCH: 'The selected token belongs to a different network. Choose a token on this rule’s network.',
+    TOKEN_ROUTE_UNAVAILABLE: 'This token cannot currently be transferred from Push to the selected network. Choose a token with a supported Push route.',
+    REQUEST_REJECTED: 'The wallet request was cancelled. Check wallet activity before trying again.',
+    NOT_OWNER_OR_AGENT: 'Connect the wallet owner or an agent authorized by its rules.',
+    WALLET_NOT_DEPLOYED: 'This agentic wallet has not been created yet.',
+    NOT_AGENTIC_WALLET: 'This address is not a supported agentic wallet.',
+    DELETE_NEEDS_TARGET: 'Choose which rules to remove.',
+    NO_RULES_FOR_CHAIN: 'This agent has no active rule for the selected network.',
+    FROM_NOT_ALLOWED: 'The agentic wallet is the sender. Remove the custom sender selection.',
+    NOT_ALLOWED_IN_AGENTIC_MODE: 'This action is unavailable while using an agentic wallet.',
+    INVALID_RULE: 'Some rule settings are invalid. Review the rule and try again.',
+    CAPABILITY_UNAVAILABLE: 'This feature is not available for this wallet or network yet.',
+    READ_ONLY: 'Connect a signing wallet to continue.',
+    NOT_WALLET_OWNER: 'Connect the owner wallet to change these permissions.',
+    RULE_NOT_FOUND: 'This rule could not be found. Refresh the wallet’s rules and try again.',
+    RULE_READ_FAILED: 'The wallet’s current state could not be loaded. Refresh and try again.',
+    INCONSISTENT_READ: 'The wallet changed while it was being checked. Refresh before trying again.',
+    INDEX_RACE: 'The expected wallet address changed. Refresh wallet information before trying again.',
+    RECEIPT_MISMATCH: 'The transaction result needs verification. Check its status before retrying.',
+    RECEIPT_UNAVAILABLE: 'The transaction was submitted, but its status could not be confirmed. Check its status before trying again.',
+    AGENT_GAS_INSUFFICIENT: 'The agent needs more Push coins to pay transaction fees.',
+    WALLET_BALANCE_INSUFFICIENT: 'The agentic wallet does not have enough funds for this action.',
+};
+function agenticUserMessage(code, diagnostic, details) {
+    if (code === 'CAPABILITY_UNAVAILABLE') {
+        if (details?.['capability'] === 'nativeActions')
+            return 'A Push rule can allow at most eight functions. Select fewer functions.';
+        if (details?.['capability'] === 'presetCalls')
+            return 'Choose a preset configuration with 1 to 32 allowed functions.';
+        if (details?.['capability'] === 'presetChain' ||
+            details?.['capability'] === 'presetCatalog')
+            return 'This preset is unavailable for the selected network.';
+    }
+    if (code !== 'INVALID_RULE')
+        return MESSAGES[code];
+    if (/validUntil|expiry|expired|future.*timestamp/i.test(diagnostic))
+        return 'Choose an expiry date in the future.';
+    if (/label.*(64|length|most)/i.test(diagnostic))
+        return 'The wallet name is too long. Shorten it and try again.';
+    if (/label/i.test(diagnostic))
+        return 'Enter a valid wallet name.';
+    if (/maxGasPerCall.*positive/i.test(diagnostic))
+        return 'Set a gas budget greater than zero for this rule.';
+    if (/allowedCalls.*(1\.\.32|contain|array)/i.test(diagnostic))
+        return 'Select between 1 and 32 allowed functions for this rule.';
+    if (/rules.*(eight|8)|eight initial rules/i.test(diagnostic))
+        return 'A wallet can be created with at most eight rules. Remove some rules before creating it.';
+    if (/assets.*(eight|8)/i.test(diagnostic))
+        return 'A rule can include at most eight tokens. Select fewer tokens.';
+    if (/duplicate.*pin|pin.*duplicate/i.test(diagnostic))
+        return 'The same function input has more than one condition. Keep one condition for each input.';
+    if (/pins.*(eight|8)/i.test(diagnostic))
+        return 'A function can have at most eight conditions. Choose a simpler function configuration.';
+    if (/pins.*32|32.*pins/i.test(diagnostic))
+        return 'This rule has too many conditions. Select fewer tokens or allowed functions.';
+    if (/selector|function signature/i.test(diagnostic))
+        return 'The selected function format is invalid. Select the function again or check its signature.';
+    if (/dynamic|static|offset|argument.*range|tuple/i.test(diagnostic))
+        return 'This function input cannot be constrained in that format. Choose a supported input or function.';
+    if (/uint256|bigint|non-negative/i.test(diagnostic))
+        return 'One of the spending limits is invalid. Review the amounts and try again.';
+    if (/chainNamespace|unsupported.*chain/i.test(diagnostic))
+        return 'Choose a supported network for this rule.';
+    if (/address/i.test(diagnostic))
+        return 'Enter a valid wallet, token or app address for this rule.';
+    return MESSAGES.INVALID_RULE;
+}
+function agenticRevertUserMessage(name) {
+    if (!name)
+        return 'The transaction could not be completed. Check wallet activity before trying again.';
+    if (/TooManyAllowedCallPins/.test(name))
+        return 'This rule has more than 32 conditions. Select fewer tokens or allowed functions.';
+    if (/TooMany.*Pins|PinRuleOutOfRange/.test(name))
+        return 'This function has too many conditions. Choose a simpler rule configuration.';
+    if (/TooManyActions|TooManyInitialRules|BatchSizeOutOfRange/.test(name))
+        return 'Too many rules or functions are selected. Reduce the selection and try again.';
+    if (/LabelTooLong/.test(name))
+        return 'The wallet name is too long. Shorten it and try again.';
+    if (/DuplicateAction|DuplicateAsset|DuplicateSvmPin/.test(name))
+        return 'This rule contains duplicate functions, tokens or conditions. Remove the duplicate selection.';
+    if (/SpentMismatch|SpentLengthMismatch|AssetSpentMismatch|IndexMismatch|InvalidNonce|IntentGrantNonceMismatch|IntentWalletMismatch/.test(name))
+        return 'The wallet changed while this action was being prepared. Refresh its state before trying again.';
+    if (/EnforcedPause/.test(name))
+        return 'This operation is temporarily paused. Try again later.';
+    if (/OwnerSigExpired|SignatureExpired/.test(name))
+        return 'The wallet approval has expired. Review and sign a new request.';
+    if (/OutsideTimeWindow/.test(name))
+        return 'This request is outside its valid time window. Refresh and approve a new request.';
+    if (/InvalidExpiry/.test(name))
+        return 'Choose a valid future expiry for this rule.';
+    if (/Allowance|Approval/.test(name))
+        return 'The token spending approval is missing or too small. Review the token approvals.';
+    if (/RuleWithoutPin|CeaAccountsMissExpectedCEA|CeaAccountAtUnpinnedIndex/.test(name))
+        return 'The rule is missing a required wallet-recipient restriction. Review its recipient settings.';
+    if (/Unsupported|WrongVmForCall|WrongModeForCall/.test(name))
+        return 'This action is not supported on the selected network or wallet version.';
+    if (/InvalidOwnerSignature|InvalidEnableSignature|InvalidSessionKeySignature|SignerNotFound/.test(name))
+        return 'The signature could not be verified. Reconnect the authorized wallet and try again.';
+    if (/PCValueExceedsCap|Gas.*Cap/.test(name ?? ''))
+        return 'The required gas exceeds this rule’s gas budget. Review the budget before trying again.';
+    if (/ArgPinAboveMax|AmountExceedsCap|TotalSpendCapExceeded|Value.*Cap|MaxCalls|CallLimitReached|TotalNativeAmountExceeded|TotalValueExceeded/.test(name ?? ''))
+        return 'This action exceeds a rule’s spending or usage limit. Reduce the amount or ask the owner to update the rule.';
+    if (/Expired|Expiry/.test(name ?? ''))
+        return 'This rule has expired. Ask the owner to renew it.';
+    if (/ArgPinMismatch|Beneficiary|NotAllowed|NotEnabled|Permission|RuleNot|RulesNot|RecipientTargetMismatch|TargetMismatch|SelectorMismatch|SvmAccountPinMismatch|SvmDataPinMismatch/.test(name ?? ''))
+        return 'This action does not match the wallet’s permissions. Check the token, recipient and allowed function.';
+    if (/CallerIsNotOwner|UnauthorizedOwner|OwnerLaneRequired/.test(name ?? ''))
+        return 'Connect the owner wallet to make this change.';
+    if (/CallerIsNotAgent/.test(name ?? ''))
+        return 'Connect the agent authorized by this rule.';
+    if (/Insufficient|Balance/.test(name ?? ''))
+        return 'There are not enough funds for this action. Check the wallet balance and fees.';
+    return 'The wallet contract rejected this transaction. Review the permissions and transaction details before trying again.';
+}
+//# sourceMappingURL=error-messages.js.map

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

@@ -10,6 +10,8 @@ export declare const AGENTIC_ERROR_CODE: {
     readonly AMBIGUOUS_RULE: "AMBIGUOUS_RULE";
     readonly TARGET_NOT_ON_RULE_CHAIN: "TARGET_NOT_ON_RULE_CHAIN";
     readonly ASSET_CHAIN_MISMATCH: "ASSET_CHAIN_MISMATCH";
+    readonly TOKEN_ROUTE_UNAVAILABLE: "TOKEN_ROUTE_UNAVAILABLE";
+    readonly REQUEST_REJECTED: "REQUEST_REJECTED";
     readonly NOT_OWNER_OR_AGENT: "NOT_OWNER_OR_AGENT";
     readonly WALLET_NOT_DEPLOYED: "WALLET_NOT_DEPLOYED";
     readonly NOT_AGENTIC_WALLET: "NOT_AGENTIC_WALLET";
@@ -36,15 +38,18 @@ export type AgenticErrorCode = (typeof AGENTIC_ERROR_CODE)[keyof typeof AGENTIC_
  * eligibility or a read that cannot be trusted. Nothing was signed or sent
  * except receipt errors, which retain the submitted transaction hash.
  */
-export declare class AgenticError extends Error {
-    readonly code: AgenticErrorCode;
+export declare class AgenticError<Code extends string = AgenticErrorCode> extends Error {
+    readonly code: Code;
+    /** Safe end-user copy; message/cause retain technical diagnostics. */
+    readonly userMessage: string;
     readonly hint?: string;
     readonly details?: Readonly<Record<string, unknown>>;
     readonly cause?: unknown;
-    constructor(code: AgenticErrorCode, message: string, opts?: {
+    constructor(code: Code, message: string, opts?: {
         hint?: string;
         details?: Record<string, unknown>;
         cause?: unknown;
+        userMessage?: string;
     });
 }
 /**
@@ -55,6 +60,7 @@ export declare class AgenticError extends Error {
  */
 export declare class AgenticRevertError extends PushChainExecutionError {
     readonly agenticCode?: string;
+    readonly userMessage: string;
     constructor(message: string, opts?: {
         decodedError?: DecodedErrorPayload;
         gatewayTxHash?: string;
@@ -62,4 +68,7 @@ export declare class AgenticRevertError extends PushChainExecutionError {
         cause?: unknown;
     });
 }
+export declare function ruleConstraintLimit(actual: number, callCount: number, chainNamespace?: string): AgenticError;
+export declare function ruleErrorContext(error: unknown, ruleIndex: number, chainNamespace?: string): unknown;
+export declare function tokenRouteUnavailable(cause: unknown, token: string, chainNamespace: string, assetIndex: number): AgenticError;
 export declare function capabilityUnavailable(capability: string, dependency: string, hint?: string): AgenticError;

package/src/lib/agentic/errors.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgenticRevertError = exports.AgenticError = exports.AGENTIC_ERROR_CODE = void 0;
+exports.ruleConstraintLimit = ruleConstraintLimit;
+exports.ruleErrorContext = ruleErrorContext;
+exports.tokenRouteUnavailable = tokenRouteUnavailable;
 exports.capabilityUnavailable = capabilityUnavailable;
 const errors_1 = require("../orchestrator/internals/errors");
+const error_messages_1 = require("./error-messages");
 /**
  * Stable AGW error codes. The first groups are specified by the AGW SDK page
  * (section 3.f); the remainder are SDK-owned codes that keep unsupported or
@@ -15,6 +19,8 @@ exports.AGENTIC_ERROR_CODE = {
     AMBIGUOUS_RULE: 'AMBIGUOUS_RULE',
     TARGET_NOT_ON_RULE_CHAIN: 'TARGET_NOT_ON_RULE_CHAIN',
     ASSET_CHAIN_MISMATCH: 'ASSET_CHAIN_MISMATCH',
+    TOKEN_ROUTE_UNAVAILABLE: 'TOKEN_ROUTE_UNAVAILABLE',
+    REQUEST_REJECTED: 'REQUEST_REJECTED',
     // initialize with agenticWallet (spec 3.f)
     NOT_OWNER_OR_AGENT: 'NOT_OWNER_OR_AGENT',
     WALLET_NOT_DEPLOYED: 'WALLET_NOT_DEPLOYED',
@@ -46,6 +52,8 @@ exports.AGENTIC_ERROR_CODE = {
  */
 class AgenticError extends Error {
     code;
+    /** Safe end-user copy; message/cause retain technical diagnostics. */
+    userMessage;
     hint;
     details;
     cause;
@@ -53,6 +61,11 @@ class AgenticError extends Error {
         super(message);
         this.name = 'AgenticError';
         this.code = code;
+        this.userMessage =
+            opts.userMessage ??
+                (Object.prototype.hasOwnProperty.call(exports.AGENTIC_ERROR_CODE, code)
+                    ? (0, error_messages_1.agenticUserMessage)(code, message, opts.details)
+                    : message);
         this.hint = opts.hint;
         this.details = opts.details;
         this.cause = opts.cause;
@@ -67,6 +80,7 @@ exports.AgenticError = AgenticError;
  */
 class AgenticRevertError extends errors_1.PushChainExecutionError {
     agenticCode;
+    userMessage;
     constructor(message, opts = {}) {
         super(message, {
             decodedError: opts.decodedError,
@@ -75,9 +89,71 @@ class AgenticRevertError extends errors_1.PushChainExecutionError {
         });
         this.name = 'AgenticRevertError';
         this.agenticCode = opts.agenticCode;
+        this.userMessage = (0, error_messages_1.agenticRevertUserMessage)(opts.decodedError?.name ?? opts.agenticCode);
     }
 }
 exports.AgenticRevertError = AgenticRevertError;
+function ruleConstraintLimit(actual, callCount, chainNamespace) {
+    const message = `This rule has ${actual} conditions. The maximum is 32. Remove duplicate functions or select fewer tokens or functions.`;
+    return new AgenticError(exports.AGENTIC_ERROR_CODE.INVALID_RULE, message, {
+        userMessage: message,
+        hint: 'Regenerate the preset after changing selections. Do not drop individual conditions or bypass the contract limit.',
+        details: {
+            reason: 'RULE_CONSTRAINT_LIMIT',
+            field: 'allowedCalls',
+            actual,
+            limit: 32,
+            callCount,
+            chainNamespace,
+        },
+    });
+}
+function ruleErrorContext(error, ruleIndex, chainNamespace) {
+    if (!(error instanceof AgenticError))
+        return error;
+    if (error.details?.['ruleIndex'] !== undefined)
+        return error;
+    return new AgenticError(error.code, error.message, {
+        hint: error.hint,
+        userMessage: `Rule ${ruleIndex + 1}: ${error.userMessage}`,
+        cause: error.cause ?? error,
+        details: {
+            ...error.details,
+            ruleIndex,
+            ...(chainNamespace ? { chainNamespace } : {}),
+        },
+    });
+}
+function tokenRouteUnavailable(cause, token, chainNamespace, assetIndex) {
+    if (cause instanceof AgenticError)
+        return cause;
+    const names = {
+        'eip155:1': 'Ethereum',
+        'eip155:11155111': 'Ethereum Sepolia',
+        'eip155:8453': 'Base',
+        'eip155:84532': 'Base Sepolia',
+        'eip155:42161': 'Arbitrum',
+        'eip155:421614': 'Arbitrum Sepolia',
+        'eip155:56': 'BNB Chain',
+        'eip155:97': 'BNB Testnet',
+    };
+    const network = names[chainNamespace] ??
+        (chainNamespace.startsWith('solana:')
+            ? 'the selected Solana network'
+            : 'the selected network');
+    const message = `This token cannot be sent from Push to ${network}. Choose a token with a supported Push route.`;
+    return new AgenticError(exports.AGENTIC_ERROR_CODE.TOKEN_ROUTE_UNAVAILABLE, message, {
+        userMessage: message,
+        hint: 'Choose a supported token on this network, or wait for a verified PRC20 route for this exact token address. Token symbols alone do not identify a route.',
+        details: {
+            token,
+            chainNamespace,
+            assetIndex,
+            field: `assets[${assetIndex}].token`,
+        },
+        cause,
+    });
+}
 function capabilityUnavailable(capability, dependency, hint) {
     return new AgenticError(exports.AGENTIC_ERROR_CODE.CAPABILITY_UNAVAILABLE, `AGW capability "${capability}" is not available: ${dependency}`, { hint, details: { capability, dependency } });
 }

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

@@ -102,6 +102,12 @@ function wrapSendError(err) {
             cause: err,
         });
     }
+    if (err &&
+        typeof err === 'object' &&
+        (('code' in err && err.code === 4001) ||
+            ('name' in err && err.name === 'UserRejectedRequestError'))) {
+        return new errors_2.AgenticError(errors_2.AGENTIC_ERROR_CODE.REQUEST_REJECTED, 'The wallet request was cancelled.', { cause: err });
+    }
     if (decoded || err instanceof errors_1.PushChainExecutionError) {
         const e = err;
         return new errors_2.AgenticRevertError(e?.message ?? decoded?.name ?? 'AGW revert', {

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

@@ -0,0 +1,5 @@
+import { type Address } from 'viem';
+import type { CHAIN } from '../../constants/enums';
+import type { AgenticRuntime } from '../runtime';
+/** Preserve read failures as read failures; never report them as bad token routes. */
+export declare function resolveRuleDestination(runtime: AgenticRuntime, wallet: Address, chain: CHAIN): Promise<Address>;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuleDestination = resolveRuleDestination;
+const viem_1 = require("viem");
+const errors_1 = require("../errors");
+/** Preserve read failures as read failures; never report them as bad token routes. */
+async function resolveRuleDestination(runtime, wallet, chain) {
+    try {
+        return (0, viem_1.getAddress)((await runtime.resolveCEA(wallet, chain)).cea);
+    }
+    catch (cause) {
+        if (cause instanceof errors_1.AgenticError)
+            throw cause;
+        const unavailable = cause instanceof Error &&
+            cause.message.includes('CEAFactory not available on chain');
+        const message = unavailable
+            ? 'Agentic wallets are not available on this destination network yet. Choose a supported network.'
+            : 'The wallet’s destination account could not be loaded. Try again shortly.';
+        throw new errors_1.AgenticError(unavailable
+            ? errors_1.AGENTIC_ERROR_CODE.CAPABILITY_UNAVAILABLE
+            : errors_1.AGENTIC_ERROR_CODE.RULE_READ_FAILED, message, {
+            userMessage: message,
+            cause,
+            details: {
+                chainNamespace: chain,
+                field: 'chainNamespace',
+                stage: 'destinationAccount',
+            },
+        });
+    }
+}
+//# sourceMappingURL=destination.js.map

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

@@ -12,72 +12,97 @@ const universal_1 = require("../codec/universal");
 const deployments_1 = require("../deployments");
 const capabilities_1 = require("../capabilities");
 const errors_1 = require("../errors");
+const destination_1 = require("./destination");
 const prc20_metadata_1 = require("../contracts/prc20-metadata");
 /** Resolve wallet-dependent wire inputs without signing or mutating authority. */
 async function prepareWalletRules(runtime, gen, owner, wallet, inputs, snap) {
-    const rules = await Promise.all(inputs.map((rule) => (0, public_rule_1.isPublicRule)(rule) ? (0, public_rule_1.normalizePublicRule)(rule, wallet, runtime) : rule));
+    const rules = await Promise.all(inputs.map(async (rule, ruleIndex) => {
+        try {
+            return (0, public_rule_1.isPublicRule)(rule)
+                ? await (0, public_rule_1.normalizePublicRule)(rule, wallet, runtime)
+                : rule;
+        }
+        catch (error) {
+            throw (0, errors_1.ruleErrorContext)(error, ruleIndex, rule?.chainNamespace);
+        }
+    }));
     if (rules.length)
         await (0, deployments_1.verifyPolicyVersion)(runtime.reader, gen);
     const svm = new Map();
     const universal = new Map();
-    for (const rule of rules) {
-        if (rule && (0, rules_1.isSolanaRule)(rule)) {
-            (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES);
-            svm.set(rule, await (0, svm_public_1.preparePublicSvmRule)(runtime, snap, wallet, rule));
-            continue;
-        }
-        if (!(0, rules_1.isUniversalRule)(rule))
-            continue;
-        if (rule.chainNamespace.startsWith('solana:'))
-            (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES);
-        (0, universal_1.validateUniversalRuleShape)(rule, runtime.nowSeconds());
-        (0, capabilities_1.requireCapability)(gen.capabilities, rule.chainNamespace.startsWith('solana:')
-            ? capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES
-            : capabilities_1.AgenticCapability.UNIVERSAL_EVM_RULES);
-        const chain = rule.chainNamespace;
-        if (chain_1.CHAIN_INFO[chain]?.vm !== enums_1.VM.EVM)
-            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `unsupported EVM rule chain ${chain}`);
-        const { cea } = await runtime.resolveCEA(wallet, chain);
-        const assets = rule.assets.length
-            ? rule.assets.map((a) => ({
-                token: typeof a.token === 'string' && (0, viem_1.getAddress)(a.token) === viem_1.zeroAddress
-                    ? undefined
-                    : a.token,
-                maxPerCall: a.maxPerCall,
-                maxTotal: (0, defaults_1.withDefault)(a.maxTotal, defaults_1.AGENTIC_DEFAULTS.universal.assetMaxTotal),
-            }))
-            : [{ token: undefined, maxPerCall: BigInt(0), maxTotal: BigInt(0) }];
-        const resolved = [];
-        for (const asset of assets) {
-            const token = asset.token === undefined
-                ? await (0, prc20_metadata_1.readGasPrc20)(snap, chain)
-                : runtime.resolvePrc20(asset.token, chain);
-            if (token === viem_1.zeroAddress)
-                throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `no gas PRC20 registered for ${chain}`);
-            const namespace = await snap.read(token, prc20_metadata_1.PRC20_SOURCE_ABI, 'SOURCE_CHAIN_NAMESPACE');
-            if (namespace !== chain)
-                throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.ASSET_CHAIN_MISMATCH, `PRC20 ${token} belongs to ${namespace}, not ${chain}`);
-            if (asset.token !== undefined) {
-                const expected = typeof asset.token === 'string'
-                    ? (0, viem_1.getAddress)(asset.token)
-                    : (0, viem_1.getAddress)(asset.token.address);
-                if (expected === viem_1.zeroAddress) {
-                    if ((await (0, prc20_metadata_1.readGasPrc20)(snap, chain)) !== (0, viem_1.getAddress)(token))
-                        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'resolved token is not the registered native gas token');
-                }
+    for (const [ruleIndex, rule] of rules.entries()) {
+        try {
+            if (rule && (0, rules_1.isSolanaRule)(rule)) {
+                (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES);
+                svm.set(rule, await (0, svm_public_1.preparePublicSvmRule)(runtime, snap, wallet, rule));
+                continue;
+            }
+            if (!(0, rules_1.isUniversalRule)(rule))
+                continue;
+            if (rule.chainNamespace.startsWith('solana:'))
+                (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES);
+            (0, universal_1.validateUniversalRuleShape)(rule, runtime.nowSeconds());
+            (0, capabilities_1.requireCapability)(gen.capabilities, rule.chainNamespace.startsWith('solana:')
+                ? capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES
+                : capabilities_1.AgenticCapability.UNIVERSAL_EVM_RULES);
+            const chain = rule.chainNamespace;
+            if (chain_1.CHAIN_INFO[chain]?.vm !== enums_1.VM.EVM)
+                throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `unsupported EVM rule chain ${chain}`);
+            const cea = await (0, destination_1.resolveRuleDestination)(runtime, wallet, chain);
+            const assets = rule.assets.length
+                ? rule.assets.map((a) => ({
+                    token: typeof a.token === 'string' && (0, viem_1.getAddress)(a.token) === viem_1.zeroAddress
+                        ? undefined
+                        : a.token,
+                    maxPerCall: a.maxPerCall,
+                    maxTotal: (0, defaults_1.withDefault)(a.maxTotal, defaults_1.AGENTIC_DEFAULTS.universal.assetMaxTotal),
+                }))
+                : [{ token: undefined, maxPerCall: BigInt(0), maxTotal: BigInt(0) }];
+            const resolved = [];
+            for (const [assetIndex, asset] of assets.entries()) {
+                let token;
+                if (asset.token === undefined)
+                    token = await (0, prc20_metadata_1.readGasPrc20)(snap, chain);
                 else {
-                    const source = await (0, prc20_metadata_1.readOriginToken)(snap, token, chain);
-                    if (source !== expected)
-                        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `PRC20 ${token} represents ${source}, not requested token ${expected}`);
+                    try {
+                        token = runtime.resolvePrc20(asset.token, chain);
+                    }
+                    catch (cause) {
+                        throw (0, errors_1.tokenRouteUnavailable)(cause, typeof asset.token === 'string'
+                            ? asset.token
+                            : asset.token.address, chain, assetIndex);
+                    }
+                }
+                if (token === viem_1.zeroAddress)
+                    throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `no gas PRC20 registered for ${chain}`);
+                const namespace = await snap.read(token, prc20_metadata_1.PRC20_SOURCE_ABI, 'SOURCE_CHAIN_NAMESPACE');
+                if (namespace !== chain)
+                    throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.ASSET_CHAIN_MISMATCH, `PRC20 ${token} belongs to ${namespace}, not ${chain}`);
+                if (asset.token !== undefined) {
+                    const expected = typeof asset.token === 'string'
+                        ? (0, viem_1.getAddress)(asset.token)
+                        : (0, viem_1.getAddress)(asset.token.address);
+                    if (expected === viem_1.zeroAddress) {
+                        if ((await (0, prc20_metadata_1.readGasPrc20)(snap, chain)) !== (0, viem_1.getAddress)(token))
+                            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'resolved token is not the registered native gas token');
+                    }
+                    else {
+                        const source = await (0, prc20_metadata_1.readOriginToken)(snap, token, chain);
+                        if (source !== expected)
+                            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `PRC20 ${token} represents ${source}, not requested token ${expected}`);
+                    }
                 }
+                resolved.push({
+                    token: (0, viem_1.getAddress)(token),
+                    maxPerCall: asset.maxPerCall,
+                    maxTotal: asset.maxTotal,
+                });
             }
-            resolved.push({
-                token: (0, viem_1.getAddress)(token),
-                maxPerCall: asset.maxPerCall,
-                maxTotal: asset.maxTotal,
-            });
+            universal.set(rule, { expectedCEA: (0, viem_1.getAddress)(cea), assets: resolved });
+        }
+        catch (error) {
+            throw (0, errors_1.ruleErrorContext)(error, ruleIndex, rule?.chainNamespace);
         }
-        universal.set(rule, { expectedCEA: (0, viem_1.getAddress)(cea), assets: resolved });
     }
     return (0, rules_1.prepareRules)(rules, {
         owner,

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

@@ -36,6 +36,7 @@ const svm_accounts_1 = require("../codec/svm-accounts");
 const svm_idl_1 = require("../codec/svm-idl");
 const svm_terms_1 = require("../codec/svm-terms");
 const svm_terms_2 = require("../codec/svm-terms");
+const errors_1 = require("../errors");
 function svmMetadata(runtime) {
     return (runtime.svmMetadata ??
         (0, svm_metadata_1.createSvmMetadataProvider)({
@@ -62,7 +63,7 @@ async function preparePublicSvmRule(runtime, snap, wallet, rule) {
     const caps = [];
     const tokenAccounts = new Map(), mints = new Set();
     const sources = [];
-    for (const asset of requested) {
+    for (const [assetIndex, asset] of requested.entries()) {
         const source = typeof asset.token === 'string' ? asset.token : asset.token?.address;
         if (typeof source !== 'string')
             throw (0, svm_terms_1.svmInvalid)('asset token requires an address');
@@ -77,9 +78,17 @@ async function preparePublicSvmRule(runtime, snap, wallet, rule) {
         const sourceToken = typeof asset.token === 'string' && key
             ? new web3_js_1.PublicKey((0, viem_1.hexToBytes)(key)).toBase58()
             : asset.token;
-        const token = native
-            ? await (0, prc20_metadata_1.readGasPrc20)(snap, chain)
-            : runtime.resolvePrc20(sourceToken, chain);
+        let token;
+        if (native)
+            token = await (0, prc20_metadata_1.readGasPrc20)(snap, chain);
+        else {
+            try {
+                token = runtime.resolvePrc20(sourceToken, chain);
+            }
+            catch (cause) {
+                throw (0, errors_1.tokenRouteUnavailable)(cause, source, chain, assetIndex);
+            }
+        }
         if (caps.some((c) => c.token === (0, viem_1.getAddress)(token)))
             throw (0, svm_terms_1.svmInvalid)('duplicate SVM asset');
         caps.push({

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

@@ -99,11 +99,10 @@ function buildPresetApi(catalog) {
                 throw invalid('preset options must be an object');
             const now = Math.floor(Date.now() / 1000);
             const network = options.network ?? enums_1.PUSH_NETWORK.TESTNET_DONUT;
-            const funding = options.funding ?? 'push';
             if (!Object.values(enums_1.PUSH_NETWORK).includes(network))
                 throw invalid('unknown preset Push network');
-            if (funding !== 'push' && funding !== 'destination')
-                throw invalid('preset funding must be push or destination');
+            if ('funding' in options)
+                throw invalid('The preset funding option is no longer supported. Remove it; preset assets and limits are always preserved.');
             if (options.agent !== undefined &&
                 (!(0, viem_1.isAddress)(options.agent, { strict: false }) ||
                     (0, viem_1.getAddress)(options.agent) === viem_1.zeroAddress))
@@ -281,8 +280,9 @@ function buildPresetApi(catalog) {
                 }
                 if (!calls.length || calls.length > 32)
                     throw (0, errors_1.capabilityUnavailable)('presetCalls', 'preset must contain 1..32 allowed calls including approvals');
-                if (calls.reduce((n, c) => n + (c.pins?.length ?? 0), 0) > 32)
-                    throw (0, errors_1.capabilityUnavailable)('presetPins', 'preset expansion exceeds 32 pins; reduce the token list or split rules across wallets');
+                const conditionCount = calls.reduce((n, c) => n + (c.pins?.length ?? 0), 0);
+                if (conditionCount > 32)
+                    throw (0, errors_1.ruleConstraintLimit)(conditionCount, calls.length, chain.chainNamespace);
                 const pairs = new Map();
                 for (const call of calls) {
                     if (!/^[A-Za-z_$][\w$]*\(.*\)$/.test(call.selector))
@@ -326,14 +326,13 @@ function buildPresetApi(catalog) {
                         message: 'No asset operation has a positive per-call limit.',
                     });
                 const configurationReady = issues.length === 0;
-                const routes = (0, routes_1.presetRoutes)(chain.chainNamespace, selectedAssets, network, funding);
+                const routes = (0, routes_1.presetRoutes)(chain.chainNamespace, selectedAssets, network);
                 issues.push(...routes.issues);
-                const bridgeAssets = funding === 'destination' ? [] : selectedAssets;
+                const bridgeAssets = selectedAssets;
                 readiness.push({
                     chainNamespace: chain.chainNamespace,
                     ready: issues.length === 0,
                     configurationReady,
-                    funding,
                     selectedAssets: selectedAssets.map((a) => ({
                         ...a,
                         token: typeof a.token === 'string' ? a.token : { ...a.token },

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

@@ -3,7 +3,7 @@ import type { RuleAsset } from '../agentic.types';
 import type { PresetChainReadiness, PresetConfigurationIssue } from './types';
 /** Offline registry checks only. Grant preparation still verifies source metadata
  * and wiring against chain state before any signature or transaction. */
-export declare function presetRoutes(chain: string, assets: RuleAsset[], network: PUSH_NETWORK, funding: 'push' | 'destination'): {
+export declare function presetRoutes(chain: string, assets: RuleAsset[], network: PUSH_NETWORK): {
     bridgeAssets: PresetChainReadiness['bridgeAssets'];
     issues: PresetConfigurationIssue[];
 };