otto-intel-mcp 0.1.3 → 0.1.4

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

@@ -32,8 +32,9 @@
  * gate's own minimum safe model —
  *
  *      reserved ──confirm──▶ confirmed_active ──┬──▶ superseded   (a later confirm won)
- *          │                                     ├──▶ revoked      (the person, or a mismatch)
- *          └──10 min──▶ expired                  └──▶ (expiry passes)
+ *          │                                     ├──▶ revoked      (the person pressed Stop)
+ *          ├──mismatch──▶ refused/unconfirmed    └──▶ (expiry passes)
+ *          └──10 min──▶ expired
  *
  * — and made ONE thing authoritative: `readActive`. A reserved row authorises NOTHING; the send gate
  * reads the confirmed-active record and requires its expiry to equal the live grant's.
@@ -121,6 +122,13 @@ export declare const DELEGATION_MINT_ENABLED_ENV: "DELEGATION_MINT_ENABLED";
 export declare function resolveDelegationMintEnabled(env?: NodeJS.ProcessEnv): boolean;
 /** The one sentence every paused surface says. No security narration: it is an update, and it is short. */
 export declare const DELEGATION_MINT_PAUSED_MESSAGE: "Delegation is paused for a few minutes while we update it";
+/** New Model B trading grants are retired. Status, confirm, revoke and exits remain available. */
+export declare const DELEGATION_TRADE_MINT_RETIRED_MESSAGE: "Otto no longer creates new Model B trading permissions. Existing permissions remain visible and revocable; use your wallet to sign new actions.";
+/** The Model B reserve may run only when both the global and trade-specific gates allow it. */
+export declare function effectiveTradeMintEnabled(switches: {
+    readonly mintEnabled: boolean;
+    readonly tradeMintEnabled: boolean;
+}): boolean;
 /**
  * The shape a mint key must have: what `createDelegation({ idempotencyKey })` accepts, bounded so it
  * cannot be used as a path or a smuggling channel. A UUID satisfies it.
@@ -233,16 +241,21 @@ export interface DelegationCapStop {
 export declare class DelegationCapExpiryUnavailableError extends Error {
     constructor(steps: number);
 }
+export type DelegationCapHandoffAuthority = Pick<DelegationCapRecord, 'userId' | 'mintKey' | 'expiresAt' | 'perSwapCapUsd' | 'requiredVersion' | 'revokeGeneration'>;
 export interface DelegationCapStore {
     /** False when no durable path is configured, or the database could not be opened. Sends refuse while false. */
     readonly available: boolean;
     readonly unavailableReason?: string;
+    /** Current durable Stop generation, sampled before the cross-kind mint claim is acquired. */
+    readRevokeGeneration(userId: string): Promise<number>;
     /**
      * Reserve the first whole second at or BEFORE `latestExpiresAt` that no reservation for this user
      * occupies, and record the cap against it. Idempotent per mint key. THROWS when the store cannot be
      * written; `DelegationCapExpiryUnavailableError` when the ladder is exhausted.
      */
-    reserve(userId: string, mintKey: string, latestExpiresAt: string, perSwapCapUsd: number, nowMs: number): Promise<DelegationCapReservation>;
+    reserve(userId: string, mintKey: string, latestExpiresAt: string, perSwapCapUsd: number, nowMs: number, 
+    /** Generation sampled before the mint claim. Omission preserves direct-store test compatibility. */
+    expectedRevokeGeneration?: number): Promise<DelegationCapReservation>;
     /** The reservation this mint key holds, with its state as of `nowMs` (the window applied). */
     readReservation(userId: string, mintKey: string, nowMs: number): Promise<DelegationCapRecord | undefined>;
     /**
@@ -257,6 +270,10 @@ export interface DelegationCapStore {
      * reservation unable to authorise anything. THROWS when the store cannot be read.
      */
     readActive(userId: string, nowMs: number): Promise<DelegationCapRecord | undefined>;
+    /** Optional for legacy callers; sponsored sends require it. Hold the cap writer lock from current
+     * authority comparison through synchronous request invocation, then release without awaiting I/O.
+     * The clock is sampled AFTER lock acquisition, so waiting cannot revive an expired grant. */
+    withCurrentActiveCap?<T>(expected: DelegationCapHandoffAuthority, now: () => number, start: () => T): T;
     /**
      * Mark the confirmed-active record for this user REVOKED, but only when it is the grant at
      * `expiresAt`. Per-grant by construction: a revoke aimed at a permission that is no longer the live
@@ -295,8 +312,8 @@ export interface DelegationCapStore {
      *
      * It takes NO expiry, deliberately. A Stop means "Otto acts under nothing for me": the record that is
      * live goes, whatever tab pressed the button and whatever grant Coinbase happens to hold — exactly what
-     * the CDP-side revoke that follows it does. `revoke` above stays per grant for the mismatch path, where
-     * the thing being taken away IS one specific grant.
+     * the CDP-side revoke that follows it does. `revoke` above remains as a narrowly scoped per-grant store
+     * primitive; confirm refusals do not call it or CDP's user-wide revoke.
      *
      * Answers the generation now in force and the instant of the record it revoked, if any.
      */

