@pushchain/core 6.0.25 → 6.0.27-alpha.0

package/src/lib/agentic/errors.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgenticRevertError = exports.AgenticError = exports.AGENTIC_ERROR_CODE = void 0;
+exports.capabilityUnavailable = capabilityUnavailable;
+const errors_1 = require("../orchestrator/internals/errors");
+/**
+ * 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
+ * unverified capabilities from being mistaken for success.
+ */
+exports.AGENTIC_ERROR_CODE = {
+    // create / rule validation (spec 3.f)
+    DUPLICATE_RULE: 'DUPLICATE_RULE',
+    AGENT_IS_OWNER: 'AGENT_IS_OWNER',
+    AMBIGUOUS_RULE: 'AMBIGUOUS_RULE',
+    TARGET_NOT_ON_RULE_CHAIN: 'TARGET_NOT_ON_RULE_CHAIN',
+    ASSET_CHAIN_MISMATCH: 'ASSET_CHAIN_MISMATCH',
+    // initialize with agenticWallet (spec 3.f)
+    NOT_OWNER_OR_AGENT: 'NOT_OWNER_OR_AGENT',
+    WALLET_NOT_DEPLOYED: 'WALLET_NOT_DEPLOYED',
+    NOT_AGENTIC_WALLET: 'NOT_AGENTIC_WALLET',
+    // rules.delete (spec 3.f)
+    DELETE_NEEDS_TARGET: 'DELETE_NEEDS_TARGET',
+    // sendTransaction (spec 3.f)
+    NO_RULES_FOR_CHAIN: 'NO_RULES_FOR_CHAIN',
+    FROM_NOT_ALLOWED: 'FROM_NOT_ALLOWED',
+    NOT_ALLOWED_IN_AGENTIC_MODE: 'NOT_ALLOWED_IN_AGENTIC_MODE',
+    // SDK-owned
+    INVALID_RULE: 'INVALID_RULE',
+    CAPABILITY_UNAVAILABLE: 'CAPABILITY_UNAVAILABLE',
+    READ_ONLY: 'READ_ONLY',
+    NOT_WALLET_OWNER: 'NOT_WALLET_OWNER',
+    RULE_NOT_FOUND: 'RULE_NOT_FOUND',
+    RULE_READ_FAILED: 'RULE_READ_FAILED',
+    INCONSISTENT_READ: 'INCONSISTENT_READ',
+    INDEX_RACE: 'INDEX_RACE',
+    CREATE_PARTIAL: 'CREATE_PARTIAL',
+    RECEIPT_MISMATCH: 'RECEIPT_MISMATCH',
+    RECEIPT_UNAVAILABLE: 'RECEIPT_UNAVAILABLE',
+    AGENT_GAS_INSUFFICIENT: 'AGENT_GAS_INSUFFICIENT',
+    WALLET_BALANCE_INSUFFICIENT: 'WALLET_BALANCE_INSUFFICIENT',
+    GATEWAY_ALLOWANCE_INSUFFICIENT: 'GATEWAY_ALLOWANCE_INSUFFICIENT',
+};
+/**
+ * Pre-signature AGW failure: invalid input, unsupported capability, failed
+ * eligibility or a read that cannot be trusted. Nothing was signed or sent
+ * unless `details` explicitly records committed hashes (CREATE_PARTIAL).
+ */
+class AgenticError extends Error {
+    code;
+    hint;
+    details;
+    cause;
+    constructor(code, message, opts = {}) {
+        super(message);
+        this.name = 'AgenticError';
+        this.code = code;
+        this.hint = opts.hint;
+        this.details = opts.details;
+        this.cause = opts.cause;
+    }
+}
+exports.AgenticError = AgenticError;
+/**
+ * On-chain AGW, URP, factory or engine revert surfaced from an agentic send.
+ * Extends core's structured execution error so `instanceof
+ * PushChainExecutionError` keeps working, and keeps the underlying cause plus
+ * any batch recovery hashes.
+ */
+class AgenticRevertError extends errors_1.PushChainExecutionError {
+    agenticCode;
+    transactionHashes;
+    pendingTransactionHash;
+    constructor(message, opts = {}) {
+        super(message, {
+            decodedError: opts.decodedError,
+            gatewayTxHash: opts.gatewayTxHash,
+            cause: opts.cause,
+        });
+        this.name = 'AgenticRevertError';
+        this.agenticCode = opts.agenticCode;
+        this.transactionHashes = opts.transactionHashes
+            ? [...opts.transactionHashes]
+            : undefined;
+        this.pendingTransactionHash = opts.pendingTransactionHash;
+    }
+}
+exports.AgenticRevertError = AgenticRevertError;
+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 } });
+}
+//# sourceMappingURL=errors.js.map

