@pushchain/core 6.0.25 → 6.0.27-alpha.0

package/src/lib/agentic/execution/svm-instruction.d.ts

@@ -0,0 +1,24 @@
+import type { CHAIN } from '../../constants/enums';
+import type { SvmTermsWire } from '../codec/svm-terms';
+import { type SvmPayloadAccount } from './svm-payload';
+import type { Address } from 'viem';
+/** Resolve IDL accounts with the wallet authority; granted permissions are checked by URP. */
+export declare function resolveAgwSvmInstruction(input: {
+    wallet: Address;
+    chain: CHAIN;
+    program: string;
+    instructionData: Uint8Array;
+    accounts?: readonly SvmPayloadAccount[];
+}, terms: SvmTermsWire): {
+    recipient: `0x${string}`;
+    payload: `0x${string}`;
+    accounts: SvmPayloadAccount[];
+    instructionData: Uint8Array;
+};
+/** Diagnostic-only local policy preview. Sends use the resolver and contract enforcement. */
+export declare function prepareAgwSvmInstruction(input: Parameters<typeof resolveAgwSvmInstruction>[0], terms: SvmTermsWire): {
+    recipient: `0x${string}`;
+    payload: `0x${string}`;
+    accounts: SvmPayloadAccount[];
+    instructionData: Uint8Array;
+};

package/src/lib/agentic/execution/svm-instruction.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAgwSvmInstruction = resolveAgwSvmInstruction;
+exports.prepareAgwSvmInstruction = prepareAgwSvmInstruction;
+const resolve_1 = require("../../orchestrator/svm-idl/resolve");
+const svm_accounts_1 = require("../codec/svm-accounts");
+const svm_payload_1 = require("./svm-payload");
+/** Resolve IDL accounts with the wallet authority; granted permissions are checked by URP. */
+function resolveAgwSvmInstruction(input, terms) {
+    const program = (0, svm_accounts_1.svmKey)(input.program);
+    if (input.accounts) {
+        const payload = (0, svm_payload_1.encodeAgwSvmPayload)(program, input.accounts, input.instructionData);
+        return {
+            recipient: program,
+            payload,
+            accounts: [...input.accounts],
+            instructionData: input.instructionData,
+        };
+    }
+    const resolved = (0, resolve_1.resolveSvmCallForCea)({
+        programAddress: program,
+        data: input.instructionData,
+        senderUea: input.wallet,
+        targetChain: input.chain,
+    }, terms.expectedCEA);
+    const payload = (0, svm_payload_1.encodeAgwSvmPayload)(resolved.targetProgram, resolved.accounts, resolved.ixData);
+    return {
+        recipient: program,
+        payload,
+        accounts: resolved.accounts,
+        instructionData: resolved.ixData,
+    };
+}
+/** Diagnostic-only local policy preview. Sends use the resolver and contract enforcement. */
+function prepareAgwSvmInstruction(input, terms) {
+    const resolved = resolveAgwSvmInstruction(input, terms);
+    (0, svm_payload_1.validateAgwSvmPayload)(terms, resolved.recipient, resolved.payload);
+    return resolved;
+}
+//# sourceMappingURL=svm-instruction.js.map

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

