otto-intel-mcp 0.1.2 → 0.1.4

package/dist/execution-delegation-exit-definition.d.ts

@@ -0,0 +1,309 @@
+import { z } from 'zod';
+export declare const DELEGATION_EXIT_TOOL_NAME: "otto_delegation_exit";
+export declare const DELEGATION_EXIT_CHAIN_ID: 8453;
+export declare const DELEGATION_EXIT_USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+export declare const DELEGATION_EXIT_STATES: readonly ["preparing", "signing", "signed", "submitted", "unknown", "confirmed", "reverted", "replaced", "canceled"];
+export declare const DELEGATION_EXIT_INPUT_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"prepare">;
+    accessToken: z.ZodString;
+    account: z.ZodString;
+    destination: z.ZodString;
+    amountAtomic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"resume">;
+    accessToken: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"submit">;
+    accessToken: z.ZodString;
+    operationId: z.ZodString;
+    epoch: z.ZodNumber;
+    ownerToken: z.ZodString;
+    signedTransaction: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"status">;
+    accessToken: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"reconcile">;
+    accessToken: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"retry_same">;
+    accessToken: z.ZodString;
+    operationId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"cancel">;
+    accessToken: z.ZodString;
+    operationId: z.ZodString;
+    epoch: z.ZodNumber;
+    ownerToken: z.ZodString;
+}, z.core.$strict>], "phase">;
+export declare const DELEGATION_EXIT_TRANSACTION_SCHEMA: z.ZodObject<{
+    type: z.ZodLiteral<"eip1559">;
+    chain_id: z.ZodLiteral<8453>;
+    nonce: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodLiteral<"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913">;
+    value: z.ZodLiteral<"0">;
+    data: z.ZodString;
+    gas: z.ZodString;
+    max_fee_per_gas: z.ZodString;
+    max_priority_fee_per_gas: z.ZodString;
+    sign_idempotency_key: z.ZodString;
+}, z.core.$strict>;
+export declare const DELEGATION_EXIT_RECORD_RESULT_SCHEMA: z.ZodObject<{
+    phase: z.ZodEnum<{
+        status: "status";
+        prepare: "prepare";
+        resume: "resume";
+        submit: "submit";
+        reconcile: "reconcile";
+        retry_same: "retry_same";
+        cancel: "cancel";
+    }>;
+    has_exit: z.ZodLiteral<true>;
+    user_id: z.ZodString;
+    operation_id: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        confirmed: "confirmed";
+        reverted: "reverted";
+        submitted: "submitted";
+        signing: "signing";
+        preparing: "preparing";
+        signed: "signed";
+        replaced: "replaced";
+        canceled: "canceled";
+    }>;
+    epoch: z.ZodNumber;
+    account: z.ZodString;
+    destination: z.ZodString;
+    amount_atomic: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    lease_expires_at: z.ZodOptional<z.ZodString>;
+    owner_token: z.ZodOptional<z.ZodString>;
+    transaction: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"eip1559">;
+        chain_id: z.ZodLiteral<8453>;
+        nonce: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodLiteral<"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913">;
+        value: z.ZodLiteral<"0">;
+        data: z.ZodString;
+        gas: z.ZodString;
+        max_fee_per_gas: z.ZodString;
+        max_priority_fee_per_gas: z.ZodString;
+        sign_idempotency_key: z.ZodString;
+    }, z.core.$strict>>;
+    transaction_hash: z.ZodOptional<z.ZodString>;
+    broadcast_attempts: z.ZodNumber;
+    receipt: z.ZodOptional<z.ZodObject<{
+        transaction_hash: z.ZodString;
+        block_number: z.ZodString;
+        block_hash: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            reverted: "reverted";
+        }>;
+    }, z.core.$strict>>;
+    replacement: z.ZodOptional<z.ZodObject<{
+        transaction_hash: z.ZodString;
+        block_number: z.ZodString;
+        block_hash: z.ZodString;
+        finalized_head_block_number: z.ZodString;
+        finalized_head_block_hash: z.ZodString;
+        finalized_nonce: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const DELEGATION_EXIT_NONE_RESULT_SCHEMA: z.ZodObject<{
+    phase: z.ZodLiteral<"status">;
+    user_id: z.ZodString;
+    has_exit: z.ZodLiteral<false>;
+}, z.core.$strict>;
+/** `status` without an operationId returns this explicit idle variant when no exit exists. */
+export declare const DELEGATION_EXIT_RESULT_SCHEMA: z.ZodUnion<readonly [z.ZodObject<{
+    phase: z.ZodEnum<{
+        status: "status";
+        prepare: "prepare";
+        resume: "resume";
+        submit: "submit";
+        reconcile: "reconcile";
+        retry_same: "retry_same";
+        cancel: "cancel";
+    }>;
+    has_exit: z.ZodLiteral<true>;
+    user_id: z.ZodString;
+    operation_id: z.ZodString;
+    state: z.ZodEnum<{
+        unknown: "unknown";
+        confirmed: "confirmed";
+        reverted: "reverted";
+        submitted: "submitted";
+        signing: "signing";
+        preparing: "preparing";
+        signed: "signed";
+        replaced: "replaced";
+        canceled: "canceled";
+    }>;
+    epoch: z.ZodNumber;
+    account: z.ZodString;
+    destination: z.ZodString;
+    amount_atomic: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+    lease_expires_at: z.ZodOptional<z.ZodString>;
+    owner_token: z.ZodOptional<z.ZodString>;
+    transaction: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"eip1559">;
+        chain_id: z.ZodLiteral<8453>;
+        nonce: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodLiteral<"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913">;
+        value: z.ZodLiteral<"0">;
+        data: z.ZodString;
+        gas: z.ZodString;
+        max_fee_per_gas: z.ZodString;
+        max_priority_fee_per_gas: z.ZodString;
+        sign_idempotency_key: z.ZodString;
+    }, z.core.$strict>>;
+    transaction_hash: z.ZodOptional<z.ZodString>;
+    broadcast_attempts: z.ZodNumber;
+    receipt: z.ZodOptional<z.ZodObject<{
+        transaction_hash: z.ZodString;
+        block_number: z.ZodString;
+        block_hash: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            reverted: "reverted";
+        }>;
+    }, z.core.$strict>>;
+    replacement: z.ZodOptional<z.ZodObject<{
+        transaction_hash: z.ZodString;
+        block_number: z.ZodString;
+        block_hash: z.ZodString;
+        finalized_head_block_number: z.ZodString;
+        finalized_head_block_hash: z.ZodString;
+        finalized_nonce: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"status">;
+    user_id: z.ZodString;
+    has_exit: z.ZodLiteral<false>;
+}, z.core.$strict>]>;
+export type DelegationExitInput = z.infer<typeof DELEGATION_EXIT_INPUT_SCHEMA>;
+export type DelegationExitResult = z.infer<typeof DELEGATION_EXIT_RESULT_SCHEMA>;
+export declare const DELEGATION_EXIT_TOOL_DEFINITION: Readonly<{
+    name: "otto_delegation_exit";
+    title: "Prepare, submit, and recover an exact Base USDC exit";
+    description: "Move an authenticated CDP end user's own Base USDC only through a server-held durable reservation. prepare returns one exact EIP-1559 transaction for client-side signing; the client must never broadcast it. submit validates and durably records the signed bytes and computed hash before the server broadcasts. status is read-only and cross-device. reconcile proves a canonical receipt without broadcasting, or returns the exact finalized sender+nonce replacement proof when another transaction consumed the reserved nonce. retry_same is explicit and can broadcast only the already-stored byte-identical transaction after reconciling first. cancel is accepted only before signed bytes were recorded. The caller presents Otto's delegation secret in x-otto-delegation-auth; user identity is always derived from accessToken.";
+    inputSchema: z.ZodObject<{}, z.core.$loose>;
+    strictInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        phase: z.ZodLiteral<"prepare">;
+        accessToken: z.ZodString;
+        account: z.ZodString;
+        destination: z.ZodString;
+        amountAtomic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"resume">;
+        accessToken: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"submit">;
+        accessToken: z.ZodString;
+        operationId: z.ZodString;
+        epoch: z.ZodNumber;
+        ownerToken: z.ZodString;
+        signedTransaction: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"status">;
+        accessToken: z.ZodString;
+        operationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"reconcile">;
+        accessToken: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"retry_same">;
+        accessToken: z.ZodString;
+        operationId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"cancel">;
+        accessToken: z.ZodString;
+        operationId: z.ZodString;
+        epoch: z.ZodNumber;
+        ownerToken: z.ZodString;
+    }, z.core.$strict>], "phase">;
+    outputSchema: z.ZodObject<{
+        operation_id: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            confirmed: "confirmed";
+            reverted: "reverted";
+            submitted: "submitted";
+            signing: "signing";
+            preparing: "preparing";
+            signed: "signed";
+            replaced: "replaced";
+            canceled: "canceled";
+        }>>;
+        epoch: z.ZodOptional<z.ZodNumber>;
+        account: z.ZodOptional<z.ZodString>;
+        destination: z.ZodOptional<z.ZodString>;
+        amount_atomic: z.ZodOptional<z.ZodString>;
+        created_at: z.ZodOptional<z.ZodString>;
+        updated_at: z.ZodOptional<z.ZodString>;
+        lease_expires_at: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        owner_token: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        transaction: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            type: z.ZodLiteral<"eip1559">;
+            chain_id: z.ZodLiteral<8453>;
+            nonce: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodLiteral<"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913">;
+            value: z.ZodLiteral<"0">;
+            data: z.ZodString;
+            gas: z.ZodString;
+            max_fee_per_gas: z.ZodString;
+            max_priority_fee_per_gas: z.ZodString;
+            sign_idempotency_key: z.ZodString;
+        }, z.core.$strict>>>;
+        transaction_hash: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        broadcast_attempts: z.ZodOptional<z.ZodNumber>;
+        receipt: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            transaction_hash: z.ZodString;
+            block_number: z.ZodString;
+            block_hash: z.ZodString;
+            status: z.ZodEnum<{
+                success: "success";
+                reverted: "reverted";
+            }>;
+        }, z.core.$strict>>>;
+        replacement: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            transaction_hash: z.ZodString;
+            block_number: z.ZodString;
+            block_hash: z.ZodString;
+            finalized_head_block_number: z.ZodString;
+            finalized_head_block_hash: z.ZodString;
+            finalized_nonce: z.ZodString;
+        }, z.core.$strict>>>;
+        phase: z.ZodEnum<{
+            status: "status";
+            prepare: "prepare";
+            resume: "resume";
+            submit: "submit";
+            reconcile: "reconcile";
+            retry_same: "retry_same";
+            cancel: "cancel";
+        }>;
+        user_id: z.ZodString;
+        has_exit: z.ZodBoolean;
+    }, z.core.$strict>;
+    annotations: Readonly<{
+        readOnlyHint: false;
+        destructiveHint: true;
+        idempotentHint: false;
+        openWorldHint: true;
+    }>;
+}>;

