@depthhq/maker-sdk 0.0.0-stage → 0.1.0

package/dist/backstop/backstop.d.ts

@@ -0,0 +1,35 @@
+import { PublicKey } from "@solana/web3.js";
+import type { MakerClient } from "../client/client.js";
+import type { BackstopInput } from "../client/types.js";
+export type BackstopSnapshot = {
+    offerId: PublicKey;
+    status: string;
+    capacity: bigint;
+    margin: bigint;
+    expiresAt: number;
+};
+type ConfirmOptions = {
+    timeoutMs?: number;
+    pollMs?: number;
+};
+export declare class BackstopHandle {
+    readonly id: PublicKey;
+    private readonly client;
+    readonly signature?: string | undefined;
+    constructor(id: PublicKey, client: MakerClient, signature?: string | undefined);
+    static offer(client: MakerClient, input: BackstopInput): Promise<BackstopHandle>;
+    status(): Promise<BackstopSnapshot>;
+    confirm(options?: ConfirmOptions): Promise<{
+        offerId: PublicKey;
+        snapshot: BackstopSnapshot;
+    }>;
+    release(): Promise<BackstopRelease>;
+    close(): Promise<string>;
+}
+export declare class BackstopRelease {
+    private readonly offer;
+    readonly signature?: string | undefined;
+    constructor(offer: BackstopHandle, signature?: string | undefined);
+    confirm(options?: ConfirmOptions): Promise<BackstopSnapshot>;
+}
+export {};

package/dist/chain/arcium.d.ts

@@ -0,0 +1,18 @@
+import * as anchor from "@anchor-lang/core";
+import type { Connection, PublicKey } from "@solana/web3.js";
+type MxeState = {
+    cluster: number;
+    mxeProgramId: PublicKey;
+};
+export declare function mxeAccount(provider: anchor.AnchorProvider): {
+    fetch(address: PublicKey): Promise<MxeState>;
+};
+export declare function queueAccounts(provider: anchor.AnchorProvider, connection: Connection, name: string, offset: anchor.BN): Promise<{
+    computationAccount: anchor.web3.PublicKey;
+    clusterAccount: anchor.web3.PublicKey;
+    mxeAccount: anchor.web3.PublicKey;
+    mempoolAccount: anchor.web3.PublicKey;
+    executingPool: anchor.web3.PublicKey;
+    compDefAccount: anchor.web3.PublicKey;
+}>;
+export {};

package/dist/chain/random.d.ts

@@ -0,0 +1 @@
+export declare function randomBytes(length: number): Uint8Array;

package/dist/client/client.d.ts

