@totalis/hip4-client 0.0.0-stage → 0.73.0

package/dist/totalis.d.ts

@@ -0,0 +1,719 @@
+import { issueApiKey, rotateApiKey } from "./api-keys.js";
+import { type AccessToken, type ApiClientOptions, type PublicEnvironment } from "./base.js";
+import type { paths } from "./generated/client.js";
+import { type BridgedCash, type HypercoreAnswer, type HypercoreTransport, type SignedSendAsset } from "./hypercore.js";
+import { BalanceUnknownError, EntryError, ExitUnavailableError } from "./flow-errors.js";
+import { ApiError, NetworkError, type RetryPolicy } from "./request.js";
+import { type SignerInput } from "./signer.js";
+import { TotalisStream, type StreamEvent, type StreamOptions, type StreamSubscription } from "./stream.js";
+import { type Hex } from "./typed-data.js";
+type Json<T> = T extends {
+    readonly content: {
+        readonly "application/json": infer Body;
+    };
+} ? Body : never;
+export type ResponseOf<Paths, P extends keyof Paths, M extends keyof Paths[P], S extends number> = Paths[P][M] extends {
+    readonly responses: infer R;
+} ? S extends keyof R ? Json<R[S]> : never : never;
+type Ok<P extends keyof paths, M extends keyof paths[P], S extends number = 200> = ResponseOf<paths, P, M, S>;
+export type RequestOf<Paths, P extends keyof Paths, M extends keyof Paths[P]> = Paths[P][M] extends {
+    readonly requestBody?: infer B;
+} ? Json<NonNullable<B>> : never;
+type CommandOf<P extends keyof paths, M extends keyof paths[P] = "post" & keyof paths[P]> = RequestOf<paths, P, M>;
+type AcceptCommand = CommandOf<"/v1/quotes/{quote_id}/accept">;
+type Funding = NonNullable<AcceptCommand["funding"]>;
+type CoreExitRequest = {
+    readonly amount: Amount;
+    readonly purpose?: "ORDER" | "WITHDRAW";
+    readonly exitId?: string;
+    readonly activationFeeAccepted?: boolean;
+};
+export type Deployment = Ok<"/v1/deployment", "get">;
+/** One live unsigned quote, told apart by `kind`: `ENTRY` (`entry`), `SELL_BACK` (`sell_back`) or `TRANSFER` (`transfer`). */
+export type Quote = Ok<"/v1/rfqs/{rfq_id}/quotes", "get">["quotes"][number];
+export type EntryQuote = Extract<Quote, {
+    readonly kind: "ENTRY";
+}>;
+/** A cash-out quote from the maker that backs the position: it buys the position back. */
+export type SellBackQuote = Extract<Quote, {
+    readonly kind: "SELL_BACK";
+}>;
+/** A cash-out quote from another maker: it takes over the position. */
+export type TransferQuote = Extract<Quote, {
+    readonly kind: "TRANSFER";
+}>;
+/** A cash-out quote: a sell-back or a transfer. */
+export type CashoutBid = SellBackQuote | TransferQuote;
+export type Acceptance = Ok<"/v1/quotes/{quote_id}/acceptance", "get">;
+/** An accept whose response was lost and that the venue never admitted: cancel fenced the RFQ first. Nothing traded. */
+export type NotAdmitted = {
+    readonly status: "NOT_ADMITTED";
+    readonly quote_id: string;
+    readonly rfq_id: string;
+};
+export type Operation = Ok<"/v1/me/operations/{operation_id}", "get">["operation"];
+export type Withdrawal = Ok<"/v1/me/withdrawals/{withdrawal_id}", "get">;
+export type CoreExit = Ok<"/v1/core-exits/{exit_id}", "get">;
+/** A transaction the wallet sends itself, paying its own gas. */
+export type WalletCall = {
+    readonly to: Hex;
+    readonly data: Hex;
+};
+/** One leg of a combo: a decimal `outcome_id` and the side, YES or NO. */
+export type Leg = EntryQuote["entry"]["legs"][number];
+/** Money is integer USDC base units (6 decimals), as a bigint or decimal string. */
+export type Amount = bigint | string;
+/** The cash an entry is planned from, as `spendableCash` reads it: free vault cash and available wallet USDC, `null` where unknown. */
+export type EntryCash = {
+    readonly vault: Amount | null;
+    readonly wallet: Amount | null;
+};
+export type DepositAccepted = Ok<"/v1/me/deposits", "post", 202>;
+/** Who signed an acceptance record, and for which vault; a record is only sent or recovered by the same account on the same deployment. */
+type RecordScope = {
+    readonly acceptanceId: string;
+    readonly rfqId: string;
+    readonly quoteId: string;
+    readonly account: Hex;
+    readonly chainId: string;
+    readonly vault: Hex;
+};
+/**
+ * Where an entry's bridge stands; absent until the accept is answered.
+ * `SENT`: recorded before the first send, Hyperliquid's answer unknown.
+ * `LANDED` (Hyperliquid's `ok`), `PROCESSED` (the nonce is spent, its outcome
+ * on the ledger) and `REFUSED` (it can never land) are its answer.
+ * `DISCARDED`: never sent, and never will be.
+ */
+export type BridgeState = "SENT" | "LANDED" | "PROCESSED" | "REFUSED" | "DISCARDED";
+/**
+ * A signed Combo entry, plain JSON. Persist it before `sendAcceptance`: after
+ * a lost answer or a restart, `recoverAcceptance` finishes it without signing
+ * again. `bridge` is the Core to HyperEVM `sendAsset`, sent only once the
+ * acceptance is `ACCEPTED` and before its `fund_by`; it lands at most once.
+ * `onRecord` hands back the record with each new `bridgeState`: persist it
+ * over this one.
+ */
+export type SignedEntry = RecordScope & {
+    readonly kind: "ENTRY";
+    readonly version: 2;
+    /** The quote's expiry, Unix seconds. */
+    readonly expiry: string;
+    readonly command: AcceptCommand;
+    readonly bridge?: SignedSendAsset;
+    readonly bridgeState?: BridgeState;
+};
+/** An entry record from SDK 0.63 or older, which sent its bridge before the accept: `recoverAcceptance` reads it and sends nothing, and `sendAcceptance` refuses it. */
+export type LegacySignedEntry = Omit<SignedEntry, "version" | "bridgeState">;
+/** A signed cash-out acceptance, plain JSON: persist it before `sendAcceptance`. */
+export type SignedCashout = RecordScope & {
+    readonly kind: "CASHOUT";
+    readonly positionId: string;
+    readonly command: AcceptCommand;
+};
+export type SignedAcceptance = SignedEntry | SignedCashout;
+/** Awaited with an entry record whose `bridgeState` changed; persist it over the stored one. */
+export type RecordListener = (record: SignedEntry) => void | Promise<void>;
+/**
+ * Where an acceptance ended. `ACCEPTED` carries `operationId`; so do
+ * `FILLED` (it committed) and `FAILED` (it reverted or expired unexecuted;
+ * the operation's `failure_reason` says why when it is known), which a later read, such as
+ * `recoverAcceptance`'s, can return. `NOT_ADMITTED` means the venue never
+ * took the accept and nothing traded. `bridged` is set
+ * for an entry whose bridge was sent: unless its operation `COMMITTED`, that
+ * cash is in the HyperEVM wallet, not on HyperCore. `bridging` is set when
+ * this call sent the bridge, which never holds up the result.
+ */
+export type AcceptanceResult = {
+    readonly acceptanceId: string;
+    readonly rfqId: string;
+    readonly quoteId: string;
+    /** An entry's position is named by its quote. */
+    readonly positionId: string;
+    readonly status: (Acceptance | NotAdmitted)["status"];
+    readonly operationId: string | undefined;
+    readonly outcome: Acceptance | NotAdmitted;
+    /** Read as the bridge stands now: `landed` turns `yes` once Hyperliquid's `ok` is recorded, and a bridge refused or discarded unsent reads undefined. */
+    readonly bridged?: BridgedCash;
+    /**
+     * Hyperliquid's answer to the bridge, once `onRecord` has recorded it;
+     * `unknown` when none came before `fund_by`. Rejects with `onRecord`'s
+     * error; when that was the record before the first send, nothing was sent.
+     */
+    readonly bridging?: Promise<HypercoreAnswer>;
+};
+/**
+ * Why an entry did not trade, as the user should hear it, from its operation
+ * (or an `OPERATION_UPDATED` payload) and its latest record. `INSUFFICIENT_CASH`:
+ * its Cash fell short, including when its Core cash did reach the wallet.
+ * `CORE_MOVE_MISSED`: it fell short with Core cash planned to cover it that
+ * Hyperliquid never confirmed moving in time (never sent, discarded, refused,
+ * or sent without an `ok`); that cash is on HyperCore or, if `bridged`, in
+ * the wallet. Any other value is the operation's own `failure_reason`, such as
+ * `DEADLINE_BEFORE_CLAIM` when the venue reached it too late; nothing traded
+ * and its cash stayed where it was.
+ */
+export type EntryFailure = "CORE_MOVE_MISSED" | NonNullable<Operation["failure_reason"]>;
+/**
+ * An entry's `EntryFailure`; undefined unless its operation ended with a
+ * `failure_reason`. Pass the record as `onRecord` last handed it back (or
+ * `openPosition`'s `record`): only `LANDED` shows the Core cash moved before
+ * `fund_by`. `PROCESSED` only says the nonce is spent, which a refused or
+ * expired send also does, so it does not show the move.
+ */
+export declare function entryFailure(record: SignedEntry | LegacySignedEntry, operation: Pick<Operation, "failure_reason">): EntryFailure | undefined;
+/** When an entry quote stops being acceptable, in ms on the venue clock: its `accept_before`. A quote without a readable one never is. */
+export declare function acceptBefore(quote: EntryQuote): number;
+/**
+ * Chooses among current offers; return undefined to wait for the quotes to
+ * change. `serverNowMs` is the venue clock. It is called on every change and
+ * may be asked about a later time, so it must depend only on its arguments.
+ */
+export type Chooser<Offer> = (offers: readonly Offer[], serverNowMs: number) => Offer | undefined;
+/** The highest payout among quotes still before their `accept_before` (ties go to the earliest). */
+export declare function bestQuote(): Chooser<EntryQuote>;
+/**
+ * The highest price with at least `minLifeSeconds` left (execution needs 20 s
+ * after confirmation) and, given `minPrice` in USDC base units, no lower than it.
+ */
+export declare function bestBid(minLifeSeconds?: number, minPrice?: bigint): Chooser<CashoutBid>;
+export type TotalisOptions = Omit<ApiClientOptions, "accessToken"> & {
+    readonly environment: PublicEnvironment;
+    /** The WebSocket origin for the stream. Defaults to `baseUrl` if set, else the environment's stream host (`wss://hip4-ws.totalis.trade` in production). */
+    readonly streamBaseUrl?: string;
+    /** The session (a Privy access token or a wallet session from `signInWithWallet`) or a scoped `ttk_` key. A function is called for each request and connection. */
+    readonly accessToken: AccessToken;
+    /** The account's signer (GET /v1/me `wallet`); required for flows that sign. Never stored. */
+    readonly signer?: SignerInput;
+    /** Stream options; `subscription` adds account subscription fields such as `open_rfqs`. */
+    readonly stream?: Omit<StreamOptions, "subscription" | "accessToken" | "environment" | "baseUrl" | "streamBaseUrl"> & {
+        readonly subscription?: Omit<Extract<StreamSubscription, {
+            readonly type: "account";
+        }>, "type">;
+    };
+};
+/**
+ * Follow a resource: read it, then read again only when the stream says it
+ * changed (`wake`) or after a reconnect, until `done`. Reads made while the
+ * stream is not live never settle it, so quotes read while disconnected are stale.
+ * A read that fails transiently is retried with `retry`'s backoff, not
+ * rejected; a wake during the backoff reads at once.
+ */
+export declare function follow<T, Done extends T = T>(stream: TotalisStream, read: (signal: AbortSignal) => Promise<T>, done: (value: T) => value is Done, wake: (event: StreamEvent) => boolean, signal?: AbortSignal, retry?: RetryPolicy): Promise<Done>;
+/**
+ * The taker SDK: the same public client surface the Totalis app and third-party
+ * clients use. Quotes, operations and acceptances are followed on the account
+ * stream; HTTP reads recover after a reconnect or answer a doorbell.
+ */
+export declare function createTotalis(options: TotalisOptions): {
+    /** The typed HTTP client over the same credential, for reads the flows do not cover. */
+    client: import("openapi-fetch").Client<paths, `${string}/${string}`>;
+    /** The account stream. Flows start it on first use; `close()` it when done. */
+    stream: TotalisStream;
+    deployment: () => Promise<{
+        readonly chain_id: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+        readonly vault_address: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+        readonly source_revision: string;
+        readonly audit_status: "PRE_AUDIT" | "AUDITED";
+        readonly fee_bps: number | null;
+        readonly taker_fee_bps: number | null;
+        readonly usdc: {
+            readonly address: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+            readonly eip712_domain: {
+                readonly name: "USDC";
+                readonly version: "2";
+                readonly chain_id: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly verifying_contract: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+            };
+        };
+    }>;
+    /** Spendable Totalis cash from a fresh balances read (`spendableCash`): `{ vault, wallet, total }`, each `null` while unknown, never 0. */
+    spendableCash: (signal?: AbortSignal) => Promise<{
+        readonly vault: bigint | null;
+        readonly wallet: bigint | null;
+        readonly total: bigint | null;
+    }>;
+    openPosition: (request: {
+        readonly legs: readonly Leg[];
+        readonly stake: Amount;
+        readonly choose?: Chooser<EntryQuote>;
+        /** How long quotes may keep arriving after the first one `choose` would take, before it picks; 0 takes it at once. */
+        readonly collectMs?: number;
+        /** `"wallet"` (default) plans the shortfall from the wallet and `core`; `"none"` never funds; or pass a funding command. */
+        readonly funding?: "wallet" | "none" | Funding;
+        /** Core USDC offered for a bridge, in USDC base units; `null` when unread (see `signEntry`). */
+        readonly core?: Amount | null;
+        readonly sourceDex?: "spot" | "";
+        readonly transport?: HypercoreTransport;
+        /** The cash to plan from (see `signEntry`); left out, the balances are read while the quotes arrive. */
+        readonly cash?: EntryCash;
+        /** Awaited with the signed record before anything is sent, then with each change to its bridge (`onRecord`): persist it to `recoverAcceptance` after a restart. */
+        readonly onSigned?: RecordListener;
+        /** Automatic-quote intent identity, as the Totalis app sends it. */
+        readonly intent?: {
+            readonly intent_id: string;
+            readonly intent_generation: string;
+        };
+        readonly quoteTimeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }) => Promise<{
+        entry: {
+            readonly maker_id: import("./generated/openapi.js").components["schemas"]["NonZeroUInt64String"];
+            readonly legs: readonly import("./generated/openapi.js").components["schemas"]["$defs-Leg"][];
+            readonly stake: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+            readonly payout: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+            readonly fee_bps: number;
+            readonly taker_fee_bps: number;
+            readonly taker: string;
+            readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+            readonly salt: import("./generated/openapi.js").components["schemas"]["Uint256"];
+        };
+        bridged: BridgedCash | undefined;
+        record: SignedEntry;
+        acceptanceId: string;
+        rfqId: string;
+        quoteId: string;
+        positionId: string;
+        status: (Acceptance | NotAdmitted)["status"];
+        operationId: string | undefined;
+        outcome: Acceptance | NotAdmitted;
+        bridging?: Promise<HypercoreAnswer>;
+    }>;
+    cashOut: (request: {
+        readonly positionId: string;
+        readonly choose?: Chooser<CashoutBid>;
+        /** As in `openPosition`. */
+        readonly collectMs?: number;
+        readonly onSigned?: (signed: SignedCashout) => void | Promise<void>;
+        readonly quoteTimeoutMs?: number;
+        readonly signal?: AbortSignal;
+    }) => Promise<AcceptanceResult>;
+    signEntry: (request: {
+        readonly quote: EntryQuote;
+        readonly core?: Amount | null;
+        readonly cash?: EntryCash;
+        readonly sourceDex?: "spot" | "";
+        readonly acceptanceId?: string;
+        readonly hypercoreNonce?: number;
+    }) => Promise<SignedEntry>;
+    signCashout: (request: {
+        readonly quote: CashoutBid;
+        readonly acceptanceId?: string;
+    }) => Promise<SignedCashout>;
+    sendAcceptance: (signed: SignedAcceptance, options?: {
+        readonly transport?: HypercoreTransport;
+        readonly signal?: AbortSignal;
+        readonly onRecord?: RecordListener;
+    }) => Promise<AcceptanceResult>;
+    recoverAcceptance: (signed: SignedAcceptance | LegacySignedEntry, options?: {
+        readonly wait?: boolean;
+        readonly transport?: HypercoreTransport;
+        readonly onRecord?: RecordListener;
+    }) => Promise<AcceptanceResult>;
+    signWithdrawal: (request: {
+        readonly destination: string;
+        readonly amount: Amount;
+        readonly idempotencyKey?: string;
+    }) => Promise<{
+        idempotencyKey: string;
+        account: `0x${string}`;
+        body: {
+            readonly destination: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+            readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+            readonly vault_withdrawal?: import("./generated/openapi.js").components["schemas"]["VaultWithdrawal"];
+            readonly payout_authorization: {
+                readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+            };
+        };
+    }>;
+    sendWithdrawal: (signed: {
+        idempotencyKey: string;
+        account: `0x${string}`;
+        body: {
+            readonly destination: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+            readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+            readonly vault_withdrawal?: import("./generated/openapi.js").components["schemas"]["VaultWithdrawal"];
+            readonly payout_authorization: {
+                readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+            };
+        };
+    }, options?: {
+        /** Awaited once the venue admits the withdrawal: persist the ID to `waitForWithdrawal` after a restart. */
+        readonly onStarted?: (withdrawalId: string) => void | Promise<void>;
+        readonly signal?: AbortSignal;
+    }) => Promise<Withdrawal>;
+    withdraw: (request: {
+        readonly destination: string;
+        readonly amount: Amount;
+        /** Awaited once the venue admits the withdrawal: persist the ID to `waitForWithdrawal` after a restart. */
+        readonly onStarted?: (withdrawalId: string) => void | Promise<void>;
+        readonly signal?: AbortSignal;
+    }) => Promise<Withdrawal>;
+    waitForWithdrawal: (withdrawalId: string, signal?: AbortSignal) => Promise<Withdrawal>;
+    waitForOperation: (operationId: string, signal?: AbortSignal) => Promise<Operation>;
+    signCoreExit: (request: CoreExitRequest) => Promise<{
+        exitId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                readonly activation_fee_accepted?: boolean;
+            };
+        };
+    }>;
+    signRunOffClaim: (request: {
+        readonly vaultAddress: string;
+        readonly claimId?: string;
+    }) => Promise<{
+        claimId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly vault_address: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+            };
+        };
+    }>;
+    sendRunOffClaim: (signed: Awaited<ReturnType<(request: {
+        readonly vaultAddress: string;
+        readonly claimId?: string;
+    }) => Promise<{
+        claimId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly vault_address: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+            };
+        };
+    }>>>) => Promise<{
+        readonly vault_address: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+        readonly operation: {
+            readonly operation_id: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+            readonly kind: string;
+            readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"] | null;
+            readonly status: import("./generated/openapi.js").components["schemas"]["OperationState"];
+            readonly transaction_hash: import("./generated/openapi.js").components["schemas"]["Bytes32"] | null;
+            readonly failure_reason?: import("./generated/openapi.js").components["schemas"]["OperationFailureReason"];
+            readonly created_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly updated_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+        };
+    }>;
+    sendCoreExit: (signed: {
+        exitId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                readonly activation_fee_accepted?: boolean;
+            };
+        };
+    }) => Promise<CoreExit>;
+    exitToCore: (request: Parameters<(request: CoreExitRequest) => Promise<{
+        exitId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                readonly activation_fee_accepted?: boolean;
+            };
+        };
+    }>>[0]) => Promise<CoreExit>;
+    waitForCoreExit: (exitId: string, signal?: AbortSignal) => Promise<CoreExit>;
+    signDeposit: (request: {
+        readonly amount: Amount;
+        readonly depositId?: string;
+    }) => Promise<{
+        depositId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly from: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly value: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+                readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+            };
+        };
+    }>;
+    sendDeposit: (signed: {
+        depositId: string;
+        account: `0x${string}`;
+        body: {
+            readonly schema_version: 1;
+            readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+            readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+            readonly command: {
+                readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly from: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                readonly value: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                readonly salt: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+                readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+            };
+        };
+    }) => Promise<DepositAccepted>;
+    signReturnToCore: (request?: {
+        readonly purpose?: "ORDER" | "WITHDRAW";
+        readonly activationFeeAccepted?: boolean;
+        readonly exitId?: string;
+        readonly depositId?: string;
+    }) => Promise<{
+        exit: {
+            exitId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                    readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                    readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                    readonly activation_fee_accepted?: boolean;
+                };
+            };
+        };
+        deposit?: {
+            depositId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly from: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly value: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+                    readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+                };
+            };
+        };
+    }>;
+    sendReturnToCore: (signed: {
+        exit: {
+            exitId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                    readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                    readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                    readonly activation_fee_accepted?: boolean;
+                };
+            };
+        };
+        deposit?: {
+            depositId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly from: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly value: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+                    readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+                };
+            };
+        };
+    }, options?: {
+        readonly signal?: AbortSignal;
+    }) => Promise<CoreExit>;
+    returnToCore: (request?: Parameters<(request?: {
+        readonly purpose?: "ORDER" | "WITHDRAW";
+        readonly activationFeeAccepted?: boolean;
+        readonly exitId?: string;
+        readonly depositId?: string;
+    }) => Promise<{
+        exit: {
+            exitId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly to: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly amount: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly expiry: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Uint"];
+                    readonly signature: import("./generated/openapi.js").components["schemas"]["ContractSignature"];
+                    readonly purpose: "ORDER" | "WITHDRAW" | "SWEEP";
+                    readonly activation_fee_accepted?: boolean;
+                };
+            };
+        };
+        deposit?: {
+            depositId: string;
+            account: `0x${string}`;
+            body: {
+                readonly schema_version: 1;
+                readonly request_id: import("./generated/openapi.js").components["schemas"]["Uuid"];
+                readonly sent_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+                readonly command: {
+                    readonly account: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly from: import("./generated/openapi.js").components["schemas"]["LowercaseNonZeroAddress"];
+                    readonly value: import("./generated/openapi.js").components["schemas"]["$defs-Amount"];
+                    readonly valid_after: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly valid_before: import("./generated/openapi.js").components["schemas"]["UInt64String"];
+                    readonly salt: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+                    readonly authorization_signature: import("./generated/openapi.js").components["schemas"]["Signature65"];
+                };
+            };
+        };
+    }>>[0] & {
+        readonly signal?: AbortSignal;
+    }) => Promise<CoreExit>;
+    directDepositCalls: (amount: Amount) => Promise<readonly WalletCall[]>;
+    /** Render an RFQ's live quotes (entry or cash-out) from the stream; `[]` while the stream is down. */
+    watchQuotes: (rfqId: string, listener: (quotes: readonly Quote[], serverNowMs: number) => void) => () => void;
+    /** Issue a personal `ttk_` key; the signer must be the account wallet (embedded, or a wallet-only account's own). */
+    issueApiKey: (request: Parameters<typeof issueApiKey>[2]) => Promise<{
+        readonly key: {
+            readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            readonly account: {
+                readonly kind: "PARTICIPANT";
+                readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            };
+            readonly environment: "development" | "staging" | "production";
+            readonly label: import("./api-keys.js").components["schemas"]["KeyLabel"];
+            readonly scopes: readonly ("identity:read" | "account:read" | "account:stream" | "rfq:read" | "rfq:write" | "quote:write" | "quote:read" | "replay:read" | "vault:read" | "vault:write" | "quote:accept" | "position:cashout" | "funding:deposit" | "funding:withdraw" | "sponsorship:use" | "maker:access:read" | "operations:read" | "operations:submit")[];
+            readonly status: "ACTIVE";
+            readonly created_at: import("./api-keys.js").components["schemas"]["Timestamp"];
+            readonly expires_at: import("./api-keys.js").components["schemas"]["Timestamp"] | null;
+        };
+        readonly secret: string;
+    } | {
+        readonly key: {
+            readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            readonly account: {
+                readonly kind: "MAKER";
+                readonly id: import("./api-keys.js").components["schemas"]["NonZeroUInt64String"];
+                readonly chain_id: "998" | "999";
+                readonly vault_address: import("./api-keys.js").components["schemas"]["LowercaseNonZeroAddress"];
+            };
+            readonly environment: "development" | "staging" | "production";
+            readonly label: import("./api-keys.js").components["schemas"]["KeyLabel"];
+            readonly scopes: readonly ("identity:read" | "account:read" | "account:stream" | "rfq:read" | "rfq:write" | "quote:write" | "quote:read" | "replay:read" | "vault:read" | "vault:write" | "quote:accept" | "position:cashout" | "funding:deposit" | "funding:withdraw" | "sponsorship:use" | "maker:access:read" | "operations:read" | "operations:submit")[];
+            readonly status: "ACTIVE";
+            readonly created_at: import("./api-keys.js").components["schemas"]["Timestamp"];
+            readonly expires_at: import("./api-keys.js").components["schemas"]["Timestamp"] | null;
+        };
+        readonly secret: string;
+    }>;
+    rotateApiKey: (keyId: string, request?: Parameters<typeof rotateApiKey>[3]) => Promise<{
+        readonly key: {
+            readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            readonly account: {
+                readonly kind: "PARTICIPANT";
+                readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            };
+            readonly environment: "development" | "staging" | "production";
+            readonly label: import("./api-keys.js").components["schemas"]["KeyLabel"];
+            readonly scopes: readonly ("identity:read" | "account:read" | "account:stream" | "rfq:read" | "rfq:write" | "quote:write" | "quote:read" | "replay:read" | "vault:read" | "vault:write" | "quote:accept" | "position:cashout" | "funding:deposit" | "funding:withdraw" | "sponsorship:use" | "maker:access:read" | "operations:read" | "operations:submit")[];
+            readonly status: "ACTIVE";
+            readonly created_at: import("./api-keys.js").components["schemas"]["Timestamp"];
+            readonly expires_at: import("./api-keys.js").components["schemas"]["Timestamp"] | null;
+            readonly rotated_from: string;
+        };
+        readonly secret: string;
+    } | {
+        readonly key: {
+            readonly id: import("./api-keys.js").components["schemas"]["Uuid"];
+            readonly account: {
+                readonly kind: "MAKER";
+                readonly id: import("./api-keys.js").components["schemas"]["NonZeroUInt64String"];
+                readonly chain_id: "998" | "999";
+                readonly vault_address: import("./api-keys.js").components["schemas"]["LowercaseNonZeroAddress"];
+            };
+            readonly environment: "development" | "staging" | "production";
+            readonly label: import("./api-keys.js").components["schemas"]["KeyLabel"];
+            readonly scopes: readonly ("identity:read" | "account:read" | "account:stream" | "rfq:read" | "rfq:write" | "quote:write" | "quote:read" | "replay:read" | "vault:read" | "vault:write" | "quote:accept" | "position:cashout" | "funding:deposit" | "funding:withdraw" | "sponsorship:use" | "maker:access:read" | "operations:read" | "operations:submit")[];
+            readonly status: "ACTIVE";
+            readonly created_at: import("./api-keys.js").components["schemas"]["Timestamp"];
+            readonly expires_at: import("./api-keys.js").components["schemas"]["Timestamp"] | null;
+            readonly rotated_from: string;
+        };
+        readonly secret: string;
+    }>;
+    close: () => void;
+};
+export type Totalis = ReturnType<typeof createTotalis>;
+export { BalanceUnknownError, EntryError, ExitUnavailableError };
+export { ApiError, NetworkError };
+export type SignedCoreExit = Awaited<ReturnType<Totalis["signCoreExit"]>>;
+export type SignedDeposit = Awaited<ReturnType<Totalis["signDeposit"]>>;
+export type SignedReturnToCore = Awaited<ReturnType<Totalis["signReturnToCore"]>>;