package/dist/execution-delegation-exit-definition.js

@@ -0,0 +1,204 @@
+import { z } from 'zod';
+import { DELEGATED_TOOL_TRANSPORT_SCHEMA, DELEGATION_AUTH_HEADER } from './execution-delegated-definition.js';
+export const DELEGATION_EXIT_TOOL_NAME = 'otto_delegation_exit';
+export const DELEGATION_EXIT_CHAIN_ID = 8453;
+export const DELEGATION_EXIT_USDC = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
+export const DELEGATION_EXIT_STATES = [
+    'preparing',
+    'signing',
+    'signed',
+    'submitted',
+    'unknown',
+    'confirmed',
+    'reverted',
+    'replaced',
+    'canceled',
+];
+const ACCESS_TOKEN = z.string().min(16).max(8192);
+const ADDRESS = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const OPERATION_ID = z.string().uuid();
+const OWNER_TOKEN = z.string().regex(/^[0-9a-f]{64}$/);
+const DECIMAL = z.string().regex(/^(?:0|[1-9][0-9]*)$/);
+const POSITIVE_DECIMAL = z.string().regex(/^[1-9][0-9]*$/);
+const HEX = z.string().regex(/^0x(?:[0-9a-fA-F]{2})+$/);
+const HASH = z.string().regex(/^0x[0-9a-fA-F]{64}$/);
+const UUID_V4 = 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}$/i);
+export const DELEGATION_EXIT_INPUT_SCHEMA = z.discriminatedUnion('phase', [
+    z.object({
+        phase: z.literal('prepare'),
+        accessToken: ACCESS_TOKEN,
+        account: ADDRESS,
+        destination: ADDRESS,
+        amountAtomic: POSITIVE_DECIMAL,
+    }).strict(),
+    z.object({
+        phase: z.literal('resume'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID,
+    }).strict(),
+    z.object({
+        phase: z.literal('submit'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID,
+        epoch: z.number().int().positive(),
+        ownerToken: OWNER_TOKEN,
+        signedTransaction: HEX,
+    }).strict(),
+    z.object({
+        phase: z.literal('status'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID.optional(),
+    }).strict(),
+    z.object({
+        phase: z.literal('reconcile'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID,
+    }).strict(),
+    z.object({
+        phase: z.literal('retry_same'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID,
+    }).strict(),
+    z.object({
+        phase: z.literal('cancel'),
+        accessToken: ACCESS_TOKEN,
+        operationId: OPERATION_ID,
+        epoch: z.number().int().positive(),
+        ownerToken: OWNER_TOKEN,
+    }).strict(),
+]);
+export const DELEGATION_EXIT_TRANSACTION_SCHEMA = z.object({
+    type: z.literal('eip1559'),
+    chain_id: z.literal(DELEGATION_EXIT_CHAIN_ID),
+    nonce: DECIMAL,
+    from: ADDRESS,
+    to: z.literal(DELEGATION_EXIT_USDC),
+    value: z.literal('0'),
+    data: HEX,
+    gas: POSITIVE_DECIMAL,
+    max_fee_per_gas: POSITIVE_DECIMAL,
+    max_priority_fee_per_gas: DECIMAL,
+    sign_idempotency_key: UUID_V4,
+}).strict();
+export const DELEGATION_EXIT_RECORD_RESULT_SCHEMA = z.object({
+    phase: z.enum(['prepare', 'resume', 'submit', 'status', 'reconcile', 'retry_same', 'cancel']),
+    has_exit: z.literal(true),
+    user_id: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    operation_id: OPERATION_ID,
+    state: z.enum(DELEGATION_EXIT_STATES),
+    epoch: z.number().int().positive(),
+    account: ADDRESS,
+    destination: ADDRESS,
+    amount_atomic: POSITIVE_DECIMAL,
+    created_at: z.string().datetime(),
+    updated_at: z.string().datetime(),
+    lease_expires_at: z.string().datetime().optional(),
+    owner_token: OWNER_TOKEN.optional(),
+    transaction: DELEGATION_EXIT_TRANSACTION_SCHEMA.optional(),
+    transaction_hash: HASH.optional(),
+    broadcast_attempts: z.number().int().nonnegative(),
+    receipt: z.object({
+        transaction_hash: HASH,
+        block_number: POSITIVE_DECIMAL,
+        block_hash: HASH,
+        status: z.enum(['success', 'reverted']),
+    }).strict().optional(),
+    replacement: z.object({
+        transaction_hash: HASH,
+        block_number: DECIMAL,
+        block_hash: HASH,
+        finalized_head_block_number: DECIMAL,
+        finalized_head_block_hash: HASH,
+        finalized_nonce: POSITIVE_DECIMAL,
+    }).strict().optional(),
+}).strict().superRefine((result, ctx) => {
+    const hasTransaction = result.transaction !== undefined;
+    const hasHash = result.transaction_hash !== undefined;
+    const hasReceipt = result.receipt !== undefined;
+    const hasReplacement = result.replacement !== undefined;
+    const hasLease = result.lease_expires_at !== undefined;
+    const hasOwner = result.owner_token !== undefined;
+    const ownerPhase = result.phase === 'prepare' || result.phase === 'resume';
+    const issue = (message) => ctx.addIssue({ code: 'custom', message });
+    if (hasOwner && !ownerPhase)
+        issue('owner_token is returned only by prepare or resume');
+    if (result.state === 'preparing') {
+        if (!hasLease || hasTransaction || hasHash || hasReceipt || hasReplacement || result.broadcast_attempts !== 0)
+            issue('preparing requires its server lease and cannot carry a transaction, hash, receipt, or broadcast attempt');
+    }
+    else if (result.state === 'signing') {
+        if (!hasTransaction || !hasLease || hasHash || hasReceipt || hasReplacement || result.broadcast_attempts !== 0)
+            issue('signing requires a leased transaction and forbids a hash, receipt, or attempt');
+        if (ownerPhase !== hasOwner)
+            issue('a signing owner_token is required by prepare/resume and omitted by status/reconcile');
+    }
+    else if (result.state === 'signed' || result.state === 'submitted' || result.state === 'unknown') {
+        if (!hasTransaction || !hasHash || hasReceipt || hasReplacement || hasOwner || hasLease)
+            issue('a hash-known nonterminal state requires transaction+hash and forbids receipt or signing ownership');
+        if (result.state === 'signed' && result.broadcast_attempts !== 0)
+            issue('signed means no broadcast attempt is recorded');
+        if ((result.state === 'submitted' || result.state === 'unknown') && result.broadcast_attempts < 1)
+            issue('submitted/unknown requires a recorded broadcast attempt');
+    }
+    else if (result.state === 'confirmed' || result.state === 'reverted') {
+        if (!hasTransaction || !hasHash || !hasReceipt || hasReplacement || hasOwner || hasLease)
+            issue('a receipt-terminal state requires transaction+hash+receipt and forbids signing ownership');
+        if (result.receipt && result.transaction_hash &&
+            result.receipt.transaction_hash.toLowerCase() !== result.transaction_hash.toLowerCase())
+            issue('receipt hash must match transaction_hash');
+        if (result.receipt && result.state === 'confirmed' && result.receipt.status !== 'success')
+            issue('confirmed requires a success receipt');
+        if (result.receipt && result.state === 'reverted' && result.receipt.status !== 'reverted')
+            issue('reverted requires a reverted receipt');
+    }
+    else if (result.state === 'replaced') {
+        if (!hasTransaction || !hasHash || hasReceipt || !hasReplacement || hasOwner || hasLease)
+            issue('replaced requires transaction+hash, finalized replacement proof in-store, and no receipt or signing ownership');
+    }
+    else if (result.state === 'canceled') {
+        if (hasHash || hasReceipt || hasReplacement || hasOwner || hasLease || result.broadcast_attempts !== 0)
+            issue('canceled forbids a hash, receipt, signing ownership, or broadcast attempt');
+    }
+});
+export const DELEGATION_EXIT_NONE_RESULT_SCHEMA = z.object({
+    phase: z.literal('status'),
+    user_id: z.string().regex(/^[a-zA-Z0-9-]{1,100}$/),
+    has_exit: z.literal(false),
+}).strict();
+/** `status` without an operationId returns this explicit idle variant when no exit exists. */
+export const DELEGATION_EXIT_RESULT_SCHEMA = z.union([
+    DELEGATION_EXIT_RECORD_RESULT_SCHEMA,
+    DELEGATION_EXIT_NONE_RESULT_SCHEMA,
+]);
+// MCP SDK 1.x normalizes only object output schemas. Keep the flat wire fields
+// discoverable while the original union remains authoritative for every state.
+const DELEGATION_EXIT_MCP_OUTPUT_SCHEMA = z.object(DELEGATION_EXIT_RECORD_RESULT_SCHEMA.shape)
+    .partial()
+    .extend({
+    phase: DELEGATION_EXIT_RECORD_RESULT_SCHEMA.shape.phase,
+    user_id: DELEGATION_EXIT_RECORD_RESULT_SCHEMA.shape.user_id,
+    has_exit: z.boolean(),
+})
+    .strict()
+    .superRefine((result, ctx) => {
+    const parsed = DELEGATION_EXIT_RESULT_SCHEMA.safeParse(result);
+    if (!parsed.success) {
+        for (const issue of parsed.error.issues)
+            ctx.addIssue({ ...issue });
+    }
+});
+export const DELEGATION_EXIT_TOOL_DEFINITION = Object.freeze({
+    name: DELEGATION_EXIT_TOOL_NAME,
+    title: 'Prepare, submit, and recover an exact Base USDC exit',
+    description: `Move an authenticated CDP end user's own Base USDC only through a server-held durable reservation. prepare returns one exact EIP-1559 transaction for client-side signing; the client must never broadcast it. submit validates and durably records the signed bytes and computed hash before the server broadcasts. status is read-only and cross-device. reconcile proves a canonical receipt without broadcasting, or returns the exact finalized sender+nonce replacement proof when another transaction consumed the reserved nonce. retry_same is explicit and can broadcast only the already-stored byte-identical transaction after reconciling first. cancel is accepted only before signed bytes were recorded. The caller presents Otto's delegation secret in ${DELEGATION_AUTH_HEADER}; user identity is always derived from accessToken.`,
+    inputSchema: DELEGATED_TOOL_TRANSPORT_SCHEMA,
+    strictInputSchema: DELEGATION_EXIT_INPUT_SCHEMA,
+    outputSchema: DELEGATION_EXIT_MCP_OUTPUT_SCHEMA,
+    annotations: Object.freeze({
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    }),
+});
+//# sourceMappingURL=execution-delegation-exit-definition.js.map

package/dist/execution-delegation-exit-store.d.ts

@@ -0,0 +1,114 @@
+import { DELEGATION_EXIT_CHAIN_ID, DELEGATION_EXIT_STATES, DELEGATION_EXIT_USDC } from './execution-delegation-exit-definition.js';
+import { type UserExecutionClaim } from './execution-journal-schema.js';
+export { USER_EXECUTION_CLAIM_KINDS, type UserExecutionClaim, type UserExecutionClaimKind } from './execution-journal-schema.js';
+export declare const DELEGATION_EXIT_SIGNING_LEASE_MS: number;
+export type DelegationExitState = (typeof DELEGATION_EXIT_STATES)[number];
+export interface DelegationExitTransaction {
+    readonly type: 'eip1559';
+    readonly chainId: typeof DELEGATION_EXIT_CHAIN_ID;
+    readonly nonce: string;
+    readonly from: string;
+    readonly to: typeof DELEGATION_EXIT_USDC;
+    readonly value: '0';
+    readonly data: `0x${string}`;
+    readonly gas: string;
+    readonly maxFeePerGas: string;
+    readonly maxPriorityFeePerGas: string;
+    readonly signIdempotencyKey: string;
+}
+export interface DelegationExitReceipt {
+    readonly transactionHash: string;
+    readonly blockNumber: string;
+    readonly blockHash: string;
+    readonly status: 'success' | 'reverted';
+}
+export interface DelegationExitReplacementProof {
+    readonly transactionHash: string;
+    readonly blockNumber: string;
+    readonly blockHash: string;
+    readonly finalizedHeadBlockNumber: string;
+    readonly finalizedHeadBlockHash: string;
+    readonly finalizedNonce: string;
+}
+export interface DelegationExitRecord {
+    readonly operationId: string;
+    readonly userId: string;
+    readonly state: DelegationExitState;
+    readonly epoch: number;
+    readonly account: string;
+    readonly destination: string;
+    readonly amountAtomic: string;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly leaseExpiresAt?: string;
+    /** Finalized canonical block sampled before the pending nonce used by the prepared transaction. */
+    readonly searchFromBlock?: string;
+    readonly transaction?: DelegationExitTransaction;
+    readonly transactionHash?: string;
+    readonly broadcastAttempts: number;
+    readonly receipt?: DelegationExitReceipt;
+    /** Present only after the actual finalized sender+nonce replacement transaction is sealed. */
+    readonly replacement?: DelegationExitReplacementProof;
+}
+export interface PrivateDelegationExitRecord extends DelegationExitRecord {
+    readonly ownerTokenDigest?: string;
+    readonly signedTransaction?: `0x${string}`;
+}
+export type ClaimOutcome = {
+    readonly outcome: 'started' | 'existing';
+} | {
+    readonly outcome: 'conflict';
+    readonly claim: UserExecutionClaim;
+};
+export type PrepareExitOutcome = {
+    readonly outcome: 'started';
+    readonly record: DelegationExitRecord;
+} | {
+    readonly outcome: 'conflict';
+    readonly claim: UserExecutionClaim;
+};
+export type AcceptSignedOutcome = {
+    readonly outcome: 'accepted';
+    readonly record: PrivateDelegationExitRecord;
+} | {
+    readonly outcome: 'already_accepted';
+    readonly record: PrivateDelegationExitRecord;
+} | {
+    readonly outcome: 'stale_owner';
+    readonly record: DelegationExitRecord;
+};
+export interface DelegationExitStore {
+    readonly available: boolean;
+    readonly unavailableReason?: string;
+    claimMint(userId: string, mintKey: string, nowMs: number, claimGeneration?: number): Promise<ClaimOutcome>;
+    readClaim(userId: string): Promise<UserExecutionClaim | undefined>;
+    releaseMint(userId: string, mintKey: string, claimGeneration?: number): Promise<boolean>;
+    prepareExit(input: {
+        operationId: string;
+        userId: string;
+        account: string;
+        destination: string;
+        amountAtomic: string;
+        ownerTokenDigest: string;
+        leaseExpiresAtMs: number;
+    }, nowMs: number): Promise<PrepareExitOutcome>;
+    finishExitPreparation(userId: string, operationId: string, epoch: number, ownerTokenDigest: string, searchFromBlock: string, transaction: DelegationExitTransaction, nowMs: number): Promise<DelegationExitRecord>;
+    abandonPreparing(userId: string, operationId: string, nowMs: number): Promise<void>;
+    resumeExit(userId: string, operationId: string, ownerTokenDigest: string, leaseExpiresAtMs: number, nowMs: number): Promise<DelegationExitRecord>;
+    readExit(userId: string, operationId?: string): Promise<DelegationExitRecord | undefined>;
+    readPrivateExit(userId: string, operationId: string): Promise<PrivateDelegationExitRecord | undefined>;
+    acceptSigned(userId: string, operationId: string, epoch: number, ownerTokenDigest: string, signedTransaction: `0x${string}`, transactionHash: string, nowMs: number): Promise<AcceptSignedOutcome>;
+    beginBroadcast(userId: string, operationId: string, nowMs: number): Promise<PrivateDelegationExitRecord>;
+    markBroadcastSubmitted(userId: string, operationId: string, transactionHash: string, nowMs: number): Promise<DelegationExitRecord>;
+    markReceipt(userId: string, operationId: string, receipt: DelegationExitReceipt, nowMs: number): Promise<DelegationExitRecord>;
+    markReplaced(userId: string, operationId: string, proof: DelegationExitReplacementProof, nowMs: number): Promise<DelegationExitRecord>;
+    cancelExit(userId: string, operationId: string, epoch: number, ownerTokenDigest: string, nowMs: number): Promise<DelegationExitRecord>;
+    close?(): void;
+}
+export declare class CorruptDelegationExitError extends Error {
+    constructor(where: string);
+}
+export declare function delegationExitOwnerTokenDigest(ownerToken: string): string;
+export declare function unavailableDelegationExitStore(reason: string): DelegationExitStore;
+export declare function openDelegationExitStore(root: string): Promise<DelegationExitStore>;
+export declare function createDelegationExitStore(env?: NodeJS.ProcessEnv): Promise<DelegationExitStore>;