package/dist/execution-delegation-cap-store.js

@@ -32,8 +32,9 @@
  * gate's own minimum safe model —
  *
  *      reserved ──confirm──▶ confirmed_active ──┬──▶ superseded   (a later confirm won)
- *          │                                     ├──▶ revoked      (the person, or a mismatch)
- *          └──10 min──▶ expired                  └──▶ (expiry passes)
+ *          │                                     ├──▶ revoked      (the person pressed Stop)
+ *          ├──mismatch──▶ refused/unconfirmed    └──▶ (expiry passes)
+ *          └──10 min──▶ expired
  *
  * — and made ONE thing authoritative: `readActive`. A reserved row authorises NOTHING; the send gate
  * reads the confirmed-active record and requires its expiry to equal the live grant's.
@@ -128,6 +129,12 @@ export function resolveDelegationMintEnabled(env = process.env) {
 }
 /** The one sentence every paused surface says. No security narration: it is an update, and it is short. */
 export const DELEGATION_MINT_PAUSED_MESSAGE = 'Delegation is paused for a few minutes while we update it';
+/** New Model B trading grants are retired. Status, confirm, revoke and exits remain available. */
+export const DELEGATION_TRADE_MINT_RETIRED_MESSAGE = 'Otto no longer creates new Model B trading permissions. Existing permissions remain visible and revocable; use your wallet to sign new actions.';
+/** The Model B reserve may run only when both the global and trade-specific gates allow it. */
+export function effectiveTradeMintEnabled(switches) {
+    return switches.mintEnabled === true && switches.tradeMintEnabled === true;
+}
 /**
  * The shape a mint key must have: what `createDelegation({ idempotencyKey })` accepts, bounded so it
  * cannot be used as a path or a smuggling channel. A UUID satisfies it.
@@ -187,6 +194,15 @@ export class DelegationCapExpiryUnavailableError extends Error {
         this.name = 'DelegationCapExpiryUnavailableError';
     }
 }
+function assertCapHandoff(record, generation, expected, nowMs) {
+    if (!Number.isSafeInteger(nowMs) || nowMs < 0 || !record || record.state !== 'confirmed_active' ||
+        record.userId !== expected.userId || record.mintKey !== expected.mintKey ||
+        record.requiredVersion !== MODEL_B_CAP_RULESET_VERSION || record.requiredVersion !== expected.requiredVersion ||
+        record.perSwapCapUsd !== expected.perSwapCapUsd || record.revokeGeneration !== generation ||
+        generation !== expected.revokeGeneration || Date.parse(record.expiresAt) !== Date.parse(expected.expiresAt) ||
+        Date.parse(record.expiresAt) <= nowMs)
+        throw new Error('SPONSOR_STOP_OR_CAP_CHANGED');
+}
 /* ------------------------------------------------------------------ *
  * Paths and pure helpers.
  * ------------------------------------------------------------------ */
@@ -477,6 +493,15 @@ class SqliteDelegationCapStore {
             return Promise.reject(error);
         }
     }