@@ -0,0 +1,18 @@
+/** Outbound encoding plus a diagnostic-only policy preview. */
+import { type Address, type Hex } from 'viem';
+import type { Call, SvmConfigRead } from '../contracts/v5';
+export interface SvmOutboundInput {
+    wallet: Address;
+    gateway: Address;
+    token: Address;
+    amount: bigint;
+    recipient: Hex;
+    payload: Hex;
+    gasLimit: bigint;
+    protocolFee: bigint;
+    maxPCForGas: bigint;
+}
+/** Diagnostic-only local preview; production sends use buildAgwSvmAction. */
+export declare function composeAgwSvmAction(input: SvmOutboundInput, config: SvmConfigRead, nowSeconds: number): Call;
+/** Encode an outbound without evaluating the granted policy; the wallet/URP enforces it. */
+export declare function buildAgwSvmAction(input: SvmOutboundInput): Call;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeAgwSvmAction = composeAgwSvmAction;
+exports.buildAgwSvmAction = buildAgwSvmAction;
+/** Outbound encoding plus a diagnostic-only policy preview. */
+const viem_1 = require("viem");
+const abi_1 = require("../../constants/abi");
+const errors_1 = require("../errors");
+const defaults_1 = require("../codec/defaults");
+const svm_terms_1 = require("../codec/svm-terms");
+const svm_payload_1 = require("./svm-payload");
+/** Diagnostic-only local preview; production sends use buildAgwSvmAction. */
+function composeAgwSvmAction(input, config, nowSeconds) {
+    function fail(name) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, name, {
+            details: { contractError: name },
+        });
+    }
+    if (!config.initialized)
+        fail('NotInitialized');
+    if (nowSeconds > config.validUntil)
+        fail('RulesExpired');
+    for (const [name, value] of Object.entries({
+        amount: input.amount,
+        gasLimit: input.gasLimit,
+        protocolFee: input.protocolFee,
+        maxPCForGas: input.maxPCForGas,
+    })) {
+        if (typeof value !== 'bigint' || value < BigInt(0) || value > defaults_1.UINT256_MAX)
+            fail(`${name}OutOfRange`);
+    }
+    const token = (0, viem_1.getAddress)(input.token), cap = config.assets.find((a) => (0, viem_1.getAddress)(a.token) === token);
+    if (!cap)
+        fail('AssetNotAllowed');
+    if (input.amount > svm_terms_1.UINT64_MAX)
+        fail('AmountExceedsU64');
+    if (input.amount > cap.maxPerCall)
+        fail('AmountExceedsCap');
+    if (cap.spent + input.amount > cap.maxTotal)
+        fail('TotalSpendCapExceeded');
+    const value = input.protocolFee + input.maxPCForGas;
+    if (value > defaults_1.UINT256_MAX || value > config.maxGasPerCall)
+        fail('PCValueExceedsCap');
+    if (!input.maxPCForGas)
+        fail('UncappedGasSwapRejected');
+    (0, svm_payload_1.validateAgwSvmPayload)(config, input.recipient, input.payload);
+    return buildAgwSvmAction(input);
+}
+/** Encode an outbound without evaluating the granted policy; the wallet/URP enforces it. */
+function buildAgwSvmAction(input) {
+    for (const [name, value] of Object.entries({
+        amount: input.amount,
+        gasLimit: input.gasLimit,
+        protocolFee: input.protocolFee,
+        maxPCForGas: input.maxPCForGas,
+    })) {
+        if (typeof value !== 'bigint' || value < BigInt(0) || value > defaults_1.UINT256_MAX)
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, `${name} must fit uint256`);
+    }
+    if (input.amount > svm_terms_1.UINT64_MAX)
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'Solana amount must fit uint64');
+    const value = input.protocolFee + input.maxPCForGas;
+    if (value > defaults_1.UINT256_MAX || input.maxPCForGas === BigInt(0))
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, 'invalid outbound gas quote');
+    const token = (0, viem_1.getAddress)(input.token);
+    const request = {
+        recipient: input.recipient,
+        token,
+        amount: input.amount,
+        gasLimit: input.gasLimit,
+        gasPrice: BigInt(0),
+        maxPCForGas: input.maxPCForGas,
+        payload: input.payload,
+        revertRecipient: (0, viem_1.getAddress)(input.wallet),
+    };
+    return {
+        target: (0, viem_1.getAddress)(input.gateway),
+        value,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: abi_1.UNIVERSAL_GATEWAY_PC,
+            functionName: 'sendUniversalTxOutbound',
+            args: [request],
+        }),
+    };
+}
+//# sourceMappingURL=svm-outbound.js.map

package/src/lib/agentic/execution/svm-payload.d.ts

@@ -0,0 +1,18 @@
+/** Parser/validator for the deployed S12–S18 instruction grammar. */
+import { type Hex } from 'viem';
+import { type SvmTermsWire } from '../codec/svm-terms';
+export interface SvmPayloadAccount {
+    pubkey: Hex;
+    isWritable: boolean;
+}
+export interface ParsedSvmPayload {
+    program: Hex;
+    accounts: (SvmPayloadAccount & {
+        writableFlag: number;
+    })[];
+    instructionData: Uint8Array;
+}
+export declare function parseAgwSvmPayload(payload: Hex): ParsedSvmPayload;
+export declare function encodeAgwSvmPayload(program: Hex, accounts: readonly SvmPayloadAccount[], instructionData: Uint8Array): Hex;
+/** Terms must have passed grant-shape validation. On-chain URP remains the enforcement authority. */
+export declare function validateAgwSvmPayload(terms: SvmTermsWire, recipient: Hex, payload: Hex): number;