package/src/lib/agentic/execution/guards.d.ts

@@ -0,0 +1,9 @@
+import { AgenticError } from '../errors';
+/** Methods the spec forbids on an agentic client (spec 2.a). */
+export type ForbiddenAgenticMethod = 'prepareTransaction' | 'executeTransactions' | 'migrateCEA' | 'rescueFunds' | 'payGasWith';
+export declare function notAllowedInAgenticMode(method: ForbiddenAgenticMethod | string): AgenticError;
+/**
+ * Reject inputs that would execute from somewhere other than the wallet, or
+ * that agentic mode does not support, before any signature or RPC call.
+ */
+export declare function guardAgenticSendParams(params: unknown): void;

package/src/lib/agentic/execution/guards.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notAllowedInAgenticMode = notAllowedInAgenticMode;
+exports.guardAgenticSendParams = guardAgenticSendParams;
+const errors_1 = require("../errors");
+function notAllowedInAgenticMode(method) {
+    return new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.NOT_ALLOWED_IN_AGENTIC_MODE, `${method} is not available on a client initialized with agenticWallet`, {
+        hint: method === 'prepareTransaction' || method === 'executeTransactions'
+            ? 'Use sendTransaction; cascades would run from the signer, not the wallet.'
+            : 'Use a client initialized without agenticWallet for signer-level operations.',
+    });
+}
+/**
+ * Reject inputs that would execute from somewhere other than the wallet, or
+ * that agentic mode does not support, before any signature or RPC call.
+ */
+function guardAgenticSendParams(params) {
+    if (!params || typeof params !== 'object') {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'sendTransaction needs a transaction object');
+    }
+    const p = params;
+    if (p.from !== undefined && p.from !== null) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.FROM_NOT_ALLOWED, '`from` (Routes 3 and 4) is not allowed in agenticWallet mode', { hint: 'A CEA-originated call makes msg.sender a CEA, so the wallet door check would fail.' });
+    }
+    if (p.payGasWith !== undefined)
+        throw notAllowedInAgenticMode('payGasWith');
+    if (p.migration)
+        throw notAllowedInAgenticMode('migrateCEA');
+}
+//# sourceMappingURL=guards.js.map

package/src/lib/agentic/execution/outbound.d.ts