+    readRevokeGeneration(userId) {
+        try {
+            assertIdentifiers(userId);
+            return Promise.resolve(this.#readGeneration(userId));
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
     stop(userId, nowMs) {
         try {
             assertIdentifiers(userId);
@@ -508,9 +533,12 @@ class SqliteDelegationCapStore {
             throw new CorruptCapRecordError('active_grants');
         return { mintKey: row.mint_key, expiresAtMs };
     }
-    reserve(userId, mintKey, latestExpiresAt, perSwapCapUsd, nowMs) {
+    reserve(userId, mintKey, latestExpiresAt, perSwapCapUsd, nowMs, expectedRevokeGeneration) {
         try {
             assertIdentifiers(userId, mintKey);
+            if (expectedRevokeGeneration !== undefined &&
+                (!Number.isSafeInteger(expectedRevokeGeneration) || expectedRevokeGeneration < 0))
+                throw new Error('invalid expected revoke generation');
             const latestMs = Date.parse(latestExpiresAt);
             if (!Number.isFinite(latestMs))
                 throw new Error('the requested expiry is not a parseable instant');
@@ -535,7 +563,10 @@ class SqliteDelegationCapStore {
                 // The generation in force RIGHT NOW, read inside the same transaction: a Stop that lands
                 // after this reservation is written is what cancels it, and one that landed before is
                 // already reflected here.
-                const generation = this.#readGeneration(userId);
+                // The admin path samples before taking the cross-kind claim. Persist that earlier generation
+                // even if Stop commits before this separate database transaction: confirm then classifies the
+                // row as cancelled, and an idempotent same-key retry cannot revive it under a newer generation.
+                const generation = expectedRevokeGeneration ?? this.#readGeneration(userId);
                 const insert = this.db.prepare(`INSERT INTO reservations
                (user_id, mint_key, expires_at_ms, requested_expires_at_ms, cap_usd, required_version, state, reserved_at_ms, revoke_generation)
              VALUES (?, ?, ?, ?, ?, ?, 'reserved', ?, ?)
@@ -613,7 +644,7 @@ class SqliteDelegationCapStore {
                 }
                 /**
                  * 🔴 A SETTLED RECORD IS NEVER BROUGHT BACK. `superseded` (a later confirmation won) and
-                 * `revoked` (the person, or a mismatch) are terminal: promoting either would resurrect a
+                 * `revoked` (the person pressed Stop) are terminal: promoting either would resurrect a
                  * permission that was deliberately replaced or taken away. `expired` and `legacy` are their
                  * own answers because the remedy differs — nothing was ever confirmed, so the person mints
                  * again.
@@ -684,6 +715,27 @@ class SqliteDelegationCapStore {
             return Promise.reject(error);
         }
     }
+    withCurrentActiveCap(expected, now, start) {
+        assertIdentifiers(expected.userId, expected.mintKey);
+        let pending;
+        try {
+            return this.#transact(() => {
+                const pointer = this.#readActiveRow(expected.userId);
+                const record = pointer ? this.#readByMintKey(expected.userId, pointer.mintKey) : undefined;
+                if (pointer && (!record || Date.parse(record.expiresAt) !== pointer.expiresAtMs))
+                    throw new Error('SPONSOR_STOP_OR_CAP_CHANGED');
+                assertCapHandoff(record, this.#readGeneration(expected.userId), expected, now());
+                pending = start();
+                return pending;
+            });
+        }
+        catch (error) {
+            // A failed commit cannot retract an already invoked network request.
+            if (pending !== undefined)
+                void Promise.resolve(pending).catch(() => undefined);
+            throw error;
+        }
+    }
     readActive(userId, nowMs) {
         try {
             assertIdentifiers(userId);
@@ -862,6 +914,7 @@ export function unavailableDelegationCapStore(reason) {
     return Object.freeze({
         available: false,
         unavailableReason: reason,
+        readRevokeGeneration: dead,
         reserve: dead,
         readReservation: dead,
         confirm: dead,
@@ -960,7 +1013,16 @@ export function inMemoryDelegationCapStore(seed = []) {
     };
     const store = {
         available: true,
-        reserve(userId, mintKey, latestExpiresAt, perSwapCapUsd, nowMs) {
+        readRevokeGeneration(userId) {
+            try {
+                assertIdentifiers(userId);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+            return Promise.resolve(generations.get(userId) ?? 0);
+        },
+        reserve(userId, mintKey, latestExpiresAt, perSwapCapUsd, nowMs, expectedRevokeGeneration) {
             try {
                 assertIdentifiers(userId, mintKey);
             }
@@ -983,7 +1045,7 @@ export function inMemoryDelegationCapStore(seed = []) {
                 requestedExpiresAt: new Date(chosen + MINT_EXPIRY_FILLER_MS).toISOString(),
                 perSwapCapUsd,
                 requiredVersion: MODEL_B_CAP_RULESET_VERSION,
-                revokeGeneration: generations.get(userId) ?? 0,
+                revokeGeneration: expectedRevokeGeneration ?? generations.get(userId) ?? 0,
                 state: 'reserved',
                 reservedAt: new Date(nowMs).toISOString(),
             });
@@ -1032,6 +1094,11 @@ export function inMemoryDelegationCapStore(seed = []) {
             active.set(userId, confirmed);
             return Promise.resolve({ outcome: 'confirmed', record: confirmed });
         },
+        withCurrentActiveCap(expected, now, start) {
+            assertIdentifiers(expected.userId, expected.mintKey);
+            assertCapHandoff(active.get(expected.userId), generations.get(expected.userId) ?? 0, expected, now());
+            return start();
+        },
         readActive(userId, nowMs) {
             const record = active.get(userId);
             if (!record || record.state !== 'confirmed_active')

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;
+    }>;
+}>;