package/src/lib/agentic/execution/svm-payload.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAgwSvmPayload = parseAgwSvmPayload;
+exports.encodeAgwSvmPayload = encodeAgwSvmPayload;
+exports.validateAgwSvmPayload = validateAgwSvmPayload;
+/** Parser/validator for the deployed S12–S18 instruction grammar. */
+const viem_1 = require("viem");
+const payload_builders_1 = require("../../orchestrator/payload-builders");
+const errors_1 = require("../errors");
+const svm_terms_1 = require("../codec/svm-terms");
+function fail(name) {
+    throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.INVALID_RULE, name, {
+        details: { contractError: name },
+    });
+}
+function parseAgwSvmPayload(payload) {
+    if (!/^0x(?:[0-9a-fA-F]{2})*$/.test(payload))
+        fail('MalformedSvmPayload');
+    const bytes = (0, viem_1.hexToBytes)(payload);
+    if (!bytes.length)
+        fail('SvmPayloadEmpty');
+    if (bytes.length < 41)
+        fail('MalformedSvmPayload');
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength), count = view.getUint32(0, false);
+    if (count > svm_terms_1.SVM_LIMITS.accounts)
+        fail('SvmAccountsOutOfRange');
+    const lenOffset = 4 + count * 33;
+    if (bytes.length < lenOffset + 4)
+        fail('MalformedSvmPayload');
+    const length = view.getUint32(lenOffset, false);
+    if (length > svm_terms_1.SVM_LIMITS.ixData)
+        fail('SvmIxDataTooLong');
+    const dataOffset = lenOffset + 4;
+    if (bytes.length !== dataOffset + length + 33)
+        fail('MalformedSvmPayload');
+    if (bytes[dataOffset + length] !== 2)
+        fail('SvmInstructionNotExecute');
+    const accounts = Array.from({ length: count }, (_, i) => {
+        const offset = 4 + i * 33, writableFlag = bytes[offset + 32];
+        // URP does not judge this flag. Preserve the raw value for diagnostics.
+        return {
+            pubkey: (0, viem_1.bytesToHex)(bytes.slice(offset, offset + 32)),
+            isWritable: writableFlag === 1,
+            writableFlag,
+        };
+    });
+    return {
+        program: (0, viem_1.bytesToHex)(bytes.slice(dataOffset + length + 1)),
+        accounts,
+        instructionData: bytes.slice(dataOffset, dataOffset + length),
+    };
+}
+function encodeAgwSvmPayload(program, accounts, instructionData) {
+    (0, svm_terms_1.exactHex)(program, 32, 'target program');
+    if (accounts.length > svm_terms_1.SVM_LIMITS.accounts)
+        fail('SvmAccountsOutOfRange');
+    if (instructionData.length > svm_terms_1.SVM_LIMITS.ixData)
+        fail('SvmIxDataTooLong');
+    accounts.forEach((a) => {
+        (0, svm_terms_1.exactHex)(a.pubkey, 32, 'account');
+        if (typeof a.isWritable !== 'boolean')
+            fail('MalformedSvmPayload');
+    });
+    return (0, payload_builders_1.encodeSvmExecutePayload)({
+        targetProgram: program,
+        accounts: [...accounts],
+        ixData: instructionData,
+        instructionId: 2,
+    });
+}
+function uintLE(data) {
+    return data.reduceRight((v, b) => (v << BigInt(8)) + BigInt(b), BigInt(0));
+}
+/** Terms must have passed grant-shape validation. On-chain URP remains the enforcement authority. */
+function validateAgwSvmPayload(terms, recipient, payload) {
+    (0, svm_terms_1.exactHex)(recipient, 32, 'recipient');
+    if (BigInt(recipient) === BigInt(0))
+        fail('RecipientNotPubkey');
+    const v = parseAgwSvmPayload(payload), data = v.instructionData;
+    if (v.program.toLowerCase() !== recipient.toLowerCase())
+        fail('RecipientTargetMismatch');
+    if ((0, svm_terms_1.isForbiddenSvmProgram)(v.program, terms))
+        fail('ForbiddenTargetProgram');
+    const rule = terms.programs.findIndex((p) => p.program.toLowerCase() === v.program.toLowerCase() &&
+        (p.dataless
+            ? data.length === 0
+            : data.length >= p.discriminatorLen &&
+                (0, viem_1.bytesToHex)(data.slice(0, p.discriminatorLen)).toLowerCase() ===
+                    p.discriminator.slice(0, 2 + p.discriminatorLen * 2).toLowerCase()));
+    if (rule < 0)
+        fail('ProgramNotAllowed');
+    const fixed = terms.programs[rule].maxAccounts;
+    if (fixed && fixed !== v.accounts.length)
+        fail('SvmAccountCountMismatch');
+    const pins = terms.pins.filter((p) => p.ruleIndex === rule);
+    for (const p of pins) {
+        if (p.accountIndex >= v.accounts.length)
+            fail('SvmAccountCountBelowPin');
+        if (v.accounts[p.accountIndex].pubkey.toLowerCase() !==
+            p.expected.toLowerCase())
+            fail('SvmAccountPinMismatch');
+    }
+    function field(fromEnd, offset, len) {
+        const start = fromEnd ? data.length - offset : offset;
+        if (start < 0 || start + len > data.length)
+            fail('SvmDataTooShortForPin');
+        return data.slice(start, start + len);
+    }
+    for (const p of terms.dataPins.filter((p) => p.ruleIndex === rule)) {
+        const a = field(p.fromEnd, p.offset, p.len);
+        if (p.mode === svm_terms_1.SvmDataPinMode.EQ) {
+            if ((0, viem_1.bytesToHex)(a).toLowerCase() !==
+                p.expected.slice(0, 2 + p.len * 2).toLowerCase())
+                fail('SvmDataPinMismatch');
+        }
+        else if (p.mode === svm_terms_1.SvmDataPinMode.GTE_LE) {
+            if (uintLE(a) < BigInt(p.expected))
+                fail('SvmDataFloorNotMet');
+        }
+        else if (p.mode === svm_terms_1.SvmDataPinMode.LTE_LE) {
+            if (uintLE(a) > BigInt(p.expected))
+                fail('SvmDataCeilingExceeded');
+        }
+        else if (uintLE(a) * p.den <
+            uintLE(field(p.fromEnd, p.offsetB, p.len)) * p.num)
+            fail('SvmDataRatioNotMet');
+    }
+    const protectedKeys = new Set(terms.ceaAccounts.map((k) => k.toLowerCase()));
+    v.accounts.forEach((a, i) => {
+        if (protectedKeys.has(a.pubkey.toLowerCase()) &&
+            !pins.some((p) => p.accountIndex === i))
+            fail('CeaAccountAtUnpinnedIndex');
+    });
+    return rule;
+}
+//# sourceMappingURL=svm-payload.js.map