@@ -0,0 +1,55 @@
+import { type Address, type Hex } from 'viem';
+import { CHAIN } from '../../constants/enums';
+import type { MoveableToken } from '../../constants/tokens';
+import type { UniversalExecuteParams, UniversalOutboundTxRequest } from '../../orchestrator/orchestrator.types';
+import type { AgenticGeneration } from '../deployments';
+import type { Call } from '../contracts/v5';
+import type { AgenticRuntime } from '../runtime';
+/** URP MAX_ACTIONS_PER_REQUEST at v5. */
+export declare const MAX_DESTINATION_CALLS = 10;
+export interface DestinationCall {
+    to: Address;
+    value: bigint;
+    data: Hex;
+}
+export interface ComposedOutbound {
+    chain: CHAIN;
+    destinationAccount: Address;
+    destinationAccountDeployed: boolean;
+    token: Address;
+    amount: bigint;
+    /** PC the wallet attaches: protocolFee + maxPCForGas. */
+    value: bigint;
+    request: UniversalOutboundTxRequest;
+    /** The wallet's call into the gateway. */
+    gatewayCall: Call;
+    destinationCalls: DestinationCall[];
+}
+/**
+ * The calls the wallet's destination account (CEA) executes, built exactly as
+ * core's Route 2 builds them for an ordinary account (buildR2CeaPayloadEvm):
+ *  - explicit call arrays are used as given (the caller handles transfers);
+ *  - with ERC-20 funds, a transfer(target, amount) is prepended to a single
+ *    call, or is the whole payload for a transfer-only send;
+ *  - native value (and native funds) goes to the target with the call, or as
+ *    a value-only call; a value transfer to the CEA itself is skipped.
+ * Every encoded call names the requested target, so a response never reports
+ * a delivery the request does not instruct.
+ */
+export declare function destinationCalls(params: UniversalExecuteParams, ctx: {
+    cea: Address;
+    fundsToken?: MoveableToken;
+}): DestinationCall[];
+/**
+ * Compose the AGW-originated EVM outbound (Route 2 shape, wallet context):
+ *  - recipient = empty bytes, revertRecipient = the AGW, maxPCForGas > 0
+ *  - payload   = UEA_MULTICALL ‖ abi.encode(Multicall[1..10]) executed by the AGW's CEA
+ *  - value     = protocolFee + maxPCForGas, paid from the AGW's PC
+ * The destination account is resolved from the AGW, never from the signer.
+ * The SDK never writes a gateway allowance on either door: the gateway pulls
+ * from an allowance the owner set separately with an ordinary send.
+ */
+export declare function composeOutbound(runtime: AgenticRuntime, gen: AgenticGeneration, wallet: Address, params: UniversalExecuteParams, opts: {
+    ruleAssets?: readonly Address[];
+    door: 'owner' | 'agent';
+}): Promise<ComposedOutbound>;

