@depthhq/sdk 0.0.0-stage → 0.1.1

package/dist/account/confirm.d.ts

@@ -0,0 +1,5 @@
+export type ConfirmOptions = {
+    timeoutMs?: number;
+    pollMs?: number;
+};
+export declare function confirmReceipt<T>(id: string, status: () => Promise<T>, advance: (current: T) => Promise<boolean>, options?: ConfirmOptions): Promise<T>;

package/dist/account/discovery.d.ts

@@ -0,0 +1,49 @@
+import * as anchor from "@anchor-lang/core";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { type ReceiptTransaction } from "../chain/transaction.js";
+export type PendingKind = "deposit" | "allocation" | "release" | "withdrawal" | "trade" | "risk";
+export type PendingItem = {
+    id: PublicKey;
+    kind: PendingKind;
+    status: string;
+    nonce: bigint;
+};
+export type PendingPage = {
+    items: PendingItem[];
+    nextCursor?: string;
+};
+export type ReceiptDetail = ReceiptTransaction & {
+    amount?: bigint;
+};
+export type UnpairedAllocation = {
+    id: PublicKey;
+    nonce: bigint;
+    amount: bigint;
+    status: string;
+    orderId: PublicKey;
+};
+export declare class FundingDiscovery {
+    private readonly program;
+    private readonly connection;
+    private readonly owner;
+    constructor(program: anchor.Program, connection: Connection, owner: PublicKey);
+    transaction(item: PendingItem): Promise<ReceiptDetail>;
+    detail(item: PendingItem): Promise<ReceiptDetail>;
+    unpairedAllocations(options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<{
+        items: UnpairedAllocation[];
+        nextCursor: string | null;
+    }>;
+    pending(options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<PendingPage>;
+    history(options?: {
+        cursor?: string;
+        limit?: number;
+    }): Promise<PendingPage>;
+    private list;
+    private project;
+}

package/dist/account/funding.d.ts

@@ -0,0 +1,86 @@
+import * as anchor from "@anchor-lang/core";
+import { Connection, PublicKey } from "@solana/web3.js";
+import type { ConfirmOptions } from "./confirm.js";
+type Queue = (name: string, offset: anchor.BN) => Promise<Record<string, PublicKey>>;
+export declare class FundingClient {
+    readonly program: anchor.Program;
+    readonly connection: Connection;
+    readonly owner: PublicKey;
+    private readonly queue;
+    readonly market: PublicKey;
+    readonly protocol: PublicKey;
+    readonly balance: PublicKey;
+    readonly marketAccount: PublicKey;
+    constructor(program: anchor.Program, connection: Connection, owner: PublicKey, queue: Queue);
+    private assertOwner;
+    read<T>(name: string, address: PublicKey): Promise<T | undefined>;
+    private recoveryKey;
+    cancelOpenBalance(): Promise<string>;
+    cancelOpenMarket(): Promise<string>;
+    cancelDeposit(id: PublicKey): Promise<string>;
+    cancelTransfer(id: PublicKey, toMarket: boolean, phase: "debiting" | "crediting"): Promise<string>;
+    openBalance(): Promise<{
+        address: PublicKey;
+        signature: string;
+    }>;
+    openMarket(): Promise<{
+        address: PublicKey;
+        signature: string;
+    }>;
+    deposit(source: PublicKey, amount: bigint, clientNonce: bigint): Promise<DepositHandle>;
+    depositHandle(depositNonce: bigint): DepositHandle;
+    withdraw(destination: PublicKey, amount: bigint, clientNonce: bigint): Promise<WithdrawalHandle>;
+    withdrawalHandle(clientNonce: bigint): WithdrawalHandle;
+    cancelWithdrawal(receipt: PublicKey): Promise<string>;
+    allocate(amount: bigint, clientNonce: bigint): Promise<TransferHandle>;
+    release(amount: bigint, clientNonce: bigint): Promise<TransferHandle>;
+    transferHandle(transferNonce: bigint): TransferHandle;
+    private beginTransfer;
+    settleTransfer(id: PublicKey, toMarket: boolean): Promise<string>;
+    refundTransfer(id: PublicKey, destination: PublicKey): Promise<string>;
+    creditDeposit(id: PublicKey): Promise<string>;
+    refundDeposit(id: PublicKey, destination: PublicKey): Promise<string>;
+}
+export declare class DepositHandle {
+    readonly client: FundingClient;
+    readonly nonce: bigint;
+    readonly signature?: string | undefined;
+    readonly id: PublicKey;
+    constructor(client: FundingClient, nonce: bigint, signature?: string | undefined);
+    status(): Promise<"pending" | "crediting" | "credited" | "refunded">;
+    confirm(options?: ConfirmOptions): Promise<"credited">;
+    credit(): Promise<string>;
+    cancel(): Promise<string>;
+    refund(destination: PublicKey): Promise<string>;
+}
+export declare class TransferHandle {
+    readonly client: FundingClient;
+    readonly nonce: bigint;
+    readonly signature?: string | undefined;
+    readonly id: PublicKey;
+    constructor(client: FundingClient, nonce: bigint, signature?: string | undefined);
+    status(): Promise<{
+        state: string;
+        toMarket: boolean;
+        amount: bigint;
+    }>;
+    confirm(options?: ConfirmOptions): Promise<{
+        state: "settled";
+        toMarket: boolean;
+        amount: bigint;
+    }>;
+    settle(): Promise<string>;
+    cancel(): Promise<string>;
+    refund(destination: PublicKey): Promise<string>;
+}
+export declare class WithdrawalHandle {
+    readonly client: FundingClient;
+    readonly nonce: bigint;
+    readonly signature?: string | undefined;
+    readonly id: PublicKey;
+    constructor(client: FundingClient, nonce: bigint, signature?: string | undefined);
+    status(): Promise<"queued" | "paid" | "rejected" | "cancelled">;
+    confirm(options?: ConfirmOptions): Promise<"paid">;
+    cancel(): Promise<string>;
+}
+export {};

package/dist/account/funding.js

@@ -0,0 +1,498 @@
+// src/account/funding.ts
+import * as anchor2 from "@anchor-lang/core";
+import {
+  balanceAddress,
+  depositAddress,
+  marketAccountAddress,
+  marketAddress,
+  protocolAddress,
+  recoveryConfigAddress,
+  transferAddress,
+  withdrawalAddress
+} from "@depthhq/bindings";
+
+// src/chain/random.ts
+function randomBytes(length) {
+  return crypto.getRandomValues(new Uint8Array(length));
+}
+
+// src/operation/error.ts
+class DepthError extends Error {
+  code;
+  stage;
+  retryable;
+  nextAction;
+  operationId;
+  constructor(code, stage, message, retryable, nextAction, operationId, options) {
+    super(message, options);
+    this.code = code;
+    this.stage = stage;
+    this.retryable = retryable;
+    this.nextAction = nextAction;
+    this.operationId = operationId;
+    this.name = "DepthError";
+  }
+}
+function submissionError(operationId, cause) {
+  throw new DepthError("SUBMISSION_UNCONFIRMED", "submission", "Submission was not confirmed; reconcile the saved operation before retrying", true, "Read the operation using the saved client nonce; do not create a new nonce", operationId, { cause });
+}
+
+// src/account/confirm.ts
+async function confirmReceipt(id, status, advance, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 60000;
+  const pollMs = options.pollMs ?? 1000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || !Number.isSafeInteger(pollMs) || pollMs < 100)
+    throw new RangeError("Invalid confirmation timing");
+  const deadline = Date.now() + timeoutMs;
+  for (;; ) {
+    const current = await status();
+    if (await advance(current))
+      return current;
+    if (Date.now() >= deadline)
+      throw new DepthError("RECEIPT_PENDING", "confirmation", "The operation is still pending", true, "Restore this receipt with its nonce and continue confirmation", id);
+    await new Promise((resolve) => setTimeout(resolve, Math.min(pollMs, deadline - Date.now())));
+  }
+}
+
+// src/trade/input.ts
+import * as anchor from "@anchor-lang/core";
+function u64(value, name) {
+  if (typeof value !== "bigint" || value < 0n || value > (1n << 64n) - 1n) {
+    throw new RangeError(`${name} must be an unsigned 64-bit bigint`);
+  }
+  return new anchor.BN(value.toString());
+}
+
+// src/account/funding.ts
+function offset() {
+  return new anchor2.BN(randomBytes(8), "le");
+}
+function status(value) {
+  return Object.keys(value)[0] ?? "unknown";
+}
+
+class FundingClient {
+  program;
+  connection;
+  owner;
+  queue;
+  market;
+  protocol;
+  balance;
+  marketAccount;
+  constructor(program, connection, owner, queue) {
+    this.program = program;
+    this.connection = connection;
+    this.owner = owner;
+    this.queue = queue;
+    this.market = marketAddress(program.programId);
+    this.protocol = protocolAddress(program.programId);
+    this.balance = balanceAddress(owner, program.programId);
+    this.marketAccount = marketAccountAddress(owner, program.programId);
+  }
+  assertOwner() {
+    const wallet = this.program.provider.wallet;
+    if (!wallet.publicKey.equals(this.owner)) {
+      throw new Error("Only the account owner can move collateral");
+    }
+  }
+  async read(name, address) {
+    const info = await this.connection.getAccountInfo(address, "confirmed");
+    if (!info)
+      return;
+    if (!info.owner.equals(this.program.programId)) {
+      throw new Error(`${name} is not owned by Depth`);
+    }
+    return this.program.coder.accounts.decode(name[0].toLowerCase() + name.slice(1), info.data);
+  }
+  async recoveryKey() {
+    const config = await this.read("RecoveryConfig", recoveryConfigAddress(this.program.programId));
+    if (!config || !config.market.equals(this.market) || config.recoveryKey.length !== 32) {
+      throw new Error("Market recovery configuration is unavailable");
+    }
+    return config.recoveryKey;
+  }
+  async cancelOpenBalance() {
+    this.assertOwner();
+    return this.program.methods.cancelOpenBalance().accountsPartial({ owner: this.owner, balance: this.balance }).rpc({ commitment: "confirmed" });
+  }
+  async cancelOpenMarket() {
+    this.assertOwner();
+    return this.program.methods.cancelOpenMarket().accountsPartial({ owner: this.owner, marketAccount: this.marketAccount }).rpc({ commitment: "confirmed" });
+  }
+  async cancelDeposit(id) {
+    this.assertOwner();
+    return this.program.methods.cancelCredit().accountsPartial({
+      owner: this.owner,
+      balance: this.balance,
+      receipt: id
+    }).rpc({ commitment: "confirmed" });
+  }
+  async cancelTransfer(id, toMarket, phase) {
+    this.assertOwner();
+    const free = phase === "debiting" ? toMarket : !toMarket;
+    const method = phase === "debiting" ? free ? this.program.methods.cancelFreeDebit : this.program.methods.cancelMarketDebit : free ? this.program.methods.cancelFreeCredit : this.program.methods.cancelMarketCredit;
+    return method().accountsPartial({
+      owner: this.owner,
+      transfer: id,
+      ...free ? { balance: this.balance } : { marketAccount: this.marketAccount }
+    }).rpc({ commitment: "confirmed" });
+  }
+  async openBalance() {
+    this.assertOwner();
+    if (await this.read("BalanceAccount", this.balance)) {
+      throw new Error("Balance account already exists");
+    }
+    const computationOffset = offset();
+    const signature = await this.program.methods.openBalance(computationOffset, await this.recoveryKey()).accountsPartial({
+      ...await this.queue("open_balance", computationOffset),
+      payer: this.owner,
+      protocol: this.protocol,
+      balance: this.balance
+    }).rpc({ commitment: "confirmed" });
+    return { address: this.balance, signature };
+  }
+  async openMarket() {
+    this.assertOwner();
+    if (await this.read("MarketAccount", this.marketAccount)) {
+      throw new Error("Market account already exists");
+    }
+    const computationOffset = offset();
+    const signature = await this.program.methods.openMarketAccount(computationOffset, await this.recoveryKey()).accountsPartial({
+      ...await this.queue("open_market", computationOffset),
+      payer: this.owner,
+      protocol: this.protocol,
+      market: this.market,
+      recoveryConfig: recoveryConfigAddress(this.program.programId),
+      marketAccount: this.marketAccount
+    }).rpc({ commitment: "confirmed" });
+    return { address: this.marketAccount, signature };
+  }
+  async deposit(source, amount, clientNonce) {
+    this.assertOwner();
+    u64(amount, "amount");
+    if (amount === 0n)
+      throw new RangeError("Deposit amount must be positive");
+    const depositNonce = clientNonce;
+    u64(clientNonce, "clientNonce");
+    const receipt = depositAddress(this.owner, depositNonce, this.program.programId);
+    const existing = await this.read("DepositReceipt", receipt);
+    if (existing) {
+      if (!existing.owner.equals(this.owner) || BigInt(existing.amount.toString()) !== amount) {
+        throw new Error("Deposit nonce is already bound to another request");
+      }
+      return this.depositHandle(clientNonce);
+    }
+    const protocol = await this.read("Protocol", this.protocol);
+    if (!protocol)
+      throw new Error("Protocol is unavailable");
+    const signature = await this.program.methods.deposit(u64(depositNonce, "nonce"), u64(amount, "amount")).accountsPartial({
+      owner: this.owner,
+      protocol: this.protocol,
+      settlementMint: protocol.settlementMint,
+      source,
+      vault: protocol.vault,
+      receipt
+    }).rpc({ commitment: "confirmed" }).catch((error) => submissionError(receipt.toBase58(), error));
+    return new DepositHandle(this, depositNonce, signature);
+  }
+  depositHandle(depositNonce) {
+    u64(depositNonce, "nonce");
+    return new DepositHandle(this, depositNonce);
+  }
+  async withdraw(destination, amount, clientNonce) {
+    this.assertOwner();
+    u64(amount, "amount");
+    u64(clientNonce, "clientNonce");
+    if (amount === 0n)
+      throw new RangeError("Withdrawal amount must be positive");
+    const handle = this.withdrawalHandle(clientNonce);
+    const existing = await this.read("WithdrawalReceipt", handle.id);
+    if (existing) {
+      if (!existing.owner.equals(this.owner) || !existing.destination.equals(destination) || BigInt(existing.amount.toString()) !== amount) {
+        throw new Error("Withdrawal nonce is already bound to another request");
+      }
+      return handle;
+    }
+    const computationOffset = offset();
+    const signature = await this.program.methods.requestWithdrawal(computationOffset, u64(clientNonce, "clientNonce"), u64(amount, "amount")).accountsPartial({
+      ...await this.queue("debit_balance", computationOffset),
+      payer: this.owner,
+      protocol: this.protocol,
+      destination,
+      balance: this.balance,
+      receipt: handle.id
+    }).rpc({ commitment: "confirmed" }).catch((error) => submissionError(handle.id.toBase58(), error));
+    return new WithdrawalHandle(this, clientNonce, signature);
+  }
+  withdrawalHandle(clientNonce) {
+    u64(clientNonce, "clientNonce");
+    return new WithdrawalHandle(this, clientNonce);
+  }
+  async cancelWithdrawal(receipt) {
+    this.assertOwner();
+    return this.program.methods.cancelWithdrawal().accountsPartial({ owner: this.owner, balance: this.balance, receipt }).rpc({ commitment: "confirmed" });
+  }
+  async allocate(amount, clientNonce) {
+    return this.beginTransfer("allocation", amount, clientNonce);
+  }
+  async release(amount, clientNonce) {
+    return this.beginTransfer("release", amount, clientNonce);
+  }
+  transferHandle(transferNonce) {
+    u64(transferNonce, "nonce");
+    return new TransferHandle(this, transferNonce);
+  }
+  async beginTransfer(kind, amount, clientNonce) {
+    this.assertOwner();
+    u64(amount, "amount");
+    if (amount === 0n)
+      throw new RangeError("Margin amount must be positive");
+    const transferNonce = clientNonce;
+    u64(clientNonce, "clientNonce");
+    const transfer = transferAddress(this.owner, transferNonce, this.program.programId);
+    const existing = await this.read("MarginTransfer", transfer);
+    if (existing) {
+      if (!existing.owner.equals(this.owner) || !existing.market.equals(this.market) || existing.toMarket !== (kind === "allocation") || BigInt(existing.amount.toString()) !== amount) {
+        throw new Error("Transfer nonce is already bound to another request");
+      }
+      return this.transferHandle(clientNonce);
+    }
+    const computationOffset = offset();
+    const queue = await this.queue(kind === "allocation" ? "debit_free" : "debit_market", computationOffset);
+    const accounts = {
+      ...queue,
+      payer: this.owner,
+      protocol: this.protocol,
+      market: this.market,
+      ...kind === "allocation" ? { balance: this.balance } : { marketAccount: this.marketAccount },
+      transfer
+    };
+    const method = kind === "allocation" ? this.program.methods.beginAllocation : this.program.methods.beginRelease;
+    const signature = await method(computationOffset, u64(transferNonce, "nonce"), u64(amount, "amount")).accountsPartial(accounts).rpc({ commitment: "confirmed" }).catch((error) => submissionError(transfer.toBase58(), error));
+    return new TransferHandle(this, transferNonce, signature);
+  }
+  async settleTransfer(id, toMarket) {
+    this.assertOwner();
+    const computationOffset = offset();
+    const name = toMarket ? "credit_market" : "credit_free";
+    const method = toMarket ? this.program.methods.settleAllocation : this.program.methods.settleRelease;
+    return method(computationOffset).accountsPartial({
+      ...await this.queue(name, computationOffset),
+      payer: this.owner,
+      protocol: this.protocol,
+      market: this.market,
+      transfer: id,
+      ...toMarket ? { marketAccount: this.marketAccount } : { balance: this.balance }
+    }).rpc({ commitment: "confirmed" });
+  }
+  async refundTransfer(id, destination) {
+    this.assertOwner();
+    const protocol = await this.read("Protocol", this.protocol);
+    if (!protocol)
+      throw new Error("Protocol is unavailable");
+    return this.program.methods.refundEscrow().accountsPartial({
+      owner: this.owner,
+      protocol: this.protocol,
+      settlementMint: protocol.settlementMint,
+      vault: protocol.vault,
+      destination,
+      transfer: id
+    }).rpc({ commitment: "confirmed" });
+  }
+  async creditDeposit(id) {
+    this.assertOwner();
+    const balance = await this.read("BalanceAccount", this.balance);
+    if (!balance || !balance.owner.equals(this.owner) || status(balance.status) !== "ready") {
+      throw new Error("Balance is unavailable or busy");
+    }
+    const computationOffset = offset();
+    return this.program.methods.creditDeposit(computationOffset).accountsPartial({
+      ...await this.queue("credit_balance", computationOffset),
+      payer: this.owner,
+      protocol: this.protocol,
+      balance: this.balance,
+      receipt: id
+    }).rpc({ commitment: "confirmed" });
+  }
+  async refundDeposit(id, destination) {
+    this.assertOwner();
+    const protocol = await this.read("Protocol", this.protocol);
+    if (!protocol)
+      throw new Error("Protocol is unavailable");
+    return this.program.methods.refundDeposit().accountsPartial({
+      owner: this.owner,
+      protocol: this.protocol,
+      settlementMint: protocol.settlementMint,
+      vault: protocol.vault,
+      destination,
+      receipt: id
+    }).rpc({ commitment: "confirmed" });
+  }
+}
+
+class DepositHandle {
+  client;
+  nonce;
+  signature;
+  id;
+  constructor(client, nonce, signature) {
+    this.client = client;
+    this.nonce = nonce;
+    this.signature = signature;
+    this.id = depositAddress(client.owner, nonce, client.program.programId);
+  }
+  async status() {
+    const receipt = await this.client.read("DepositReceipt", this.id);
+    if (!receipt || !receipt.owner.equals(this.client.owner)) {
+      throw new Error("Deposit receipt is unavailable");
+    }
+    const current = status(receipt.status);
+    if (!["pending", "crediting", "credited", "refunded"].includes(current)) {
+      throw new Error("Unknown deposit status");
+    }
+    return current;
+  }
+  async confirm(options) {
+    await confirmReceipt(this.id.toBase58(), () => this.status(), async (state) => {
+      if (state === "credited")
+        return true;
+      if (state === "refunded")
+        throw new DepthError("DEPOSIT_REFUNDED", "confirmation", "Deposit was refunded", false, "Read the receipt before funding again", this.id.toBase58());
+      if (state === "pending") {
+        try {
+          await this.credit();
+        } catch (error) {
+          if (await this.status() === "pending")
+            throw error;
+        }
+      }
+      return false;
+    }, options);
+    return "credited";
+  }
+  async credit() {
+    if (await this.status() !== "pending") {
+      throw new Error("Deposit is not pending credit");
+    }
+    return this.client.creditDeposit(this.id);
+  }
+  async cancel() {
+    if (await this.status() !== "crediting")
+      throw new Error("Deposit credit is not pending");
+    return this.client.cancelDeposit(this.id);
+  }
+  async refund(destination) {
+    if (await this.status() !== "pending") {
+      throw new Error("Deposit is not refundable");
+    }
+    return this.client.refundDeposit(this.id, destination);
+  }
+}
+
+class TransferHandle {
+  client;
+  nonce;
+  signature;
+  id;
+  constructor(client, nonce, signature) {
+    this.client = client;
+    this.nonce = nonce;
+    this.signature = signature;
+    this.id = transferAddress(client.owner, nonce, client.program.programId);
+  }
+  async status() {
+    const transfer = await this.client.read("MarginTransfer", this.id);
+    if (!transfer || !transfer.owner.equals(this.client.owner) || !transfer.market.equals(this.client.market)) {
+      throw new Error("Margin transfer is unavailable");
+    }
+    return {
+      state: status(transfer.status),
+      toMarket: transfer.toMarket,
+      amount: BigInt(transfer.amount.toString())
+    };
+  }
+  async confirm(options) {
+    const settled = await confirmReceipt(this.id.toBase58(), () => this.status(), async (transfer) => {
+      if (transfer.state === "settled")
+        return true;
+      if (transfer.state === "rejected" || transfer.state === "refunded" || transfer.state === "cancelled")
+        throw new DepthError("MARGIN_REJECTED", "confirmation", `Margin transfer ${transfer.state}`, false, "Read the receipt and private account before retrying", this.id.toBase58());
+      if (transfer.state === "escrow") {
+        try {
+          await this.settle();
+        } catch (error) {
+          if ((await this.status()).state === "escrow")
+            throw error;
+        }
+      }
+      return false;
+    }, options);
+    return { ...settled, state: "settled" };
+  }
+  async settle() {
+    const transfer = await this.status();
+    if (transfer.state !== "escrow") {
+      throw new Error("Margin transfer is not ready to settle");
+    }
+    return this.client.settleTransfer(this.id, transfer.toMarket);
+  }
+  async cancel() {
+    const transfer = await this.status();
+    if (transfer.state !== "debiting" && transfer.state !== "crediting")
+      throw new Error("Transfer computation is not pending");
+    return this.client.cancelTransfer(this.id, transfer.toMarket, transfer.state);
+  }
+  async refund(destination) {
+    const transfer = await this.status();
+    if (transfer.state !== "escrow") {
+      throw new Error("Margin transfer is not refundable");
+    }
+    return this.client.refundTransfer(this.id, destination);
+  }
+}
+
+class WithdrawalHandle {
+  client;
+  nonce;
+  signature;
+  id;
+  constructor(client, nonce, signature) {
+    this.client = client;
+    this.nonce = nonce;
+    this.signature = signature;
+    this.id = withdrawalAddress(client.owner, nonce, client.program.programId);
+  }
+  async status() {
+    const receipt = await this.client.read("WithdrawalReceipt", this.id);
+    if (!receipt || !receipt.owner.equals(this.client.owner) || !receipt.balance.equals(this.client.balance)) {
+      throw new Error("Withdrawal receipt is unavailable");
+    }
+    const state = status(receipt.status);
+    if (!["queued", "paid", "rejected", "cancelled"].includes(state)) {
+      throw new Error("Unknown withdrawal status");
+    }
+    return state;
+  }
+  async confirm(options) {
+    await confirmReceipt(this.id.toBase58(), () => this.status(), async (state) => {
+      if (state === "paid")
+        return true;
+      if (state === "rejected" || state === "cancelled")
+        throw new DepthError("WITHDRAWAL_REJECTED", "confirmation", `Withdrawal ${state}`, false, "Read the receipt and private balance before retrying", this.id.toBase58());
+      return false;
+    }, options);
+    return "paid";
+  }
+  async cancel() {
+    if (await this.status() !== "queued")
+      throw new Error("Withdrawal is not queued");
+    return this.client.cancelWithdrawal(this.id);
+  }
+}
+export {
+  WithdrawalHandle,
+  TransferHandle,
+  FundingClient,
+  DepositHandle
+};

package/dist/account/release.d.ts

@@ -0,0 +1,8 @@
+export type ReleasePosition = {
+    collateral: bigint;
+    reserved: bigint;
+    position: bigint;
+    entryPriceE8: bigint;
+    fundingCheckpoint: bigint;
+};
+export declare function releasableMargin(state: ReleasePosition, oraclePriceE8: bigint, fundingIndex: bigint, initialMarginBps: number): bigint;

package/dist/account/token.d.ts

@@ -0,0 +1,5 @@
+import * as anchor from "@anchor-lang/core";
+import { Connection, PublicKey } from "@solana/web3.js";
+export declare function associatedTokenAddress(owner: PublicKey, mint: PublicKey): PublicKey;
+export declare function sourceTokenAccount(connection: Connection, owner: PublicKey, mint: PublicKey, amount: bigint): Promise<PublicKey>;
+export declare function destinationTokenAccount(provider: anchor.AnchorProvider, owner: PublicKey, mint: PublicKey): Promise<PublicKey>;