package/src/lib/agentic/execution/svm-public.d.ts

@@ -0,0 +1,5 @@
+import { type UniversalExecuteParams, type TransactionExecutionOptions } from '../../orchestrator/orchestrator.types';
+import type { AgenticRuntime } from '../runtime';
+import type { AgenticExecutionContext } from '../context';
+/** Public single-instruction route; the contract enforces the supplied rule. */
+export declare function sendPublicSvm(runtime: AgenticRuntime, actx: AgenticExecutionContext, p: UniversalExecuteParams, options?: TransactionExecutionOptions): Promise<import("../../orchestrator/orchestrator.types").UniversalTxResponse>;

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendPublicSvm = sendPublicSvm;
+const progress_hook_types_1 = require("../../progress-hook/progress-hook.types");
+const common_1 = require("../management/common");
+const viem_1 = require("viem");
+const orchestrator_types_1 = require("../../orchestrator/orchestrator.types");
+const resolve_1 = require("../../orchestrator/svm-idl/resolve");
+const capabilities_1 = require("../capabilities");
+const rules_1 = require("../reads/rules");
+const svm_1 = require("../reads/svm");
+const snapshot_1 = require("../reads/snapshot");
+const svm_public_1 = require("../management/svm-public");
+const common_2 = require("../management/common");
+const svm_accounts_1 = require("../codec/svm-accounts");
+const svm_terms_1 = require("../codec/svm-terms");
+const errors_1 = require("../errors");
+const svm_send_1 = require("./svm-send");
+const svm_payload_1 = require("./svm-payload");
+const svm_quote_1 = require("./svm-quote");
+const svm_outbound_1 = require("./svm-outbound");
+const response_1 = require("../response");
+/** Public single-instruction route; the contract enforces the supplied rule. */
+async function sendPublicSvm(runtime, actx, p, options) {
+    const gen = actx.generation, wallet = actx.wallet;
+    (0, capabilities_1.requireCapability)(gen.capabilities, capabilities_1.AgenticCapability.UNIVERSAL_SVM_RULES);
+    (0, capabilities_1.requireCapability)(gen.capabilities, actx.door === 'agent'
+        ? capabilities_1.AgenticCapability.AGENT_EXECUTE
+        : capabilities_1.AgenticCapability.OWNER_EXECUTE);
+    const to = p.to;
+    const target = (0, svm_accounts_1.svmKey)(to.address);
+    if (Array.isArray(p.data))
+        throw (0, svm_terms_1.svmInvalid)('Solana AGW sends do not support instruction arrays');
+    const hasInstruction = p.data !== undefined && p.data !== '0x';
+    if (hasInstruction &&
+        (typeof p.data !== 'string' || !/^0x(?:[0-9a-fA-F]{2})+$/.test(p.data)))
+        throw (0, svm_terms_1.svmInvalid)('invalid Solana instruction bytes');
+    if (!hasInstruction && actx.door === 'agent')
+        throw (0, svm_terms_1.svmInvalid)('Solana agent sends require an encoded instruction');
+    if (p.funds && (0, orchestrator_types_1.isPC20Reference)(p.funds.token))
+        throw (0, svm_terms_1.svmInvalid)('PC20 SVM outbound is not supported');
+    if (p.funds && (p.value ?? BigInt(0)) !== BigInt(0))
+        throw (0, svm_terms_1.svmInvalid)('use either funds or value for the bridged amount');
+    const amount = p.funds?.amount ?? p.value ?? BigInt(0);
+    if (typeof amount !== 'bigint' || amount < BigInt(0) || amount > svm_terms_1.UINT64_MAX)
+        throw (0, svm_terms_1.svmInvalid)('Solana outbound amount must fit uint64');
+    if (!hasInstruction && amount === BigInt(0))
+        throw (0, svm_terms_1.svmInvalid)('a funds-only send requires a positive amount');
+    const metadata = (0, svm_public_1.svmMetadata)(runtime), snap = await snapshot_1.Snapshot.at(runtime.reader);
+    let rulesId, data, instruction, cea;
+    let destinationTransfer;
+    let transferValue = BigInt(0);
+    const gasLimit = p.gasLimit ?? BigInt(1_000_000);
+    if (actx.door === 'agent') {
+        const active = await (0, rules_1.selectRuleForSend)(snap, gen, wallet, actx.signerPushAccount, to.chain);
+        const stored = await (0, svm_1.readSvmConfig)(snap, gen, wallet, active, runtime.pushChainNamespace);
+        const token = p.funds || amount > BigInt(0)
+            ? runtime.resolvePrc20(p.funds?.token, to.chain)
+            : (0, viem_1.getAddress)(stored.config.assets[0].token);
+        const prepared = await (0, svm_send_1.prepareSvmAgentExecution)(runtime, gen, {
+            wallet,
+            rulesId: active.rulesId,
+            token,
+            amount,
+            gasLimit,
+            program: target,
+            instructionData: (0, viem_1.hexToBytes)(p.data),
+        }, metadata);
+        data = prepared.data;
+        instruction = prepared.instruction;
+        cea = stored.config.expectedCEA;
+        rulesId = active.rulesId;
+    }
+    else {
+        const gateway = await metadata.gateway(to.chain);
+        cea = (0, svm_accounts_1.deriveAgwSvmCea)(wallet, gateway.program).address;
+        const resolved = hasInstruction
+            ? (0, resolve_1.resolveSvmCallForCea)({
+                programAddress: target,
+                data: (0, viem_1.hexToBytes)(p.data),
+                senderUea: wallet,
+                targetChain: to.chain,
+            }, cea)
+            : undefined;
+        if (resolved)
+            instruction = {
+                recipient: resolved.targetProgram,
+                instructionData: resolved.ixData,
+                accounts: resolved.accounts,
+            };
+        const token = runtime.resolvePrc20(p.funds?.token, to.chain);
+        const quote = await (0, svm_quote_1.quoteSvmRequest)(runtime, snap, wallet, token, to.chain, gasLimit, amount);
+        if (!hasInstruction) {
+            destinationTransfer = { recipient: target, token, amount };
+            transferValue = quote.isNative ? amount : BigInt(0);
+        }
+        const [pc, balance, allowance] = await Promise.all([
+            runtime.reader.getBalance({
+                address: wallet,
+                blockNumber: snap.blockNumber,
+            }),
+            snap.read(token, viem_1.erc20Abi, 'balanceOf', [wallet]),
+            snap.read(token, viem_1.erc20Abi, 'allowance', [
+                wallet,
+                gen.addresses.gateway,
+            ]),
+        ]);
+        const value = quote.protocolFee + quote.nativeValueForGas;
+        if (pc < value || balance < amount)
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.WALLET_BALANCE_INSUFFICIENT, 'wallet cannot cover Solana outbound');
+        if (allowance < amount)
+            throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.GATEWAY_ALLOWANCE_INSUFFICIENT, 'set the wallet gateway allowance separately');
+        const call = (0, svm_outbound_1.buildAgwSvmAction)({
+            wallet,
+            gateway: gen.addresses.gateway,
+            token,
+            amount,
+            recipient: target,
+            payload: resolved
+                ? (0, svm_payload_1.encodeAgwSvmPayload)(resolved.targetProgram, resolved.accounts, resolved.ixData)
+                : '0x',
+            gasLimit: quote.gasLimitUsed,
+            protocolFee: quote.protocolFee,
+            maxPCForGas: quote.nativeValueForGas,
+        });
+        data = gen.contracts.encodeExecute([call]);
+    }
+    const hook = options?.progressHook ?? p.progressHook;
+    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_107, rulesId, to.chain, actx.door);
+    let response;
+    try {
+        response = await runtime.execute({
+            to: wallet,
+            value: BigInt(0),
+            data,
+            ...(p.nonce === undefined ? {} : { nonce: p.nonce }),
+            ...(p.maxFeePerGas === undefined
+                ? {}
+                : { maxFeePerGas: p.maxFeePerGas }),
+            ...(p.maxPriorityFeePerGas === undefined
+                ? {}
+                : { maxPriorityFeePerGas: p.maxPriorityFeePerGas }),
+            ...(p.deadline === undefined ? {} : { deadline: p.deadline }),
+            ...(p.feeLockTxHash === undefined
+                ? {}
+                : { feeLockTxHash: p.feeLockTxHash }),
+        }, { ...options, progressHook: options?.progressHook ?? p.progressHook });
+    }
+    catch (error) {
+        const wrapped = (0, common_2.wrapSendError)(error);
+        (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_199_02, 'sendTransaction', wrapped.code ?? 'UNKNOWN', wrapped.message, wrapped.decodedError);
+        throw wrapped;
+    }
+    const result = (0, response_1.adaptAgenticResponse)(response, {
+        wallet,
+        door: actx.door,
+        rulesId,
+        chainNamespace: to.chain,
+        chain: to.chain,
+        route: 'UOA_TO_CEA',
+        ...(instruction
+            ? {
+                destinationAccount: cea,
+                destinationInstruction: {
+                    program: instruction.recipient,
+                    data: (0, viem_1.bytesToHex)(instruction.instructionData),
+                    accounts: instruction.accounts,
+                },
+            }
+            : { destinationTransfer }),
+        logical: instruction
+            ? {
+                to: instruction.recipient,
+                data: (0, viem_1.bytesToHex)(instruction.instructionData),
+                value: BigInt(0),
+            }
+            : { to: target, data: '0x', value: transferValue },
+    });
+    (0, common_1.emitAgentic)(runtime, hook, progress_hook_types_1.PROGRESS_HOOK.AGENTIC_TX_199_01, 'sendTransaction', response.hash);
+    return result;
+}
+//# sourceMappingURL=svm-public.js.map

