@depthhq/sdk 0.0.0-stage → 0.1.1

package/dist/app/app.d.ts

@@ -0,0 +1,50 @@
+import * as anchor from "@anchor-lang/core";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { FundingClient } from "../account/funding.js";
+export type AppSummary = {
+    id: PublicKey;
+    feeBps: number;
+    version: bigint;
+    active: boolean;
+};
+export type ConfirmOptions = {
+    timeoutMs?: number;
+    pollMs?: number;
+    signal?: AbortSignal;
+};
+export declare class AppAdmin {
+    private readonly program;
+    private readonly connection;
+    private readonly owner;
+    private readonly funding;
+    readonly id: PublicKey;
+    readonly address: PublicKey;
+    constructor(program: anchor.Program, connection: Connection, owner: PublicKey, funding: FundingClient);
+    summary(): Promise<AppSummary | undefined>;
+    register(input: {
+        feeBps: number;
+    }): Promise<AppRegistration>;
+    setFee(feeBps: number): Promise<AppUpdate>;
+    setActive(active: boolean): Promise<AppUpdate>;
+    private requireSummary;
+    private validateFee;
+    private update;
+}
+export declare class AppUpdate {
+    private readonly admin;
+    private readonly feeBps;
+    private readonly active;
+    readonly signature: string;
+    constructor(admin: AppAdmin, feeBps: number, active: boolean, signature: string);
+    confirm(): Promise<AppSummary>;
+}
+export declare class AppRegistration {
+    private readonly admin;
+    private readonly funding;
+    private readonly feeBps;
+    readonly signature?: string | undefined;
+    constructor(admin: AppAdmin, funding: FundingClient, feeBps: number, signature?: string | undefined);
+    confirm(options?: ConfirmOptions): Promise<{
+        appId: PublicKey;
+    }>;
+}

package/dist/catalog/catalog.d.ts

@@ -0,0 +1,50 @@
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+import { PublicKey } from "@solana/web3.js";
+import type { DepthClient } from "../client/client.js";
+export type MarketPolicy = {
+    initialMarginBps: number;
+    maintenanceMarginBps: number;
+    liquidationFeeBps: number;
+    tradeFeeBps: number;
+    insuranceFeeBps: number;
+    maxAccountNotional: bigint;
+    maxMarketNotional: bigint;
+    maxOracleAgeSeconds: number;
+    maxConfidenceBps: number;
+    maxQuoteDeviationBps: number;
+    maxQuoteLifetimeSeconds: number;
+    maxOrderQueueSeconds: number;
+    fundingIntervalSeconds: number;
+    fundingRateCapBps: number;
+    quoteTiers: bigint[];
+    backstopMinCollateral: bigint;
+};
+export type MarketSummary = {
+    id: typeof SOL_USD_MARKET_ID;
+    address: PublicKey;
+    settlementMint: PublicKey;
+    status: string;
+    incident: string;
+    revision: bigint;
+    oraclePriceE8: bigint;
+    oracleEmaE8: bigint;
+    oracleConfidenceE8: bigint;
+    oracleTimestamp: bigint;
+    oracleSlot: bigint;
+    fundingIndex: bigint;
+    lastFundingTimestamp: bigint;
+    activeQuoteIds: PublicKey[];
+    waitingQuoteIds: PublicKey[];
+    policy: MarketPolicy;
+    slot: number;
+};
+export declare class MarketCatalog {
+    private readonly client;
+    constructor(client: DepthClient);
+    market(id: string): Promise<MarketSummary>;
+    markets(): Promise<{
+        items: MarketSummary[];
+        nextCursor?: string;
+    }>;
+    marketPolicy(id: string): Promise<MarketPolicy>;
+}

package/dist/catalog/data.d.ts

@@ -0,0 +1,30 @@
+import type { CandleInterval, CandlePage, PublicMarket, PublicApp } from "@depthhq/schema";
+export type { Candle, CandleInterval, CandlePage, PublicMarket, PublicApp, } from "@depthhq/schema";
+import { type DepthEnvironment } from "../chain/network.js";
+export type DataOptions = {
+    environment: DepthEnvironment;
+    serviceUrl?: string;
+};
+export type CandleQuery = {
+    interval?: CandleInterval;
+    before?: number;
+    limit?: number;
+};
+export declare class MarketData {
+    readonly serviceUrl: string;
+    constructor(options: DataOptions);
+    private get;
+    markets(): Promise<{
+        items: PublicMarket[];
+    }>;
+    market(marketId?: string): Promise<PublicMarket>;
+    app(appId: string): Promise<PublicApp>;
+    candles(marketId?: string, query?: CandleQuery, signal?: AbortSignal): Promise<CandlePage>;
+    subscribe(input: {
+        marketId?: string;
+        interval?: CandleInterval;
+        onUpdate: (page: CandlePage) => void;
+        onError: (error: unknown) => void;
+    }): () => void;
+}
+export declare function create_depth_data(options: DataOptions): MarketData;