package/src/lib/agentic/execution/outbound.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_DESTINATION_CALLS = void 0;
+exports.destinationCalls = destinationCalls;
+exports.composeOutbound = composeOutbound;
+const viem_1 = require("viem");
+const enums_1 = require("../../constants/enums");
+const chain_1 = require("../../constants/chain");
+const abi_1 = require("../../constants/abi");
+const orchestrator_types_1 = require("../../orchestrator/orchestrator.types");
+const route_handlers_1 = require("../../orchestrator/internals/route-handlers");
+const capabilities_1 = require("../capabilities");
+const v5_1 = require("../contracts/v5");
+const errors_1 = require("../errors");
+/** Includes first-use CEA deployment; explicit caller gas always takes precedence. */
+const FIRST_USE_EVM_GAS_LIMIT = BigInt(2_000_000);
+/** URP MAX_ACTIONS_PER_REQUEST at v5. */
+exports.MAX_DESTINATION_CALLS = 10;
+const MULTICALL_TUPLE = [
+    {
+        type: 'tuple[]',
+        components: [
+            { name: 'to', type: 'address' },
+            { name: 'value', type: 'uint256' },
+            { name: 'data', type: 'bytes' },
+        ],
+    },
+];
+/**
+ * The calls the wallet's destination account (CEA) executes, built exactly as
+ * core's Route 2 builds them for an ordinary account (buildR2CeaPayloadEvm):
+ *  - explicit call arrays are used as given (the caller handles transfers);
+ *  - with ERC-20 funds, a transfer(target, amount) is prepended to a single
+ *    call, or is the whole payload for a transfer-only send;
+ *  - native value (and native funds) goes to the target with the call, or as
+ *    a value-only call; a value transfer to the CEA itself is skipped.
+ * Every encoded call names the requested target, so a response never reports
+ * a delivery the request does not instruct.
+ */
+function destinationCalls(params, ctx) {
+    const target = (0, viem_1.getAddress)(params.to.address);
+    if (Array.isArray(params.data)) {
+        return params.data.map((c) => ({
+            to: (0, viem_1.getAddress)(c.to),
+            value: c.value ?? BigInt(0),
+            data: c.data,
+        }));
+    }
+    const amount = params.funds?.amount ?? BigInt(0);
+    const token = ctx.fundsToken;
+    const erc20 = amount > BigInt(0) && token && token.mechanism !== 'native';
+    const nativeFunds = amount > BigInt(0) && token?.mechanism === 'native' ? amount : BigInt(0);
+    const value = params.value ?? BigInt(0);
+    const calls = [];
+    if (erc20) {
+        calls.push({
+            to: (0, viem_1.getAddress)(token.address),
+            value: BigInt(0),
+            data: (0, viem_1.encodeFunctionData)({
+                abi: abi_1.ERC20_EVM,
+                functionName: 'transfer',
+                args: [target, amount],
+            }),
+        });
+    }
+    const data = params.data && params.data !== '0x' ? params.data : undefined;
+    if (data) {
+        calls.push({ to: target, value: value + nativeFunds, data });
+    }
+    else {
+        const forward = value > BigInt(0) ? value : nativeFunds;
+        if (forward > BigInt(0) && target !== ctx.cea) {
+            calls.push({ to: target, value: forward, data: '0x' });
+        }
+    }
+    return calls;
+}
+/**
+ * Compose the AGW-originated EVM outbound (Route 2 shape, wallet context):
+ *  - recipient = empty bytes, revertRecipient = the AGW, maxPCForGas > 0
+ *  - payload   = UEA_MULTICALL ‖ abi.encode(Multicall[1..10]) executed by the AGW's CEA
+ *  - value     = protocolFee + maxPCForGas, paid from the AGW's PC
+ * The destination account is resolved from the AGW, never from the signer.
+ * The SDK never writes a gateway allowance on either door: the gateway pulls
+ * from an allowance the owner set separately with an ordinary send.
+ */
+async function composeOutbound(runtime, gen, wallet, params, opts) {
+    (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_EVM_OUTBOUND);
+    const target = params.to;
+    const chain = target.chain;
+    const info = chain_1.CHAIN_INFO[chain];
+    if (!info) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `unknown destination chain ${String(chain)}`);
+    }
+    if (info.vm !== enums_1.VM.EVM) {
+        throw (0, errors_1.capabilityUnavailable)(capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES, 'This composer accepts EVM destinations; use the Solana instruction route');
+    }
+    const funds = params.funds;
+    if (funds && (0, orchestrator_types_1.isPC20Reference)(funds.token)) {
+        throw (0, errors_1.capabilityUnavailable)('pc20Outbound', 'PC20 tokens are not supported through an agentic wallet');
+    }
+    // An omitted funds.token means the destination chain's native token, as in Route 2.
+    const fundsToken = funds?.amount
+        ? funds.token
+            ? (0, route_handlers_1.resolveR2DestinationFundsToken)(funds.token, chain, runtime.network)
+            : {
+                symbol: 'native',
+                decimals: 18,
+                address: '0x0000000000000000000000000000000000000000',
+                mechanism: 'native',
+            }
+        : undefined;
+    // Burn token and amount, as Route 2 sizes them for an ordinary account.
+    let token;
+    let amount = BigInt(0);
+    if (funds) {
+        token = runtime.resolvePrc20(funds.token, chain);
+        amount = funds.amount;
+    }
+    else if ((params.value ?? BigInt(0)) > BigInt(0)) {
+        token = runtime.resolvePrc20(undefined, chain);
+        amount = params.value;
+    }
+    else if (opts.ruleAssets?.length) {
+        token = (0, viem_1.getAddress)(opts.ruleAssets[0]);
+    }
+    else {
+        token = runtime.resolvePrc20(undefined, chain);
+    }
+    const resolved = await runtime.resolveCEA(wallet, chain);
+    const cea = (0, viem_1.getAddress)(resolved.cea);
+    const calls = destinationCalls(params, { cea, fundsToken });
+    if (calls.length === 0) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'this outbound carries no destination call; parking funds in the wallet’s destination account is not supported', {
+            hint: 'Name a recipient other than the wallet’s own destination account, or add calldata.',
+        });
+    }
+    if (calls.length > exports.MAX_DESTINATION_CALLS) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `at most ${exports.MAX_DESTINATION_CALLS} destination calls per outbound`);
+    }
+    if (opts.door === 'agent') {
+        const bare = calls.findIndex((c) => (c.data.length - 2) / 2 < 4);
+        if (bare >= 0) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `destination call ${bare} has no function selector; the rules policy only admits allow-listed calls`, {
+                hint: 'A value-only destination transfer is not representable in an agent rule.',
+            });
+        }
+    }
+    const quote = await runtime.quoteOutbound(token, params.gasLimit ??
+        (resolved.isDeployed ? BigInt(0) : FIRST_USE_EVM_GAS_LIMIT), chain);
+    if (quote.nativeValueForGas <= BigInt(0)) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'outbound gas quote returned zero; URP rejects an uncapped gas swap');
+    }
+    const maxPCForGas = quote.nativeValueForGas;
+    const value = quote.protocolFee + maxPCForGas;
+    const payload = (0, viem_1.concat)([
+        v5_1.UEA_MULTICALL_PREFIX,
+        (0, viem_1.encodeAbiParameters)(MULTICALL_TUPLE, [calls]),
+    ]);
+    const request = {
+        recipient: '0x',
+        token,
+        amount,
+        gasLimit: quote.gasLimitUsed,
+        gasPrice: BigInt(0),
+        maxPCForGas,
+        payload,
+        revertRecipient: wallet,
+    };
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: abi_1.UNIVERSAL_GATEWAY_PC,
+        functionName: 'sendUniversalTxOutbound',
+        args: [request],
+    });
+    return {
+        chain,
+        destinationAccount: cea,
+        destinationAccountDeployed: resolved.isDeployed,
+        token,
+        amount,
+        value,
+        request,
+        gatewayCall: { target: gen.addresses.gateway, value, data },
+        destinationCalls: calls,
+    };
+}
+//# sourceMappingURL=outbound.js.map