package/src/lib/agentic/execution/svm-quote.d.ts

@@ -0,0 +1,11 @@
+import { type Address } from 'viem';
+import type { CHAIN } from '../../constants/enums';
+import type { AgenticRuntime } from '../runtime';
+import type { Snapshot } from '../reads/snapshot';
+/** Route/fee validation, independent of the selected rule's permissions. */
+export declare function quoteSvmRequest(runtime: AgenticRuntime, snap: Snapshot, wallet: Address, token: Address, chain: CHAIN, gasLimit: bigint, amount: bigint): Promise<{
+    isNative: boolean;
+    protocolFee: bigint;
+    nativeValueForGas: bigint;
+    gasLimitUsed: bigint;
+}>;

package/src/lib/agentic/execution/svm-quote.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteSvmRequest = quoteSvmRequest;
+const web3_js_1 = require("@solana/web3.js");
+const viem_1 = require("viem");
+const prc20_metadata_1 = require("../contracts/prc20-metadata");
+const errors_1 = require("../errors");
+/** Route/fee validation, independent of the selected rule's permissions. */
+async function quoteSvmRequest(runtime, snap, wallet, token, chain, gasLimit, amount) {
+    if ((await snap.read(token, prc20_metadata_1.PRC20_SOURCE_ABI, 'SOURCE_CHAIN_NAMESPACE')) !== chain) {
+        throw new errors_1.AgenticError(errors_1.AGENTIC_ERROR_CODE.ASSET_CHAIN_MISMATCH, 'outbound asset belongs to another chain');
+    }
+    const isNative = (0, viem_1.getAddress)(token) === (0, viem_1.getAddress)(await (0, prc20_metadata_1.readGasPrc20)(snap, chain));
+    const splMintBase58 = !isNative && amount > BigInt(0)
+        ? new web3_js_1.PublicKey((0, viem_1.hexToBytes)(await (0, prc20_metadata_1.readSvmSourceToken)(snap, token, chain, runtime.network))).toBase58()
+        : undefined;
+    const quote = await runtime.quoteOutbound(token, gasLimit, chain, {
+        wallet,
+        splMintBase58,
+        burnAmount: amount,
+    });
+    return { ...quote, isNative };
+}
+//# sourceMappingURL=svm-quote.js.map

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