@@ -0,0 +1,176 @@
+import * as anchor from "@anchor-lang/core";
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+import { DepthView } from "@depthhq/sdk/views";
+import { DepthRecovery } from "@depthhq/sdk/recovery";
+import type { FillSnapshot } from "@depthhq/sdk/views";
+import { PublicKey } from "@solana/web3.js";
+import { DepthClient, FundingClient } from "@depthhq/sdk";
+import type { AmountSelector, CloseInput, ReductionInput, ReverseInput, TradeInput } from "@depthhq/sdk";
+import { BackstopHandle } from "../backstop/backstop.js";
+import { FillHistory } from "../fill/history.js";
+import { QuoteHandle } from "../quote/quote.js";
+import { QuoteReplacement } from "../quote/replacement.js";
+import type { GrantState, BackstopInput, MakerOptions, ResolvedMakerOptions, QuoteRequest, QuoteState } from "./types.js";
+export declare class MakerClient {
+    readonly options: ResolvedMakerOptions;
+    readonly provider: anchor.AnchorProvider;
+    readonly program: anchor.Program;
+    readonly position: ReturnType<MakerClient["positionActions"]>;
+    readonly marketAddress: anchor.web3.PublicKey;
+    readonly quoteQueueAddress: anchor.web3.PublicKey;
+    readonly protocolAddress: anchor.web3.PublicKey;
+    readonly backstop: ((id: PublicKey) => BackstopHandle) & {
+        offer: (input: BackstopInput) => Promise<BackstopHandle>;
+    };
+    private ownerClient?;
+    private owned;
+    get funding(): FundingClient;
+    get recovery(): DepthRecovery;
+    private constructor();
+    static create(options: MakerOptions): Promise<MakerClient>;
+    private accountActions;
+    readonly account: (() => {
+        history: (options?: Parameters<DepthClient["account"]["history"]>[0]) => Promise<import("@depthhq/sdk").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        openMarket: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        summary: () => Promise<import("@depthhq/sdk").BalanceSnapshot>;
+        pending: () => Promise<import("@depthhq/sdk").PendingPage>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("@depthhq/sdk").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("@depthhq/sdk").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("@depthhq/sdk").TransferHandle;
+    }) & {
+        history: (options?: Parameters<DepthClient["account"]["history"]>[0]) => Promise<import("@depthhq/sdk").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        openMarket: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        summary: () => Promise<import("@depthhq/sdk").BalanceSnapshot>;
+        pending: () => Promise<import("@depthhq/sdk").PendingPage>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("@depthhq/sdk").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("@depthhq/sdk").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("@depthhq/sdk").TransferHandle;
+    };
+    readonly positions: {
+        list: () => Promise<{
+            items: {
+                id: anchor.web3.PublicKey;
+                marketId: string;
+            }[];
+            nextCursor: null;
+        }>;
+    };
+    readonly trade: {
+        submit: (input: TradeInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        reduce: (input: ReductionInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        close: (input: CloseInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        reverse: (input: ReverseInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+    };
+    marketAccount(): PublicKey;
+    grantAddress(operator?: anchor.web3.PublicKey): PublicKey;
+    read<T>(name: string, address: PublicKey): Promise<T>;
+    quoteState(id: PublicKey): Promise<QuoteState>;
+    queue(name: string, computationOffset: anchor.BN): Promise<{
+        computationAccount: anchor.web3.PublicKey;
+        clusterAccount: anchor.web3.PublicKey;
+        mxeAccount: anchor.web3.PublicKey;
+        mempoolAccount: anchor.web3.PublicKey;
+        executingPool: anchor.web3.PublicKey;
+        compDefAccount: anchor.web3.PublicKey;
+    }>;
+    private grantFor;
+    readonly operator: {
+        list: () => Promise<{
+            id: anchor.web3.PublicKey;
+            state: GrantState;
+        }[]>;
+        authorize: (input: {
+            operator: PublicKey;
+            maxCapacity: bigint;
+            expiresAt: number;
+            canView: boolean;
+        }) => Promise<string>;
+        revoke: (operator: PublicKey) => Promise<string>;
+    };
+    readonly quote: {
+        replacement: (prior: PublicKey, clientNonce: bigint) => QuoteReplacement;
+        publish: (request: QuoteRequest) => Promise<QuoteHandle>;
+        get: (id: PublicKey) => QuoteHandle;
+        list: (options?: {
+            cursor?: string;
+            limit?: number;
+        }) => Promise<{
+            items: {
+                id: anchor.web3.PublicKey;
+                nonce: bigint;
+                status: string;
+                replacementNonce: bigint | undefined;
+                handle: QuoteHandle;
+            }[];
+            nextCursor: string | null;
+        }>;
+        active: () => Promise<QuoteHandle[]>;
+        replace: (prior: PublicKey, input: QuoteRequest, options?: {
+            timeoutMs?: number;
+            pollMs?: number;
+        }) => Promise<QuoteHandle>;
+    };
+    private flatQuote;
+    private viewGrant;
+    requestMarketView(): Promise<DepthView>;
+    requestFillView(order: PublicKey): Promise<DepthView>;
+    requestQuoteView(quote: PublicKey): Promise<DepthView>;
+    private requestView;
+    private positionActions;
+    readonly fills: {
+        list: (options?: Parameters<FillHistory["list"]>[0]) => Promise<import("../fill/history.js").FillPage>;
+        subscribe: (options: {
+            marketId: typeof SOL_USD_MARKET_ID;
+            onFill: (fill: {
+                id: string;
+                signature: string;
+                slot: number;
+                execution: FillSnapshot;
+            }) => Promise<void>;
+            onError: (error: unknown) => void;
+            pollMs?: number;
+        }) => Promise<() => void>;
+        get: (order: PublicKey, options?: {
+            timeoutMs: number;
+            pollMs?: number;
+        }) => Promise<FillSnapshot>;
+    };
+    private validateQuote;
+}
+export declare function createDepthMaker(options: MakerOptions): Promise<MakerClient>;

package/dist/client/types.d.ts

@@ -0,0 +1,98 @@
+import type { ConnectionOptions, ResolvedConnection, DepthWallet } from "@depthhq/sdk";
+import type * as anchor from "@anchor-lang/core";
+import type { PublicKey } from "@solana/web3.js";
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+export type MakerOptions = ConnectionOptions & {
+    wallet: DepthWallet;
+    maker?: PublicKey;
+    makerOwner?: PublicKey;
+    appId?: PublicKey | string;
+    cursorDirectory?: string;
+};
+export type ResolvedMakerOptions = ResolvedConnection & Omit<MakerOptions, keyof ConnectionOptions | "maker" | "appId"> & {
+    maker: PublicKey;
+    appId?: PublicKey;
+};
+export type QuoteTier = {
+    size: bigint;
+    bidE8: bigint;
+    askE8: bigint;
+};
+export type QuoteInput = {
+    tiers: QuoteTier[];
+    maxCapacity: bigint;
+    expiresAt: number;
+    clientNonce: bigint;
+};
+export type FlatQuoteInput = {
+    marketId: typeof SOL_USD_MARKET_ID;
+    bidE8: bigint;
+    askE8: bigint;
+    maxCapacity: bigint;
+    validForSeconds: number;
+    clientNonce?: bigint;
+};
+export type QuoteRequest = QuoteInput | FlatQuoteInput;
+export type QuoteState = {
+    status: Record<string, unknown>;
+    maker: PublicKey;
+    operator: PublicKey;
+    operatorVersion: anchor.BN;
+    market: PublicKey;
+    nonce: anchor.BN;
+    capacity: anchor.BN;
+    expiry: anchor.BN;
+    attachedOrders: number;
+    replacementNonce: anchor.BN | null;
+};
+export type MarketState = {
+    revision: anchor.BN;
+    status: Record<string, unknown>;
+    settlementMint: PublicKey;
+    vault: PublicKey;
+    oracleTimestamp: anchor.BN;
+    pendingOrders: number;
+    backstopOffer: PublicKey;
+    activeQuoteCount: number;
+    activeQuotes: PublicKey[];
+    quotedNotional: anchor.BN;
+    config: {
+        quoteTiers: anchor.BN[];
+        initialMarginBps: number;
+        maxAccountNotional: anchor.BN;
+        maxMarketNotional: anchor.BN;
+        maxQuoteLifetimeSeconds: number;
+        maxOracleAgeSeconds: number;
+        backstopMinCollateral: anchor.BN;
+    };
+};
+export type QuoteQueueState = {
+    market: PublicKey;
+    count: number;
+    entries: PublicKey[];
+};
+export type BackstopInput = {
+    marketId: typeof SOL_USD_MARKET_ID;
+    maxCapacity: bigint;
+    validForSeconds: number;
+    clientNonce?: bigint;
+};
+export type BackstopState = {
+    maker: PublicKey;
+    market: PublicKey;
+    nonce: anchor.BN;
+    capacity: anchor.BN;
+    margin: anchor.BN;
+    expiry: anchor.BN;
+    status: Record<string, unknown>;
+};
+export type GrantState = {
+    active: boolean;
+    canView: boolean;
+    maker: PublicKey;
+    operator: PublicKey;
+    market: PublicKey;
+    maxCapacity: anchor.BN;
+    expiresAt: anchor.BN;
+    version: anchor.BN;
+};

package/dist/fill/browser.d.ts

@@ -0,0 +1,8 @@
+export declare class BrowserCursorStore {
+    readonly key: string;
+    constructor(genesis: string, maker: string);
+    private database;
+    load(): Promise<string | undefined>;
+    save(cursor: string): Promise<void>;
+}
+export declare function createCursorStore(genesis: string, maker: string, _directory?: string): BrowserCursorStore;

package/dist/fill/cursor.d.ts

@@ -0,0 +1,8 @@
+export declare class FillCursorStore {
+    readonly genesis: string;
+    readonly maker: string;
+    readonly path: string;
+    constructor(genesis: string, maker: string, directory?: string);
+    load(): Promise<string | undefined>;
+    save(cursor: string): Promise<void>;
+}

package/dist/fill/history.d.ts

@@ -0,0 +1,25 @@
+import type { MakerClient } from "../client/client.js";
+export type FillPage = {
+    fills: {
+        id: string;
+        signature: string;
+        slot: number;
+    }[];
+    cursor?: string;
+    head?: string;
+};
+export declare class FillHistory {
+    private readonly client;
+    constructor(client: MakerClient);
+    list(options?: {
+        before?: string;
+        until?: string;
+        limit?: number;
+    }): Promise<FillPage>;
+    subscribe(listener: (fill: FillPage["fills"][number]) => Promise<void>, options: {
+        cursor?: string;
+        pollMs?: number;
+        saveCursor: (cursor: string) => Promise<void>;
+        onError: (error: unknown) => void;
+    }): () => void;
+}

package/dist/fill/store.d.ts

@@ -0,0 +1,2 @@
+import { FillCursorStore } from "./cursor.js";
+export declare function createCursorStore(genesis: string, maker: string, directory?: string): FillCursorStore;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createDepthMaker, createDepthMaker as create_depth_maker, MakerClient, } from "./client/client.js";
+export { QuoteHandle } from "./quote/quote.js";
+export { QuoteReplacement } from "./quote/replacement.js";
+export type { ReplacementSnapshot } from "./quote/replacement.js";
+export { BackstopHandle, BackstopRelease } from "./backstop/backstop.js";
+export type { BackstopSnapshot } from "./backstop/backstop.js";
+export type { QuoteSnapshot } from "./quote/quote.js";
+export type { FlatQuoteInput, BackstopInput, MakerOptions, QuoteInput, QuoteRequest, QuoteTier, } from "./client/types.js";
+export type { FillPage } from "./fill/history.js";