otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-sponsored-transport.js

@@ -0,0 +1,180 @@
+import { accountGasFailure } from './execution-account-gas-view.js';
+/** CDP's public REST contract preserves paymasterContext, omitted by the pinned high-level SDK.
+ * Server-only transport. Admission, shared claims, consent and receipt finality belong to its caller.
+ * A POST is attempted once. Any response loss keeps the original request unresolved.
+ */
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { assertSponsoredGasPolicyCurrent, readSponsoredGasPolicy, SponsoredGasPolicyError } from './execution-sponsored-gas-policy.js';
+export const SPONSORED_CDP_NETWORKS = {
+    1: 'ethereum', 8453: 'base', 42161: 'arbitrum', 10: 'optimism', 137: 'polygon',
+};
+const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const hash = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const callSchema = z.object({
+    to: address,
+    data: z.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/).max(262146),
+    value: z.string().regex(/^(0|[1-9][0-9]*)$/).refine(v => BigInt(v) < 2n ** 256n),
+}).strict();
+const callsSchema = z.array(callSchema).min(1).max(8);
+const bindingSchema = z.object({
+    userId: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    account: address,
+    chainId: z.number().int().refine(v => Object.hasOwn(SPONSORED_CDP_NETWORKS, v)),
+    idempotencyKey: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/),
+}).strict();
+const responseSchema = z.object({
+    network: z.string(), userOpHash: hash, calls: callsSchema,
+    status: z.enum(['pending', 'signed', 'broadcast', 'complete', 'dropped', 'failed']),
+    transactionHash: z.union([hash, z.literal('')]).optional(),
+});
+export class SponsoredTransportError extends Error {
+    code;
+    constructor(code) {
+        super(code === 'SPONSOR_SUBMISSION_UNCERTAIN'
+            ? 'The sponsored request may have been submitted. Retain its claim and reconcile the same operation; do not create a replacement.'
+            : code === 'SPONSOR_AUTH_UNAVAILABLE' ? 'Sponsorship authentication could not be prepared; no request was sent.'
+                : 'The sponsored request or operator configuration is invalid.');
+        this.code = code;
+        this.name = 'SponsoredTransportError';
+    }
+}
+const API_HOST = 'api.cdp.coinbase.com';
+function digest(binding, path, body) {
+    return createHash('sha256').update(JSON.stringify([binding.userId, binding.account.toLowerCase(), binding.chainId, binding.idempotencyKey, path, body])).digest('hex');
+}
+function normalizeCalls(calls) {
+    return callsSchema.parse(calls).map(call => ({ to: call.to.toLowerCase(), data: call.data.toLowerCase(), value: call.value }));
+}
+function validateProvider(raw) {
+    try {
+        if (!Object.hasOwn(SPONSORED_CDP_NETWORKS, raw.chainId))
+            throw new Error();
+        const url = new URL(raw.paymasterUrl);
+        if (url.protocol !== 'https:' || url.hostname !== 'api.pimlico.io' || url.port || url.username || url.password || url.hash ||
+            url.pathname !== `/v2/${raw.chainId}/rpc` || [...url.searchParams.keys()].length !== 1 || !url.searchParams.get('apikey') ||
+            !/^[a-zA-Z0-9_-]{1,128}$/.test(raw.sponsorshipPolicyId))
+            throw new Error();
+        return Object.freeze({ chainId: raw.chainId, paymasterUrl: url.toString(), sponsorshipPolicyId: raw.sponsorshipPolicyId });
+    }
+    catch {
+        throw new SponsoredTransportError('SPONSOR_CONFIGURATION_INVALID');
+    }
+}
+export function createSponsoredCdpTransport(options) {
+    const providers = new Map();
+    for (const provider of options.providers) {
+        if (providers.has(provider.chainId))
+            throw new SponsoredTransportError('SPONSOR_CONFIGURATION_INVALID');
+        providers.set(provider.chainId, validateProvider(provider));
+    }
+    const credentials = Object.freeze({ ...options.credentials });
+    const requestFetch = options.fetch ?? fetch;
+    const now = options.now ?? Date.now;
+    const monotonic = options.monotonic;
+    const auth = options.auth ?? (async (input) => {
+        const sdk = await import('@coinbase/cdp-sdk/auth');
+        return sdk.getAuthHeaders(input);
+    });
+    function prepare(binding, calls, payer = 'sponsor') {
+        try {
+            bindingSchema.parse(binding);
+            const provider = providers.get(binding.chainId);
+            if (!provider || (payer !== 'sponsor' && payer !== 'account'))
+                throw new Error();
+            const path = `/platform/v2/embedded-wallet-api/end-users/${binding.userId}/evm/smart-accounts/${binding.account.toLowerCase()}/send`;
+            const body = JSON.stringify({
+                network: SPONSORED_CDP_NETWORKS[binding.chainId], calls: normalizeCalls(calls), useCdpPaymaster: false,
+                ...(payer === 'sponsor' ? { paymasterAlias: `pimlico:${binding.chainId}`,
+                    paymasterContext: { sponsorshipPolicyId: provider.sponsorshipPolicyId } } : {}),
+            });
+            return Object.freeze({ ...binding, account: binding.account.toLowerCase(), path, body,
+                digest: digest(binding, path, wireBody(binding.chainId, normalizeCalls(calls), payer)) });
+        }
+        catch {
+            throw new SponsoredTransportError('SPONSOR_REQUEST_INVALID');
+        }
+    }
+    function wireBody(chainId, calls, payer) {
+        const provider = providers.get(chainId);
+        if (!provider)
+            throw new SponsoredTransportError('SPONSOR_REQUEST_INVALID');
+        return JSON.stringify({ network: SPONSORED_CDP_NETWORKS[chainId], calls, useCdpPaymaster: false,
+            ...(payer === 'sponsor' ? { paymasterUrl: provider.paymasterUrl,
+                paymasterContext: { sponsorshipPolicyId: provider.sponsorshipPolicyId } } : {}) });
+    }
+    function validate(request) {
+        try {
+            const { userId, account, chainId, idempotencyKey } = request;
+            const body = JSON.parse(request.body);
+            const calls = normalizeCalls(body.calls);
+            const payer = body.paymasterAlias !== undefined || body.paymasterContext !== undefined ? 'sponsor' : 'account';
+            const expected = prepare({ userId, account, chainId, idempotencyKey }, calls, payer);
+            if (request.path !== expected.path || request.body !== expected.body || request.digest !== expected.digest)
+                throw new Error();
+            return { calls, payer };
+        }
+        catch {
+            throw new SponsoredTransportError('SPONSOR_REQUEST_INVALID');
+        }
+    }
+    function checkGasPolicy(chainId) {
+        const provider = providers.get(chainId);
+        if (!provider)
+            throw new SponsoredTransportError('SPONSOR_CONFIGURATION_INVALID');
+        return readSponsoredGasPolicy(provider, { fetch: requestFetch, now, monotonic });
+    }
+    return Object.freeze({
+        prepare,
+        checkGasPolicy,
+        /** Readiness/Stop/capability must be checked by the owning service after auth and immediately before POST. */
+        async send(request, beforeHandoff, handoff = start => start()) {
+            request = Object.freeze({ ...request });
+            const { calls: expectedCalls, payer } = validate(request);
+            const privateBody = wireBody(request.chainId, expectedCalls, payer);
+            let headers;
+            try {
+                headers = await auth({ ...credentials, requestMethod: 'POST', requestHost: API_HOST,
+                    requestPath: request.path, requestBody: JSON.parse(privateBody), source: 'otto-sponsored-execution' });
+            }
+            catch {
+                throw new SponsoredTransportError('SPONSOR_AUTH_UNAVAILABLE');
+            }
+            await beforeHandoff();
+            // Read the current cap after asynchronous quote/protocol prechecks, then check its age again at invocation.
+            const gasPolicy = payer === 'sponsor' ? await checkGasPolicy(request.chainId) : undefined;
+            // No retry, redirect, transport fallback or provider error-body propagation.
+            let requestStarted = false;
+            try {
+                const response = await handoff(onInvoke => {
+                    if (requestStarted)
+                        throw new SponsoredTransportError('SPONSOR_SUBMISSION_UNCERTAIN');
+                    if (gasPolicy)
+                        assertSponsoredGasPolicyCurrent(gasPolicy, now());
+                    onInvoke?.(gasPolicy);
+                    requestStarted = true;
+                    return requestFetch(`https://${API_HOST}${request.path}`, {
+                        method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
+                        headers: { ...headers, 'Content-Type': 'application/json', 'X-Idempotency-Key': request.idempotencyKey }, body: privateBody,
+                    });
+                });
+                if (!response.ok)
+                    throw new Error();
+                const text = await response.text();
+                if (text.length > 1_000_000)
+                    throw new Error();
+                const result = responseSchema.parse(JSON.parse(text));
+                if (result.network !== SPONSORED_CDP_NETWORKS[request.chainId] || JSON.stringify(normalizeCalls(result.calls)) !== JSON.stringify(expectedCalls))
+                    throw new Error();
+                return Object.freeze({ userOpHash: result.userOpHash, status: result.status,
+                    ...(result.transactionHash ? { transactionHash: result.transactionHash } : {}) });
+            }
+            catch (error) {
+                if (!requestStarted && (error instanceof SponsoredGasPolicyError || accountGasFailure(error)))
+                    throw error;
+                throw new SponsoredTransportError('SPONSOR_SUBMISSION_UNCERTAIN');
+            }
+        },
+    });
+}
+//# sourceMappingURL=execution-sponsored-transport.js.map