@@ -0,0 +1,44 @@
+/** Prepared-wire agent execution used by the public Solana route. */
+import { type Address, type Hex } from 'viem';
+import type { AgenticGeneration } from '../deployments';
+import type { AgenticRuntime } from '../runtime';
+import { type SvmMetadataProvider } from '../management/svm-context';
+import type { SvmPayloadAccount } from './svm-payload';
+export interface PreparedSvmRequest {
+    wallet: Address;
+    rulesId: Hex;
+    token: Address;
+    amount: bigint;
+    gasLimit: bigint;
+    program: string;
+    instructionData: Uint8Array;
+    /** Already-resolved wire accounts for non-Anchor/dataless programs. */
+    accounts?: readonly SvmPayloadAccount[];
+}
+export declare function prepareSvmAgentExecution(runtime: AgenticRuntime, gen: AgenticGeneration, input: PreparedSvmRequest, metadata: SvmMetadataProvider): Promise<{
+    stored: import("../reads/svm").SvmRuleSnapshot;
+    call: import("../contracts/v5").Call;
+    instruction: {
+        recipient: `0x${string}`;
+        payload: `0x${string}`;
+        accounts: SvmPayloadAccount[];
+        instructionData: Uint8Array;
+    };
+    quote: {
+        isNative: boolean;
+        protocolFee: bigint;
+        nativeValueForGas: bigint;
+        gasLimitUsed: bigint;
+    };
+    data: `0x${string}`;
+}>;
+export declare function sendSvmAgentWire(runtime: AgenticRuntime, gen: AgenticGeneration, input: PreparedSvmRequest, metadata: SvmMetadataProvider): Promise<{
+    tx: import("../../orchestrator/orchestrator.types").UniversalTxResponse;
+    context: import("../reads/svm").SvmRuleSnapshot;
+    instruction: {
+        recipient: `0x${string}`;
+        payload: `0x${string}`;
+        accounts: SvmPayloadAccount[];
+        instructionData: Uint8Array;
+    };
+}>;