@totalis/hip4-client 0.0.0-stage → 0.65.2

package/dist/maker.d.ts

@@ -0,0 +1,205 @@
+import { audienceClient, type AccessToken, type ApiClientOptions, type PublicEnvironment } from "./base.js";
+import type { paths } from "./generated/maker.js";
+import type { paths as ClientPaths } from "./generated/client.js";
+import { type SignerInput } from "./signer.js";
+import { TotalisStream, type StreamEventOf, type StreamOptions, type StreamSubscription } from "./stream.js";
+import { type ResponseOf } from "./totalis.js";
+import { type TransactionCall } from "./controller.js";
+export type { components, operations, paths } from "./generated/maker.js";
+export { controllerTransactions, encodeCall, openMakerVaultTransaction, type ControllerTransactions, type TransactionCall } from "./controller.js";
+export declare function createMakerClient(environment: PublicEnvironment, options?: ApiClientOptions): import("openapi-fetch").Client<paths, `${string}/${string}`>;
+type Ok<P extends keyof paths, M extends keyof paths[P], S extends number = 200> = ResponseOf<paths, P, M, S>;
+export type Rfq = Ok<"/v1/rfqs/{rfq_id}", "get">;
+export type EntryRfq = Extract<Rfq, {
+    readonly kind: "ENTRY";
+}>;
+export type CashoutRfq = Extract<Rfq, {
+    readonly kind: "CASHOUT";
+}>;
+/** An acceptance awaiting this maker's confirm, as QUOTE_ACCEPTED, the maker snapshot's `acceptances` and GET /v1/makers/{maker_id}/acceptances carry it. */
+export type MakerAcceptance = StreamEventOf<"QUOTE_ACCEPTED">["payload"];
+/** The acceptance after this maker's confirm or decline. */
+export type Acceptance = Ok<"/v1/quotes/{quote_id}/confirm", "post">;
+export type CollateralReduction = Ok<"/v1/makers/{maker_id}/collateral-reductions/{job_id}", "get">;
+export type MakerWithdrawal = Ok<"/v1/makers/{maker_id}/withdrawal", "get">;
+export type SelfFundedAccepted = Ok<"/v1/makers/{maker_id}/operations/{operation_id}/self-funded-transaction", "post", 202>;
+export type Decision = "CONFIRM" | "DECLINE";
+/** An RFQ as `onRfq` delivers it: open, as `GET /v1/rfqs/{rfq_id}` reads it. */
+export type OpenedRfq = Rfq;
+/**
+ * `quote` or `bid` on an RFQ where a taker's acceptance of this maker's quote
+ * awaits its answer. Publishing would replace that quote, which the venue
+ * refuses with 409 `STATE_CONFLICT`. Nothing was published: answer the
+ * acceptance (`confirm`, or `onAcceptance`) first, or let its deadline pass.
+ */
+export declare class AcceptancePendingError extends Error {
+    readonly rfqId: string;
+    readonly quoteId: string;
+    readonly deadline: string;
+    readonly name = "AcceptancePendingError";
+    readonly code = "ACCEPTANCE_PENDING";
+    constructor(rfqId: string, quoteId: string, deadline: string);
+}
+export type MakerOptions = 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 maker's scoped `ttk_` key. */
+    readonly apiKey: AccessToken;
+    readonly makerId: string;
+    /** The maker's current quote signer (`signer` in GET /v1/makers/{maker_id}/capital). Never stored. */
+    readonly signer: SignerInput;
+    /**
+     * Where this maker records the digests it publishes: the only terms its quote
+     * signer will sign. Defaults to memory; pass a durable store so a restarted or
+     * separate confirming process can answer quotes published elsewhere.
+     */
+    readonly published?: PublishedStore;
+    /** Resume the maker stream after this cursor: the stream replays the events after it. Persist `stream.cursor` to use it. */
+    readonly stream?: Omit<StreamOptions, "subscription" | "accessToken" | "environment" | "baseUrl" | "streamBaseUrl"> & {
+        readonly subscription?: Omit<Extract<StreamSubscription, {
+            readonly type: "maker";
+        }>, "type" | "maker_id">;
+    };
+};
+/** The maker-owned record of published digests and their expiry (unix seconds). */
+export type PublishedStore = {
+    record(digest: string, expiry: number): void | Promise<void>;
+    forget(digest: string): void | Promise<void>;
+    expiry(digest: string): number | undefined | Promise<number | undefined>;
+};
+/** An in-memory store that drops entries a minute after they expire. */
+export declare function memoryPublished(): PublishedStore;
+/**
+ * The maker SDK over the public maker surface (the one Totalis MM uses):
+ * publish unsigned entry and cash-out quotes on one route, then confirm the
+ * exact terms a taker accepted when QUOTE_ACCEPTED arrives.
+ */
+export declare function createMaker(options: MakerOptions): {
+    client: import("openapi-fetch").Client<paths, `${string}/${string}`>;
+    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"];
+            };
+        };
+    }>;
+    quote: (rfq: Pick<EntryRfq, "rfq_id" | "taker" | "stake" | "legs">, terms: {
+        readonly payout: bigint | string;
+        readonly lifetimeSeconds?: number;
+        readonly salt?: string;
+    }) => Promise<{
+        quoteId: `0x${string}`;
+        entry: {
+            maker_id: string;
+            legs: {
+                readonly outcome_id: import("./generated/openapi.js").components["schemas"]["UInt32String"];
+                readonly side: import("./generated/openapi.js").components["schemas"]["Side"];
+            }[];
+            stake: string;
+            payout: string;
+            fee_bps: number;
+            taker_fee_bps: number;
+            taker: string;
+            expiry: string;
+            salt: string;
+        };
+    }>;
+    bid: (rfq: Pick<CashoutRfq, "rfq_id" | "position_id" | "owner" | "leg_state" | "maker_id">, terms: {
+        readonly price: bigint | string;
+        readonly lifetimeSeconds?: number;
+        readonly salt?: string;
+    }) => Promise<{
+        quote_id: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+        sell_back: import("./generated/openapi.js").components["schemas"]["schemas-SellBackTerms"];
+        quoteId: string;
+    } | {
+        quote_id: import("./generated/openapi.js").components["schemas"]["Bytes32"];
+        transfer: import("./generated/openapi.js").components["schemas"]["schemas-TransferTerms"];
+        quoteId: string;
+    }>;
+    cancelQuote: (quoteId: string) => Promise<{
+        readonly status: "CANCELLED" | "REPLACED" | "ACCEPTED";
+    }>;
+    renewQuoteLease: (leaseMs: number) => Promise<{
+        readonly lease_ms: number;
+        readonly expires_at: import("./generated/openapi.js").components["schemas"]["$defs-Timestamp"];
+    }>;
+    releaseQuoteLease: () => Promise<{
+        readonly released: boolean;
+    }>;
+    keepQuoteLease: (leaseMs: number, onError?: (error: unknown) => void) => () => void;
+    confirm: (acceptance: MakerAcceptance, decision?: Decision) => Promise<Acceptance>;
+    onAcceptance: (handler: (acceptance: MakerAcceptance) => Decision | Promise<Decision>, onError?: (error: unknown, acceptance?: MakerAcceptance) => void) => () => void;
+    onRfq: (handler: (rfq: OpenedRfq) => unknown, onError?: (error: unknown) => void) => () => void;
+    controller: () => Promise<{
+        approveUsdc: (amount: string | bigint) => TransactionCall;
+        deposit: (amount: string | bigint) => TransactionCall;
+        requestWithdraw: (amount: string | bigint, to: string) => TransactionCall;
+        executeWithdraw: () => TransactionCall;
+        cancelWithdraw: () => TransactionCall;
+        resetDiscount: () => TransactionCall;
+    }>;
+    withdrawal: () => Promise<MakerWithdrawal>;
+    reduceCollateral: (request?: {
+        readonly signTransaction?: (call: TransactionCall) => Promise<string>;
+        readonly signal?: AbortSignal;
+    }) => Promise<{
+        readonly job: CollateralReduction;
+        readonly idempotencyKey: string;
+        readonly submitted?: SelfFundedAccepted;
+    }>;
+    close: () => void;
+};
+export type Maker = ReturnType<typeof createMaker>;
+/** `GET /v1/me/maker`'s `ownership`: the account's maker as the venue has indexed it. */
+export type MakerOwnership = ResponseOf<ClientPaths, "/v1/me/maker", "get", 200>["ownership"];
+/**
+ * Where an account's maker stands in onboarding:
+ * - `READY`: admitted; issue its maker key and start quoting. `PENDING` after
+ *   admission and `RESTRICTED` await or carry an operator decision.
+ * - `NOT_INDEXED`: no maker of the account's wallet is indexed yet. Right
+ *   after `openMakerVaultTransaction` lands this lasts a few blocks; read
+ *   again (`waitForMaker`). It also stays here if the transaction never landed,
+ *   or if the maker's quote signer is not its controller.
+ * - `SETUP_REQUIRED`: indexed but not admitted, when `admit: false`.
+ * - `WALLET_REQUIRED`, `OWNERSHIP_CONFLICT`: the account has no single wallet
+ *   that controls the maker; reading again will not change it.
+ */
+export type MakerReadiness = {
+    readonly state: "READY" | "PENDING" | "RESTRICTED";
+    readonly makerId: string;
+    readonly ownership: MakerOwnership;
+} | {
+    readonly state: "NOT_INDEXED" | "SETUP_REQUIRED" | "WALLET_REQUIRED" | "OWNERSHIP_CONFLICT";
+    readonly ownership: MakerOwnership;
+};
+/** The account's typed client (`createClient`, or `totalis.client`) under the session of the wallet that opened the maker. */
+export type MakerOnboardingClient = ReturnType<typeof audienceClient<ClientPaths>>;
+/**
+ * Read the account's maker (`GET /v1/me/maker`) and, once indexed or
+ * `PENDING`, admit it (`POST /v1/me/maker`, unless `admit: false`). Admission needs no signature
+ * and repeats safely. The POST's 404 (no maker indexed yet) is `NOT_INDEXED`,
+ * not an error.
+ */
+export declare function makerReadiness(client: MakerOnboardingClient, options?: {
+    readonly admit?: boolean;
+    readonly signal?: AbortSignal;
+}): Promise<MakerReadiness>;
+/** `makerReadiness` again every `intervalMs` (default 3000) while `NOT_INDEXED`; resolves with the first other state. */
+export declare function waitForMaker(client: MakerOnboardingClient, options?: {
+    readonly admit?: boolean;
+    readonly signal?: AbortSignal;
+    readonly intervalMs?: number;
+}): Promise<MakerReadiness>;