package/dist/catalog/data.js

@@ -0,0 +1,169 @@
+// src/catalog/data.ts
+import { candleIntervals } from "@depthhq/schema";
+
+// src/chain/network.ts
+var environments = {
+  localnet: {
+    rpc: "http://127.0.0.1:8899",
+    service: "http://127.0.0.1:8787"
+  },
+  devnet: {
+    rpc: "https://api.devnet.solana.com",
+    service: "https://depth.supply",
+    genesis: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG"
+  },
+  "mainnet-beta": {
+    rpc: "https://api.mainnet.solana.com",
+    service: "https://depth.supply",
+    genesis: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d"
+  }
+};
+function endpoint(value, environment, name) {
+  const url = new URL(value);
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    throw new RangeError(`${name} must use HTTPS, or loopback HTTP for local development`);
+  }
+  return url.toString().replace(/\/$/, "");
+}
+
+// src/catalog/data.ts
+function parseCandles(value) {
+  const page = value;
+  if (!page || page.marketId !== "SOL-USD" || page.kind !== "reference" || page.source !== "hyperliquid" || !candleIntervals.includes(page.interval) || !Number.isSafeInteger(page.fetchedAt) || typeof page.stale !== "boolean" || page.nextCursor !== null && !Number.isSafeInteger(page.nextCursor) || !Array.isArray(page.items) || page.items.length > 500) {
+    throw new Error("Invalid reference candle response");
+  }
+  let previous = -1;
+  for (const candle of page.items) {
+    if (!Number.isSafeInteger(candle.time) || candle.time <= previous || [candle.open, candle.high, candle.low, candle.close].some((price) => !Number.isFinite(price) || price <= 0) || candle.high < Math.max(candle.open, candle.close, candle.low) || candle.low > Math.min(candle.open, candle.close))
+      throw new Error("Invalid reference candle");
+    previous = candle.time;
+  }
+  return page;
+}
+
+class MarketData {
+  serviceUrl;
+  constructor(options) {
+    this.serviceUrl = endpoint(options.serviceUrl ?? environments[options.environment].service, options.environment, "serviceUrl");
+  }
+  async get(path, signal) {
+    const response = await fetch(`${this.serviceUrl}${path}`, {
+      signal: signal ?? AbortSignal.timeout(15000),
+      cache: "no-store"
+    });
+    if (!response.ok)
+      throw new Error(`Depth public service returned HTTP ${response.status}`);
+    return response.json();
+  }
+  async markets() {
+    const page = await this.get("/v1/markets");
+    if (!Array.isArray(page.markets))
+      throw new Error("Market discovery is unavailable");
+    return { items: page.markets };
+  }
+  async market(marketId = "SOL-USD") {
+    const market = await this.get(`/v1/markets/${encodeURIComponent(marketId)}`);
+    if (market.id !== marketId)
+      throw new Error("Market response identity mismatch");
+    return market;
+  }
+  async app(appId) {
+    const app = await this.get(`/v1/apps/${encodeURIComponent(appId)}`);
+    if (app.id !== appId || !Number.isSafeInteger(app.fee_bps))
+      throw new Error("App response identity mismatch");
+    return app;
+  }
+  async candles(marketId = "SOL-USD", query = {}, signal) {
+    const params = new URLSearchParams;
+    for (const [name, value] of Object.entries(query))
+      if (value !== undefined)
+        params.set(name, String(value));
+    return parseCandles(await this.get(`/v1/markets/${encodeURIComponent(marketId)}/candles?${params}`, signal));
+  }
+  subscribe(input) {
+    const controller = new AbortController;
+    const signal = controller.signal;
+    const run = async () => {
+      let last = 0;
+      while (!signal.aborted) {
+        try {
+          const url = `${this.serviceUrl}/v1/markets/${encodeURIComponent(input.marketId ?? "SOL-USD")}/stream?interval=${input.interval ?? "15m"}`;
+          const response = await fetch(url, {
+            signal,
+            headers: { accept: "text/event-stream" }
+          });
+          if (!response.ok || !response.body)
+            throw new Error("Market stream is unavailable");
+          const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
+          const abort = () => {
+            reader.cancel().catch(() => {
+              return;
+            });
+          };
+          signal.addEventListener("abort", abort, { once: true });
+          let buffer = "";
+          try {
+            for (;; ) {
+              const part = await reader.read();
+              if (part.done)
+                throw new Error("Market stream disconnected");
+              buffer += part.value.replace(/\r/g, "");
+              if (buffer.length > 1e6)
+                throw new Error("Market stream frame is too large");
+              let boundary;
+              while ((boundary = buffer.indexOf(`
+
+`)) !== -1) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                if (frame.includes("event: unavailable"))
+                  throw new Error("Reference source is unavailable");
+                const line = frame.split(`
+`).find((entry) => entry.startsWith("data: "));
+                if (!line)
+                  continue;
+                const page = parseCandles(JSON.parse(line.slice(6)));
+                if (page.interval !== (input.interval ?? "15m"))
+                  throw new Error("Market stream interval mismatch");
+                if (page.fetchedAt >= last) {
+                  last = page.fetchedAt;
+                  input.onUpdate(page);
+                }
+              }
+            }
+          } finally {
+            signal.removeEventListener("abort", abort);
+            await reader.cancel().catch(() => {
+              return;
+            });
+          }
+        } catch (error) {
+          if (!signal.aborted)
+            input.onError(error);
+        }
+        if (!signal.aborted)
+          await new Promise((resolve) => {
+            const abort = () => {
+              clearTimeout(timer);
+              resolve();
+            };
+            const timer = setTimeout(() => {
+              signal.removeEventListener("abort", abort);
+              resolve();
+            }, 3000);
+            signal.addEventListener("abort", abort, { once: true });
+          });
+      }
+    };
+    run();
+    return () => controller.abort();
+  }
+}
+function create_depth_data(options) {
+  return new MarketData(options);
+}
+export {
+  create_depth_data,
+  MarketData
+};