package/dist/execution-tool-definitions.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare const ACCOUNT_PROFILE_SCHEMA: z.ZodObject<{
     kind: z.ZodEnum<{
-        safe: "safe";
         eoa: "eoa";
+        safe: "safe";
     }>;
     address: z.ZodString;
     chainId: z.ZodNumber;
@@ -10,8 +10,8 @@ export declare const ACCOUNT_PROFILE_SCHEMA: z.ZodObject<{
 export declare const PREPARE_SWAP_INPUT_SCHEMA: z.ZodObject<{
     accountProfile: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -29,8 +29,8 @@ export declare const PREPARE_SWAP_INPUT_SCHEMA: z.ZodObject<{
 export declare const PREPARE_BRIDGE_INPUT_SCHEMA: z.ZodObject<{
     accountProfile: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -64,8 +64,8 @@ export declare const EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -88,9 +88,9 @@ export declare const EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
             value: z.ZodString;
             data: z.ZodString;
             kind: z.ZodEnum<{
-                call: "call";
-                approve_reset: "approve_reset";
                 approve: "approve";
+                approve_reset: "approve_reset";
+                call: "call";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
@@ -130,8 +130,8 @@ export declare const BRIDGE_EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -158,9 +158,9 @@ export declare const BRIDGE_EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
             value: z.ZodString;
             data: z.ZodString;
             kind: z.ZodEnum<{
-                call: "call";
-                approve_reset: "approve_reset";
                 approve: "approve";
+                approve_reset: "approve_reset";
+                call: "call";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
@@ -195,8 +195,8 @@ export declare const BRIDGE_EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
 export declare const PREPARE_POLYMARKET_ORDER_INPUT_SCHEMA: z.ZodObject<{
     accountProfile: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -323,8 +323,8 @@ export declare const POLYMARKET_EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -580,8 +580,8 @@ export declare const HYPERLIQUID_L1_ACTION_PAYLOAD_SCHEMA: z.ZodObject<{
 export declare const PREPARE_PERP_ORDER_INPUT_SCHEMA: z.ZodObject<{
     accountProfile: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -613,8 +613,8 @@ export declare const HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA: z.ZodObject<{
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -730,8 +730,8 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -754,9 +754,9 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
             value: z.ZodString;
             data: z.ZodString;
             kind: z.ZodEnum<{
-                call: "call";
-                approve_reset: "approve_reset";
                 approve: "approve";
+                approve_reset: "approve_reset";
+                call: "call";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
@@ -795,8 +795,8 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -823,9 +823,9 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
             value: z.ZodString;
             data: z.ZodString;
             kind: z.ZodEnum<{
-                call: "call";
-                approve_reset: "approve_reset";
                 approve: "approve";
+                approve_reset: "approve_reset";
+                call: "call";
             }>;
         }, z.core.$strict>>;
     }, z.core.$strict>], "kind">;
@@ -864,8 +864,8 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;
@@ -972,8 +972,8 @@ export declare const EXECUTION_ARTIFACT_SCHEMA: z.ZodUnion<readonly [z.ZodObject
     intent_digest: z.ZodString;
     account_binding: z.ZodObject<{
         kind: z.ZodEnum<{
-            safe: "safe";
             eoa: "eoa";
+            safe: "safe";
         }>;
         address: z.ZodString;
         chainId: z.ZodNumber;

package/dist/execution-tool-definitions.js

@@ -1039,13 +1039,6 @@ export const EXECUTION_TOOL_DEFINITIONS = Object.freeze([
         inputSchema: PREPARE_POLYMARKET_ORDER_INPUT_SCHEMA,
         outputSchema: POLYMARKET_EXECUTION_ENVELOPE_SCHEMA,
     }),
-    Object.freeze({
-        name: 'otto_prepare_perp_order',
-        title: 'Prepare an unsigned Hyperliquid perp order L1 action',
-        description: "Prepare and verify an unsigned Hyperliquid perpetuals order (limit, with optional reduce-only take-profit and stop-loss triggers bundled as normalTpsl) for the caller-owned Hyperliquid account, returned as the canonical L1 action plus the exact EIP-712 Agent domain, struct, and connectionId recipe the caller's own signer needs. The asset id, size grid, and price grid come from the live perp universe: an unknown or delisted perp, a size finer than the asset's szDecimals, or a price off the venue's 5-significant-digit / (6 - szDecimals) decimal grid is refused by name rather than rounded to a different order. There is no market order — name your own aggressive limit price with 'Ioc'. Otto's builder attribution is spec'd and valueless today, so the action carries no builder field and the envelope says so. The nonce is chosen by the signer, never here; the envelope's valid_until is committed to the artifact digest AND placed inside the signed digest as expiresAfter, so the venue itself rejects a stale action, while the Hyperliquid signer nonce remains the replay boundary and this tool cannot guarantee single execution. This tool never signs or submits, holds no key, and derives no agent wallet.",
-        inputSchema: PREPARE_PERP_ORDER_INPUT_SCHEMA,
-        outputSchema: HYPERLIQUID_EXECUTION_ENVELOPE_SCHEMA,
-    }),
 ]);
 export const EXECUTION_TOOL_DEFINITION_BY_NAME = new Map(EXECUTION_TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
 //# sourceMappingURL=execution-tool-definitions.js.map

package/dist/execution-tools.d.ts

@@ -1,9 +1,16 @@
+import type { LpUserOpBinding } from './lp-userop-registration.js';
+import type { NativeYieldUserOpBinding } from './native-yield-userop-registration.js';
+import type { SponsoredAccountBinding } from './execution-sponsored-registration.js';
 import { type ExecutionServiceConfig } from './execution-config.js';
 import { type DelegationServices } from './execution-delegation.js';
+import { type RouteSimulator } from './adapter/route-simulator.js';
+import { type PrepareSwapInput } from './execution-tool-definitions.js';
 import { type BridgeExecutionEnvelope, type ExecutionEnvelope, type HyperliquidExecutionEnvelope, type PolymarketExecutionEnvelope } from './execution-types.js';
 import { type HyperliquidInfoClient } from './hyperliquid-info-client.js';
 import { type UnsignedHyperliquidAction, type UnsignedHyperliquidActionRequest } from './hyperliquid-order-builder.js';
-import { type LiFiQuoteClient } from './lifi-execution-client.js';
+import { type LiFiQuote, type LiFiQuoteClient } from './lifi-execution-client.js';
+import type { YieldVaultReader } from './yield-deposit-definition.js';
+import type { EquityOracleReader } from './stock-buy-definition.js';
 import { type PolymarketClobClient } from './polymarket-clob-client.js';
 import { type UnsignedPolymarketOrder, type UnsignedPolymarketOrderRequest } from './polymarket-order-builder.js';
 /** The order-construction seam: request in, unsigned SDK-built order out. */
@@ -37,8 +44,30 @@ export interface ExecutionToolRuntime {
      * this process prepared (`prepared-artifacts.ts`).
      */
     readonly delegation?: DelegationServices;
+    readonly sponsoredAccount?: SponsoredAccountBinding;
+    readonly nativeYieldUserOp?: NativeYieldUserOpBinding;
+    readonly lpUserOp?: LpUserOpBinding;
+    /**
+     * Proves a quoted swap's calldata executes from the signing account BEFORE it is prepared
+     * (`adapter/route-simulator.ts`). Present on a server booted with a Base RPC (the delegated rail's);
+     * absent elsewhere, in which case the envelope records `route_simulated:false`.
+     */
+    readonly routeSimulator?: RouteSimulator;
+    /**
+     * The one on-chain read `otto_prepare_yield_deposit` needs (the vault's own `previewDeposit`), present
+     * on the hosted service over the delegation rig's Base public client; injectable so the parity guard is
+     * mutation-provable. Absent → the yield constructor refuses by name, nothing is prepared.
+     */
+    readonly yieldVaultReader?: YieldVaultReader;
+    /**
+     * The one on-chain read `otto_prepare_stock_buy` needs (the equity's Chainlink mark), present on the
+     * hosted service over the same Base public client; injectable so the parity guard is mutation-provable.
+     * Absent → the stock constructor refuses by name, nothing is prepared.
+     */
+    readonly equityOracleReader?: EquityOracleReader;
 }
 export interface ExecutionRuntimeOverrides {
+    readonly routeSimulator?: RouteSimulator;
     readonly quoteClient?: LiFiQuoteClient;
     readonly clobClient?: PolymarketClobClient;
     readonly polymarketOrderBuilder?: PolymarketOrderBuilder;
@@ -48,6 +77,11 @@ export interface ExecutionRuntimeOverrides {
     readonly entropy?: () => Uint8Array;
     readonly clientOrderIdEntropy?: () => Uint8Array;
     readonly delegation?: DelegationServices;
+    readonly sponsoredAccount?: SponsoredAccountBinding;
+    readonly nativeYieldUserOp?: NativeYieldUserOpBinding;
+    readonly lpUserOp?: LpUserOpBinding;
+    readonly yieldVaultReader?: YieldVaultReader;
+    readonly equityOracleReader?: EquityOracleReader;
 }
 export declare function createExecutionToolRuntime(config: ExecutionServiceConfig, overrides?: ExecutionRuntimeOverrides): ExecutionToolRuntime;
 export declare function createExecutionToolRuntimeFromEnv(env?: NodeJS.ProcessEnv): ExecutionToolRuntime | undefined;
@@ -58,7 +92,25 @@ export declare function createExecutionToolRuntimeFromEnv(env?: NodeJS.ProcessEn
  * the tool.
  */
 export declare function createExecutionToolRuntimeWithDelegationFromEnv(env?: NodeJS.ProcessEnv): Promise<ExecutionToolRuntime | undefined>;
+/** How many LI.FI tools the constructor will try before it refuses: the first quote plus two re-quotes. */
+export declare const MAX_ROUTE_ATTEMPTS: 3;
 export declare function prepareSwap(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<ExecutionEnvelope>;
+/**
+ * The route-set and fee pre-checks, then ONE LI.FI quote for the parsed swap input. Split from
+ * `prepareSwapFromQuote` so a constructor that must read the quote itself (the Yield Copilot deposit:
+ * expected shares, the router's floor, the fee lines) quotes exactly once and builds the envelope from
+ * that same quote — a second quote could route through a different tool and carry a different floor.
+ */
+export declare function quoteSwap(runtime: ExecutionToolRuntime, input: PrepareSwapInput, signal?: AbortSignal): Promise<ExecutableSwapQuote>;
+/** A LI.FI quote as `quoteSwap` returns it: the quote plus the route facts the envelope records. */
+export type ExecutableSwapQuote = LiFiQuote & {
+    readonly route: {
+        readonly tool: string;
+        readonly simulated: boolean;
+    };
+};
+/** Decode, assert and commit the envelope for a parsed swap input over the quote `quoteSwap` returned for it. */
+export declare function prepareSwapFromQuote(runtime: ExecutionToolRuntime, input: PrepareSwapInput, quote: LiFiQuote | ExecutableSwapQuote): ExecutionEnvelope;
 /**
  * Build the ordered source-chain plan for a cross-chain native-USDC bridge over the enumerated v1
  * Circle-CCTP route set. Prepare-only: the plan is handed to the caller's own custody to sign.