package/src/lib/agentic/execution/send.d.ts

@@ -0,0 +1,9 @@
+import type { ExecuteParams, TransactionExecutionOptions, UniversalExecuteParams, UniversalTxResponse } from '../../orchestrator/orchestrator.types';
+import type { AgenticExecutionContext } from '../context';
+import type { AgenticRuntime } from '../runtime';
+/**
+ * sendTransaction in agenticWallet mode. Owner door → execute; agent door →
+ * executeAsAgent under the one enabled rule for (signer, destination), looked
+ * up on every send. Everything is validated before the signer is asked.
+ */
+export declare function agenticSend(runtime: AgenticRuntime, actx: AgenticExecutionContext, params: UniversalExecuteParams | ExecuteParams, options?: TransactionExecutionOptions): Promise<UniversalTxResponse>;

package/src/lib/agentic/execution/send.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agenticSend = agenticSend;
+const svm_public_1 = require("./svm-public");
+const viem_1 = require("viem");
+const abi_1 = require("../../constants/abi");
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
+const route_detector_1 = require("../../orchestrator/route-detector");
+const helpers_1 = require("../../orchestrator/internals/helpers");
+const capabilities_1 = require("../capabilities");
+const v5_1 = require("../contracts/v5");
+const ids_1 = require("../codec/ids");
+const errors_1 = require("../errors");
+const common_1 = require("../management/common");
+const rules_1 = require("../reads/rules");
+const snapshot_1 = require("../reads/snapshot");
+const response_1 = require("../response");
+const guards_1 = require("./guards");
+const outbound_1 = require("./outbound");
+const MODE_UNIVERSAL = 0;
+const VM_EVM = 0;
+/** R1's own required-funds estimate when no gasLimit is given (execute-standard). */
+const DEFAULT_GAS_ESTIMATE = BigInt(1e7);
+/** Signer-level fields that legitimately carry over to the wrapped Push tx. */
+function signerFields(p) {
+    const out = {};
+    if (p.gasLimit !== undefined && !(0, route_detector_1.isChainTarget)(p.to))
+        out.gasLimit = p.gasLimit;
+    if (p.maxFeePerGas !== undefined)
+        out.maxFeePerGas = p.maxFeePerGas;
+    if (p.maxPriorityFeePerGas !== undefined)
+        out.maxPriorityFeePerGas = p.maxPriorityFeePerGas;
+    if (p.nonce !== undefined)
+        out.nonce = p.nonce;
+    if (p.deadline !== undefined)
+        out.deadline = p.deadline;
+    if (p.feeLockTxHash !== undefined)
+        out.feeLockTxHash = p.feeLockTxHash;
+    return out;
+}
+/**
+ * Spec 2.a gas rule: in agenticWallet mode an external signer's UEA must
+ * already hold the PC for its Push gas, except for the very first action
+ * while that UEA is undeployed (which takes the one-time origin fee lock).
+ * Mirrors R1's fee-lock condition so an underfunded UEA fails loudly here
+ * instead of silently locking origin funds on every action.
+ */
+async function enforceSignerGas(runtime, gasLimit) {
+    if (runtime.signerIsPushNative())
+        return;
+    if (!(await runtime.signerAccountDeployed()))
+        return;
+    const [gasPrice, balance] = await Promise.all([
+        runtime.getGasPrice(),
+        runtime.signerBalance(),
+    ]);
+    const required = (gasLimit ?? DEFAULT_GAS_ESTIMATE) * gasPrice;
+    if (balance < required) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.AGENT_GAS_INSUFFICIENT, `the signer's UEA ${runtime.signerPushAccount()} holds ${balance} PC wei but needs ~${required} for Push gas`, {
+            hint: "The wallet's PC pays outbound fees, not the signer's gas. Top up the signer's UEA (PushChain.utils.account.deriveExecutorAccount) from a client without agenticWallet.",
+            details: { required, balance },
+        });
+    }
+}
+/**
+ * A ChainTarget naming the connected Push chain is a native send, exactly like
+ * a bare address (core's route detector treats it the same way). A ChainTarget
+ * naming a different Push network is refused rather than routed outbound.
+ */
+function normalizePushDestination(p, runtime) {
+    if (!(0, route_detector_1.isChainTarget)(p.to))
+        return p;
+    const chain = p.to.chain;
+    if (chain === (0, helpers_1.getPushChainForNetwork)(runtime.network)) {
+        return { ...p, to: (0, viem_1.getAddress)(p.to.address) };
+    }
+    if ((0, helpers_1.isPushChain)(chain)) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `destination ${chain} is a Push chain other than the connected network (${runtime.network})`);
+    }
+    return p;
+}
+function toCalls(params) {
+    if (Array.isArray(params.data)) {
+        return params.data.map((c) => ({
+            target: (0, viem_1.getAddress)(c.to),
+            value: c.value ?? BigInt(0),
+            data: c.data,
+        }));
+    }
+    return [
+        {
+            target: (0, viem_1.getAddress)(params.to),
+            value: params.value ?? BigInt(0),
+            data: (params.data ?? '0x'),
+        },
+    ];
+}
+/**
+ * sendTransaction in agenticWallet mode. Owner door → execute; agent door →
+ * executeAsAgent under the one enabled rule for (signer, destination), looked
+ * up on every send. Everything is validated before the signer is asked.
+ */
+async function agenticSend(runtime, actx, params, options) {
+    (0, common_1.assertCanSign)(runtime, 'sendTransaction');
+    (0, guards_1.guardAgenticSendParams)(params);
+    const p = normalizePushDestination(params, runtime);
+    const hook = options?.progressHook ?? p.progressHook;
+    const gen = actx.generation;
+    const wallet = actx.wallet;
+    const outbound = (0, route_detector_1.isChainTarget)(p.to);
+    const destination = outbound
+        ? p.to.chain
+        : runtime.pushChainNamespace;
+    if (!outbound && p.funds) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.NOT_ALLOWED_IN_AGENTIC_MODE, "`funds` on a Push-chain send would bridge from the signer; it does not move the wallet's tokens", {
+            hint: "Transfer the wallet's PRC20 with a token transfer call in `data`.",
+        });
+    }
+    if (outbound && destination.startsWith('solana:')) {
+        await enforceSignerGas(runtime, undefined);
+        return (0, svm_public_1.sendPublicSvm)(runtime, actx, p, options);
+    }
+    let wrappedData;
+    let agentBatch;
+    let nativeCalls;
+    let rulesId;
+    let logical;
+    let meta = {};
+    let outboundChain;
+    let destinationCalls;
+    if (actx.door === 'agent') {
+        (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.AGENT_EXECUTE);
+    }
+    else {
+        (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.OWNER_EXECUTE);
+    }
+    if (!outbound) {
+        const calls = toCalls(p);
+        if (calls.length === 0)
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'an empty call array cannot execute');
+        if (actx.door === 'owner') {
+            wrappedData = gen.contracts.encodeExecute(calls);
+        }
+        else {
+            const snap = await snapshot_1.Snapshot.at(runtime.reader);
+            const rule = await (0, rules_1.selectRuleForSend)(snap, gen, wallet, actx.signerPushAccount, destination);
+            rulesId = rule.rulesId;
+            wrappedData = gen.contracts.encodeExecuteAsAgent(rule.rulesId, calls[0]);
+            if (calls.length > 1) {
+                agentBatch = calls.map((call) => ({
+                    to: wallet,
+                    value: BigInt(0),
+                    data: gen.contracts.encodeExecuteAsAgent(rule.rulesId, call),
+                }));
+                nativeCalls = calls;
+            }
+        }
+        logical =
+            calls.length === 1
+                ? { to: calls[0].target, data: calls[0].data, value: calls[0].value }
+                : agentBatch
+                    ? { to: calls[0].target, data: calls[0].data, value: calls[0].value }
+                    : { to: wallet, data: wrappedData, value: BigInt(0) };
+    }
+    else {
+        let ruleAssets;
+        let expectedCEA;
+        const snap = await snapshot_1.Snapshot.at(runtime.reader);
+        if (actx.door === 'agent') {
+            const rule = await (0, rules_1.selectRuleForSend)(snap, gen, wallet, actx.signerPushAccount, destination);
+            if (rule.mode !== MODE_UNIVERSAL || rule.vm !== VM_EVM) {
+                throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `rule ${rule.rulesId} is not an EVM universal rule`);
+            }
+            rulesId = rule.rulesId;
+            const cfg = await snap.read(gen.addresses.rulesPolicy, gen.contracts.abis.policy, 'getConfig', [
+                (0, ids_1.configId)(wallet, rule.rulesId, (0, ids_1.actionId)(gen.addresses.gateway, v5_1.SEND_OUTBOUND_SELECTOR)),
+                wallet,
+            ]);
+            ruleAssets = cfg.assets.map((a) => (0, viem_1.getAddress)(a.token));
+            expectedCEA = (0, viem_1.getAddress)(cfg.expectedCEA);
+        }
+        const out = await (0, outbound_1.composeOutbound)(runtime, gen, wallet, p, {
+            ruleAssets,
+            door: actx.door,
+        });
+        outboundChain = out.chain;
+        meta = { route: 'UOA_TO_CEA', destinationAccount: out.destinationAccount };
+        const [walletPc, tokenBalance, allowance] = await Promise.all([
+            runtime.reader.getBalance({
+                address: wallet,
+                blockNumber: snap.blockNumber,
+            }),
+            out.amount > BigInt(0)
+                ? snap.read(out.token, abi_1.ERC20_EVM, 'balanceOf', [wallet])
+                : Promise.resolve(BigInt(0)),
+            snap.read(out.token, abi_1.ERC20_EVM, 'allowance', [wallet, gen.addresses.gateway]),
+        ]);
+        if (walletPc < out.value) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.WALLET_BALANCE_INSUFFICIENT, `wallet ${wallet} holds ${walletPc} PC wei; this outbound needs ${out.value} (protocol fee + gas cap)`, { hint: "Fund the wallet's PC with an ordinary send to its address." });
+        }
+        if (tokenBalance < out.amount) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.WALLET_BALANCE_INSUFFICIENT, `wallet ${wallet} holds ${tokenBalance} of ${out.token}; this outbound burns ${out.amount}`);
+        }
+        // Both doors only consume an allowance the owner set separately; the SDK
+        // never writes one (a write from a stale read could restore revoked authority).
+        if (out.amount > allowance) {
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.GATEWAY_ALLOWANCE_INSUFFICIENT, `the gateway may pull ${allowance} of ${out.token} from the wallet; this outbound needs ${out.amount}`, {
+                hint: 'Set a bounded allowance first with an owner-door send: approve(gateway, cap) on the token (approve(gateway, 0) removes it).',
+            });
+        }
+        if (actx.door === 'agent') {
+            if (expectedCEA && expectedCEA !== out.destinationAccount) {
+                throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INCONSISTENT_READ, `rule ${rulesId} committed destination account ${expectedCEA}, but the wallet's account on ${out.chain} now derives to ${out.destinationAccount}`, {
+                    hint: 'Destination-account derivation drift (obligation 13). The owner must regrant the rule.',
+                });
+            }
+            wrappedData = gen.contracts.encodeExecuteAsAgent(rulesId, out.gatewayCall);
+        }
+        else {
+            wrappedData = gen.contracts.encodeExecute([out.gatewayCall]);
+        }
+        destinationCalls = out.destinationCalls;
+        logical = (0, response_1.outboundResponseCall)(destinationCalls, {
+            to: out.gatewayCall.target,
+            data: out.gatewayCall.data,
+            value: out.gatewayCall.value,
+        });
+    }
+    await enforceSignerGas(runtime, signerFields(p).gasLimit);
+    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_107, rulesId, outboundChain ?? destination, actx.door);
+    let resp;
+    try {
+        const sendOptions = hook ? { ...options, progressHook: hook } : options;
+        resp = agentBatch
+            ? await runtime.executeAtomicBatch({
+                ...signerFields(p),
+                to: wallet,
+                value: BigInt(0),
+                data: agentBatch,
+            }, sendOptions)
+            : await runtime.execute({
+                ...signerFields(p),
+                to: wallet,
+                value: BigInt(0),
+                data: wrappedData,
+            }, sendOptions);
+    }
+    catch (err) {
+        const wrapped = (0, common_1.wrapSendError)(err);
+        (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_199_02, 'sendTransaction', wrapped?.code ?? 'UNKNOWN', wrapped?.message ?? String(err), wrapped?.decodedError);
+        throw wrapped;
+    }
+    (0, response_1.adaptAgenticResponse)(resp, {
+        wallet,
+        door: actx.door,
+        rulesId,
+        chainNamespace: outboundChain ?? destination,
+        destinationAccount: meta.destinationAccount,
+        destinationCalls,
+        ...(nativeCalls
+            ? {
+                nativeCalls: nativeCalls.map((c) => ({
+                    to: c.target,
+                    data: c.data,
+                    value: c.value,
+                })),
+            }
+            : {}),
+        logical,
+        route: meta.route,
+        chain: outboundChain,
+    });
+    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_199_01, 'sendTransaction', resp.hash);
+    return resp;
+}
+//# sourceMappingURL=send.js.map