package/dist/chain/arcium.d.ts

@@ -0,0 +1,10 @@
+import * as anchor from "@anchor-lang/core";
+import { PublicKey } from "@solana/web3.js";
+type MxeState = {
+    cluster: number;
+    mxeProgramId: PublicKey;
+};
+export declare function arciumAccount(provider: anchor.AnchorProvider): {
+    fetch(address: PublicKey): Promise<MxeState>;
+};
+export {};

package/dist/chain/connection.d.ts

@@ -0,0 +1,4 @@
+import { Connection, type Commitment, type TransactionConfirmationStrategy, type RpcResponseAndContext, type SignatureResult } from "@solana/web3.js";
+export declare class HttpConnection extends Connection {
+    confirmTransaction(strategy: TransactionConfirmationStrategy | string, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+}

package/dist/chain/environment.d.ts

@@ -0,0 +1,20 @@
+import { type DepthEnvironment } from "./network.js";
+export { endpoint, environments } from "./network.js";
+export type { DepthEnvironment } from "./network.js";
+import { Connection } from "@solana/web3.js";
+import type { DeploymentPolicy } from "./manifest.js";
+export type ConnectionOptions = {
+    environment?: DepthEnvironment;
+    connection?: Connection;
+    rpcUrl?: string;
+    deployment?: DeploymentPolicy;
+    serviceUrl?: string;
+    manifestUrl?: string;
+};
+export type ResolvedConnection = {
+    connection: Connection;
+    deployment: DeploymentPolicy;
+    serviceUrl?: string;
+    environment?: DepthEnvironment;
+};
+export declare function resolveConnection(options: ConnectionOptions): Promise<ResolvedConnection>;

package/dist/chain/manifest.d.ts

@@ -0,0 +1,36 @@
+import * as anchor from "@anchor-lang/core";
+import { PublicKey } from "@solana/web3.js";
+import { Buffer } from "buffer";
+export type DeploymentManifest = {
+    version: number;
+    expiresAt: number;
+    genesisHash: string;
+    program: string;
+    programHash: string;
+    idlHash: string;
+    mxe: string;
+    cluster: number;
+    settlementMint: string;
+    configHash: string;
+    revision: string;
+    definitions: {
+        name: string;
+        address: string;
+        hash: string;
+    }[];
+};
+export type SignedManifest = {
+    payload: DeploymentManifest;
+    signer: string;
+    signature: string;
+};
+export type DeploymentPolicy = {
+    manifest: SignedManifest;
+    trustedSigner: PublicKey;
+} | {
+    localnet: true;
+};
+export declare function manifestBytes(value: unknown): Buffer;
+export declare function authenticateManifest(signed: SignedManifest, trusted: PublicKey): Promise<void>;
+export declare function captureDeployment(provider: anchor.AnchorProvider, version: number, expiresAt: number): Promise<DeploymentManifest>;
+export declare function verifyDeployment(provider: anchor.AnchorProvider, policy: DeploymentPolicy): Promise<void>;

package/dist/chain/network.d.ts

@@ -0,0 +1,18 @@
+export type DepthEnvironment = "localnet" | "devnet" | "mainnet-beta";
+export declare const environments: {
+    readonly localnet: {
+        readonly rpc: "http://127.0.0.1:8899";
+        readonly service: "http://127.0.0.1:8787";
+    };
+    readonly devnet: {
+        readonly rpc: "https://api.devnet.solana.com";
+        readonly service: "https://depth.supply";
+        readonly genesis: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
+    };
+    readonly "mainnet-beta": {
+        readonly rpc: "https://api.mainnet.solana.com";
+        readonly service: "https://depth.supply";
+        readonly genesis: "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d";
+    };
+};
+export declare function endpoint(value: string, environment: DepthEnvironment, name: string): string;

package/dist/chain/provider.d.ts

@@ -0,0 +1,6 @@
+import * as anchor from "@anchor-lang/core";
+import { Transaction } from "@solana/web3.js";
+export declare function applyDepthComputeBudget(transaction: Transaction): void;
+export declare class DepthProvider extends anchor.AnchorProvider {
+    sendAndConfirm(transaction: Parameters<anchor.AnchorProvider["sendAndConfirm"]>[0], signers?: Parameters<anchor.AnchorProvider["sendAndConfirm"]>[1], options?: Parameters<anchor.AnchorProvider["sendAndConfirm"]>[2]): Promise<string>;
+}

package/dist/chain/random.d.ts

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

package/dist/chain/settlement.d.ts

@@ -0,0 +1,15 @@
+import * as anchor from "@anchor-lang/core";
+import type { Connection, PublicKey, VersionedTransactionResponse } from "@solana/web3.js";
+export type SettlementTransaction = {
+    signature: string;
+    slot: number;
+    orderId: PublicKey;
+    timestamp?: number;
+};
+export declare function settlementOrder(transaction: VersionedTransactionResponse, program: anchor.Program): PublicKey | undefined;
+export declare function settlementTransaction(connection: Connection, program: anchor.Program, address: PublicKey, match: {
+    orderId: PublicKey;
+} | {
+    trader: PublicKey;
+    market: PublicKey;
+}): Promise<SettlementTransaction>;

package/dist/chain/transaction.d.ts

@@ -0,0 +1,12 @@
+import * as anchor from "@anchor-lang/core";
+import type { Connection, PublicKey, VersionedTransactionResponse } from "@solana/web3.js";
+export type ReceiptTransaction = {
+    signature: string;
+    slot: number;
+    timestamp?: number;
+};
+export declare function depthInstructions(transaction: VersionedTransactionResponse, program: anchor.Program): {
+    definition: anchor.IdlInstruction;
+    accounts: (anchor.web3.PublicKey | undefined)[];
+}[];
+export declare function receiptTransaction(connection: Connection, program: anchor.Program, address: PublicKey, names?: readonly string[]): Promise<ReceiptTransaction>;

package/dist/client/client.d.ts

@@ -0,0 +1,137 @@
+import * as anchor from "@anchor-lang/core";
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+import { PublicKey } from "@solana/web3.js";
+import { AppAdmin } from "../app/app.js";
+import { MarketCatalog } from "../catalog/catalog.js";
+import { FundingDiscovery } from "../account/discovery.js";
+import { FundingClient } from "../account/funding.js";
+import { DepthOperation } from "../operation/operation.js";
+import { DepthRecovery } from "../recovery/recovery.js";
+import { ExecutionHistory } from "../history/history.js";
+import type { AmountSelector } from "../trade/amount.js";
+import { TradeFlow } from "../trade/flow.js";
+import { DepthView } from "../view/view.js";
+import type { BalanceSnapshot } from "../view/view.js";
+import type { CloseInput, DepthOptions, ResolvedDepthOptions, MarketState, ReductionInput, ReverseInput, TradeInput } from "./types.js";
+export declare class DepthClient {
+    readonly options: ResolvedDepthOptions;
+    readonly program: anchor.Program;
+    readonly provider: anchor.AnchorProvider;
+    readonly position: ReturnType<DepthClient["positionActions"]>;
+    readonly marketAddress: anchor.web3.PublicKey;
+    readonly protocolAddress: anchor.web3.PublicKey;
+    readonly mxeAddress: anchor.web3.PublicKey;
+    get catalog(): MarketCatalog;
+    get funding(): FundingClient;
+    get app(): AppAdmin;
+    get recovery(): DepthRecovery;
+    private historyClient?;
+    get history(): ExecutionHistory;
+    private constructor();
+    static create(options: DepthOptions): Promise<DepthClient>;
+    private verifyDeployment;
+    private read;
+    private queue;
+    private accountAddress;
+    market(): Promise<{
+        address: PublicKey;
+        state: MarketState;
+        slot: number;
+    }>;
+    operation(id: PublicKey): DepthOperation;
+    requestBalanceView(): Promise<DepthView>;
+    requestMarketView(): Promise<DepthView>;
+    requestFillView(order: PublicKey): Promise<DepthView>;
+    private requestView;
+    private ensureBalanceReady;
+    private ensureMarketReady;
+    private allocateRequest;
+    private releaseRequest;
+    private depositRequest;
+    private withdrawRequest;
+    private accountActions;
+    readonly account: (() => {
+        detail: (item: Parameters<FundingDiscovery["detail"]>[0]) => Promise<import("../account/discovery.js").ReceiptDetail>;
+        transaction: (item: Parameters<FundingDiscovery["transaction"]>[0]) => Promise<import("../account/discovery.js").ReceiptDetail>;
+        history: (options?: Parameters<FundingDiscovery["history"]>[0]) => Promise<import("../account/discovery.js").PendingPage>;
+        pending: (options?: Parameters<FundingDiscovery["pending"]>[0]) => Promise<import("../account/discovery.js").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("../account/funding.js").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("../account/funding.js").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("../account/funding.js").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("../account/funding.js").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("../account/funding.js").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("../account/funding.js").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("../account/funding.js").TransferHandle;
+        summary: (options?: {
+            timeoutMs: number;
+            pollMs?: number;
+        }) => Promise<BalanceSnapshot>;
+    }) & {
+        detail: (item: Parameters<FundingDiscovery["detail"]>[0]) => Promise<import("../account/discovery.js").ReceiptDetail>;
+        transaction: (item: Parameters<FundingDiscovery["transaction"]>[0]) => Promise<import("../account/discovery.js").ReceiptDetail>;
+        history: (options?: Parameters<FundingDiscovery["history"]>[0]) => Promise<import("../account/discovery.js").PendingPage>;
+        pending: (options?: Parameters<FundingDiscovery["pending"]>[0]) => Promise<import("../account/discovery.js").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("../account/funding.js").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("../account/funding.js").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("../account/funding.js").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("../account/funding.js").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("../account/funding.js").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("../account/funding.js").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("../account/funding.js").TransferHandle;
+        summary: (options?: {
+            timeoutMs: number;
+            pollMs?: number;
+        }) => Promise<BalanceSnapshot>;
+    };
+    private positionActions;
+    readonly positions: {
+        list: (options?: {
+            cursor?: string;
+            limit?: number;
+        }) => Promise<{
+            items: {
+                id: anchor.web3.PublicKey;
+                marketId: string;
+            }[];
+            nextCursor: null;
+        }>;
+    };
+    readonly trade: {
+        submit: (input: TradeInput) => Promise<DepthOperation>;
+        reduce: (input: ReductionInput) => Promise<DepthOperation>;
+        close: (input: CloseInput) => Promise<DepthOperation>;
+        reverse: (input: ReverseInput) => Promise<DepthOperation>;
+        operation: (clientNonce: bigint) => DepthOperation;
+        flow: (clientNonce: bigint) => TradeFlow;
+        unpairedAllocations: (options?: Parameters<FundingDiscovery["unpairedAllocations"]>[0]) => Promise<{
+            items: import("../account/discovery.js").UnpairedAllocation[];
+            nextCursor: string | null;
+        }>;
+    };
+    private orderAddress;
+    private submitTrade;
+    private validateTrade;
+}
+export declare function createDepth(options: DepthOptions): Promise<DepthClient>;