@depthhq/sdk 0.1.1 → 0.1.3

package/dist/account/funding.d.ts

@@ -7,11 +7,12 @@ export declare class FundingClient {
     readonly connection: Connection;
     readonly owner: PublicKey;
     private readonly queue;
+    readonly settlement: "keeper" | "wallet";
     readonly market: PublicKey;
     readonly protocol: PublicKey;
     readonly balance: PublicKey;
     readonly marketAccount: PublicKey;
-    constructor(program: anchor.Program, connection: Connection, owner: PublicKey, queue: Queue);
+    constructor(program: anchor.Program, connection: Connection, owner: PublicKey, queue: Queue, settlement?: "keeper" | "wallet");
     private assertOwner;
     read<T>(name: string, address: PublicKey): Promise<T | undefined>;
     private recoveryKey;

package/dist/account/funding.js

@@ -76,15 +76,17 @@ class FundingClient {
   connection;
   owner;
   queue;
+  settlement;
   market;
   protocol;
   balance;
   marketAccount;
-  constructor(program, connection, owner, queue) {
+  constructor(program, connection, owner, queue, settlement = "wallet") {
     this.program = program;
     this.connection = connection;
     this.owner = owner;
     this.queue = queue;
+    this.settlement = settlement;
     this.market = marketAddress(program.programId);
     this.protocol = protocolAddress(program.programId);
     this.balance = balanceAddress(owner, program.programId);
@@ -418,7 +420,7 @@ class TransferHandle {
         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") {
+      if (transfer.state === "escrow" && this.client.settlement === "wallet") {
         try {
           await this.settle();
         } catch (error) {

package/dist/account/state.d.ts

@@ -0,0 +1,9 @@
+import * as anchor from "@anchor-lang/core";
+import { Connection, PublicKey } from "@solana/web3.js";
+export type AccountState = {
+    id: string;
+    status: "uninitialized" | "opening" | "ready" | "crediting" | "withdrawing" | "moving" | "claiming";
+    version: bigint;
+    slot: number;
+};
+export declare function balanceState(program: anchor.Program, connection: Connection, owner: PublicKey, address: PublicKey): Promise<AccountState>;

package/dist/chain/environment.d.ts

@@ -18,3 +18,4 @@ export type ResolvedConnection = {
     environment?: DepthEnvironment;
 };
 export declare function resolveConnection(options: ConnectionOptions): Promise<ResolvedConnection>;
+export declare function prepare_depth(options: ConnectionOptions): Promise<ResolvedConnection>;

package/dist/chain/manifest.d.ts

@@ -32,5 +32,5 @@ export type DeploymentPolicy = {
 };
 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>;
+export declare function captureDeployment(provider: Pick<anchor.Provider, "connection">, version: number, expiresAt: number): Promise<DeploymentManifest>;
+export declare function verifyDeployment(provider: Pick<anchor.Provider, "connection">, policy: DeploymentPolicy): Promise<void>;

package/dist/chain/provider.d.ts

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

package/dist/client/client.d.ts

@@ -1,6 +1,7 @@
 import * as anchor from "@anchor-lang/core";
 import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
 import { PublicKey } from "@solana/web3.js";
+import { DepthProvider } from "../chain/provider.js";
 import { AppAdmin } from "../app/app.js";
 import { MarketCatalog } from "../catalog/catalog.js";
 import { FundingDiscovery } from "../account/discovery.js";
@@ -16,7 +17,9 @@ import type { CloseInput, DepthOptions, ResolvedDepthOptions, MarketState, Reduc
 export declare class DepthClient {
     readonly options: ResolvedDepthOptions;
     readonly program: anchor.Program;
-    readonly provider: anchor.AnchorProvider;
+    readonly provider: DepthProvider;
+    private readonly views;
+    private readonly viewReads;
     readonly position: ReturnType<DepthClient["positionActions"]>;
     readonly marketAddress: anchor.web3.PublicKey;
     readonly protocolAddress: anchor.web3.PublicKey;
@@ -51,6 +54,7 @@ export declare class DepthClient {
     private withdrawRequest;
     private accountActions;
     readonly account: (() => {
+        state: () => Promise<import("../account/state.js").AccountState>;
         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>;
@@ -78,6 +82,7 @@ export declare class DepthClient {
             pollMs?: number;
         }) => Promise<BalanceSnapshot>;
     }) & {
+        state: () => Promise<import("../account/state.js").AccountState>;
         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>;
@@ -131,7 +136,12 @@ export declare class DepthClient {
         }>;
     };
     private orderAddress;
+    private deferViewClose;
+    private viewState;
+    private summaryView;
+    private readSummaryView;
     private submitTrade;
+    private waitForMarket;
     private validateTrade;
 }
 export declare function createDepth(options: DepthOptions): Promise<DepthClient>;

package/dist/client/types.d.ts

@@ -11,10 +11,14 @@ export type DepthWallet = {
 export type DepthOptions = ConnectionOptions & {
     appId?: PublicKey | string;
     wallet: DepthWallet;
+    privateViews?: "memory" | "device";
+    settlement?: "keeper" | "wallet";
 };
 export type ResolvedDepthOptions = ResolvedConnection & {
     appId?: PublicKey;
     wallet: DepthWallet;
+    privateViews?: "memory" | "device";
+    settlement?: "keeper" | "wallet";
 };
 export type TradeTerms = {
     marketId: typeof SOL_USD_MARKET_ID;

package/dist/index.d.ts

@@ -26,7 +26,8 @@ export { resolveAmount } from "./trade/amount.js";
 export type { AmountSelector } from "./trade/amount.js";
 export type { BalanceSnapshot, FillSnapshot, PositionSnapshot, QuoteBalanceSnapshot, } from "./view/view.js";
 export type { DepthOptions, DepthWallet, TradeInput, ReductionInput, CloseInput, ReverseInput, TradeIntent, } from "./client/types.js";
-export { resolveConnection } from "./chain/environment.js";
+export { resolveConnection, prepare_depth } from "./chain/environment.js";
+export type { AccountState } from "./account/state.js";
 export type { ConnectionOptions, ResolvedConnection, DepthEnvironment, } from "./chain/environment.js";
 export { DepthError } from "./operation/error.js";
 export { DepthProvider } from "./chain/provider.js";

package/dist/index.js

@@ -43628,7 +43628,7 @@ import {
   recoveryConfigAddress as recoveryConfigAddress2,
   SOL_USD_MARKET_ID as SOL_USD_MARKET_ID3
 } from "@depthhq/bindings";
-import { PublicKey as PublicKey9 } from "@solana/web3.js";
+import { PublicKey as PublicKey10 } from "@solana/web3.js";
 
 // src/chain/random.ts
 function randomBytes3(length) {
@@ -44491,7 +44491,7 @@ async function captureDeployment(provider, version, expiresAt) {
   const protocol = coder.decode("protocol", protocolInfo.data);
   if (!market.settlementMint.equals(protocol.settlementMint))
     throw new Error("Deployment settlement mints disagree");
-  const arcium2 = getArciumProgram(provider);
+  const arcium2 = new anchor2.Program(ARCIUM_IDL, provider);
   const mxeAddress = getMXEAccAddress(DEPTH_PROGRAM_ID);
   const mxe = await arcium2.account.mxeAccount.fetch(mxeAddress);
   if (!mxe.mxeProgramId.equals(DEPTH_PROGRAM_ID))
@@ -44521,6 +44521,7 @@ async function captureDeployment(provider, version, expiresAt) {
     })
   };
 }
+var verified = new WeakMap;
 async function verifyDeployment(provider, policy) {
   if ("localnet" in policy) {
     const url = new URL(provider.connection.rpcEndpoint);
@@ -44530,9 +44531,28 @@ async function verifyDeployment(provider, policy) {
   }
   await authenticateManifest(policy.manifest, policy.trustedSigner);
   const expected = policy.manifest.payload;
-  const actual = await captureDeployment(provider, expected.version, expected.expiresAt);
-  if (!manifestBytes(actual).equals(manifestBytes(expected)))
-    throw new Error("Signed deployment does not match the connected chain");
+  const key = manifestBytes(policy.manifest).toString("base64");
+  const previous = verified.get(provider.connection);
+  if (previous?.key === key && previous.expiresAt > Date.now())
+    return previous.task;
+  const task = (async () => {
+    const actual = await captureDeployment(provider, expected.version, expected.expiresAt);
+    if (!manifestBytes(actual).equals(manifestBytes(expected)))
+      throw new Error("Signed deployment does not match the connected chain");
+  })();
+  const entry = {
+    key,
+    expiresAt: Math.min(Date.now() + 30000, expected.expiresAt * 1000),
+    task
+  };
+  verified.set(provider.connection, entry);
+  try {
+    await task;
+  } catch (error) {
+    if (verified.get(provider.connection) === entry)
+      verified.delete(provider.connection);
+    throw error;
+  }
 }
 
 // src/chain/network.ts
@@ -44687,6 +44707,11 @@ async function resolveConnection(options) {
     throw unavailable("Depth deployment could not be verified", error);
   }
 }
+async function prepare_depth(options) {
+  const resolved = await resolveConnection(options);
+  await verifyDeployment({ connection: resolved.connection }, resolved.deployment);
+  return resolved;
+}
 
 // src/chain/arcium.ts
 function arciumAccount(provider) {
@@ -44701,6 +44726,7 @@ import { DEPTH_IDL as DEPTH_IDL2, DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID3 } from "
 import {
   ComputeBudgetProgram,
   SendTransactionError,
+  PublicKey as PublicKey4,
   Transaction
 } from "@solana/web3.js";
 var queuedInstructions = new Set([
@@ -44743,11 +44769,52 @@ function applyDepthComputeBudget(transaction) {
 }
 
 class DepthProvider extends anchor3.AnchorProvider {
+  cleanup = new Map;
+  deferClose(id, instruction) {
+    this.cleanup.set(id.toBase58(), instruction);
+  }
+  async appendCleanup(transaction) {
+    if (!this.cleanup.size || transaction.signatures.some((item) => item.signature))
+      return [];
+    const entries = [...this.cleanup.entries()].slice(0, 64);
+    const queued = new Set(entries.map(([, instruction]) => instruction));
+    transaction.instructions = transaction.instructions.filter((instruction) => !queued.has(instruction));
+    const accounts2 = await this.connection.getMultipleAccountsInfo(entries.map(([id]) => new PublicKey4(id)), "confirmed");
+    const added = [];
+    for (let index = 0;index < entries.length; index++) {
+      const [id, instruction] = entries[index];
+      if (!accounts2[index]?.owner.equals(DEPTH_PROGRAM_ID3)) {
+        this.cleanup.delete(id);
+        continue;
+      }
+      const candidate = new Transaction({
+        feePayer: transaction.feePayer ?? this.wallet.publicKey,
+        recentBlockhash: transaction.recentBlockhash ?? PublicKey4.default.toBase58()
+      }).add(...transaction.instructions, instruction);
+      try {
+        candidate.serialize({
+          requireAllSignatures: false,
+          verifySignatures: false
+        });
+      } catch {
+        continue;
+      }
+      transaction.add(instruction);
+      added.push(id);
+    }
+    return added;
+  }
   async sendAndConfirm(transaction, signers, options) {
-    if (transaction instanceof Transaction)
+    let cleanup = [];
+    if (transaction instanceof Transaction) {
       applyDepthComputeBudget(transaction);
+      cleanup = await this.appendCleanup(transaction);
+    }
     try {
-      return await super.sendAndConfirm(transaction, signers, options);
+      const signature = await super.sendAndConfirm(transaction, signers, options);
+      for (const id of cleanup)
+        this.cleanup.delete(id);
+      return signature;
     } catch (error) {
       if (!(error instanceof Error) || !error.message.includes("Unknown action 'undefined'"))
         throw error;
@@ -44998,7 +45065,7 @@ import {
   transferAddress,
   withdrawalAddress
 } from "@depthhq/bindings";
-import { PublicKey as PublicKey4 } from "@solana/web3.js";
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
 
 // src/chain/transaction.ts
 init_buffer();
@@ -45156,7 +45223,7 @@ class FundingDiscovery {
     const limit = options.limit ?? 20;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
       throw new RangeError("limit must be an integer from 1 to 100");
-    const cursor = options.cursor ? new PublicKey4(options.cursor).toBase58() : undefined;
+    const cursor = options.cursor ? new PublicKey5(options.cursor).toBase58() : undefined;
     const accounts2 = await this.connection.getProgramAccounts(this.program.programId, {
       commitment: "confirmed",
       dataSlice: { offset: 0, length: 0 },
@@ -45188,7 +45255,7 @@ class FundingDiscovery {
         const current = status(state);
         if (!state.toMarket || current !== "settled")
           return;
-        const orderId = PublicKey4.findProgramAddressSync([
+        const orderId = PublicKey5.findProgramAddressSync([
           Buffer2.from("order"),
           state.market.toBuffer(),
           this.owner.toBuffer(),
@@ -45235,7 +45302,7 @@ class FundingDiscovery {
     const limit = options.limit ?? 20;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
       throw new RangeError("limit must be an integer from 1 to 100");
-    const cursor = options.cursor ? new PublicKey4(options.cursor).toBase58() : undefined;
+    const cursor = options.cursor ? new PublicKey5(options.cursor).toBase58() : undefined;
     const types3 = [
       {
         name: "depositReceipt",
@@ -45326,7 +45393,7 @@ class FundingDiscovery {
         throw new Error("Order changed during discovery");
       const bytes = Buffer2.alloc(8);
       bytes.writeBigUInt64LE(nonce);
-      canonical = PublicKey4.findProgramAddressSync([
+      canonical = PublicKey5.findProgramAddressSync([
         Buffer2.from("order"),
         state.market.toBuffer(),
         this.owner.toBuffer(),
@@ -45412,15 +45479,17 @@ class FundingClient {
   connection;
   owner;
   queue;
+  settlement;
   market;
   protocol;
   balance;
   marketAccount;
-  constructor(program, connection, owner, queue) {
+  constructor(program, connection, owner, queue, settlement = "wallet") {
     this.program = program;
     this.connection = connection;
     this.owner = owner;
     this.queue = queue;
+    this.settlement = settlement;
     this.market = marketAddress3(program.programId);
     this.protocol = protocolAddress2(program.programId);
     this.balance = balanceAddress(owner, program.programId);
@@ -45754,7 +45823,7 @@ class TransferHandle {
         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") {
+      if (transfer.state === "escrow" && this.client.settlement === "wallet") {
         try {
           await this.settle();
         } catch (error) {
@@ -45827,18 +45896,46 @@ class WithdrawalHandle {
   }
 }
 
+// src/account/state.ts
+async function balanceState(program, connection, owner, address2) {
+  const { context, value: value2 } = await connection.getAccountInfoAndContext(address2, "confirmed");
+  const base = { id: address2.toBase58(), slot: context.slot };
+  if (!value2)
+    return { ...base, status: "uninitialized", version: 0n };
+  if (!value2.owner.equals(program.programId))
+    throw new Error("Balance account is not owned by Depth");
+  const state = program.coder.accounts.decode("balanceAccount", value2.data);
+  if (!state.owner.equals(owner))
+    throw new Error("Balance account does not belong to this wallet");
+  const status3 = Object.keys(state.status)[0];
+  if (![
+    "opening",
+    "ready",
+    "crediting",
+    "withdrawing",
+    "moving",
+    "claiming"
+  ].includes(status3))
+    throw new Error("Balance account has an invalid status");
+  return {
+    ...base,
+    status: status3,
+    version: BigInt(state.version.toString())
+  };
+}
+
 // src/account/token.ts
 init_buffer();
 import {
-  PublicKey as PublicKey5,
+  PublicKey as PublicKey6,
   SystemProgram,
   Transaction as Transaction2,
-  TransactionInstruction
+  TransactionInstruction as TransactionInstruction2
 } from "@solana/web3.js";
-var tokenProgram = new PublicKey5("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-var associatedProgram = new PublicKey5("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+var tokenProgram = new PublicKey6("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var associatedProgram = new PublicKey6("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 function associatedTokenAddress(owner, mint) {
-  return PublicKey5.findProgramAddressSync([owner.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()], associatedProgram)[0];
+  return PublicKey6.findProgramAddressSync([owner.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()], associatedProgram)[0];
 }
 function tokenBalance(info, owner, mint) {
   if (!info.owner.equals(tokenProgram) || info.data.length < 165 || !info.data.subarray(0, 32).equals(mint.toBuffer()) || !info.data.subarray(32, 64).equals(owner.toBuffer()) || info.data[108] !== 1)
@@ -45867,7 +45964,7 @@ async function destinationTokenAccount(provider, owner, mint) {
   const address2 = associatedTokenAddress(owner, mint);
   let info = await provider.connection.getAccountInfo(address2, "confirmed");
   if (!info) {
-    const instruction = new TransactionInstruction({
+    const instruction = new TransactionInstruction2({
       programId: associatedProgram,
       data: Buffer2.from([1]),
       keys: [
@@ -45909,7 +46006,7 @@ import {
   marketAddress as marketAddress4,
   SOL_USD_MARKET_ID as SOL_USD_MARKET_ID2
 } from "@depthhq/bindings";
-import { PublicKey as PublicKey6 } from "@solana/web3.js";
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
 
 // src/position/pnl.ts
 var scale = 100000000000n;
@@ -46139,11 +46236,11 @@ class DepthOperation {
         throw new DepthError(result.status === "pending" ? "FILL_VIEW_PENDING" : "FILL_VIEW_STALE", "confirmation", result.status === "pending" ? "Private fill computation is still pending" : "Private fill view is stale", result.status === "pending", result.status === "pending" ? "Call privateResult again with the same operation" : "Restore this operation and request a fresh fill view", this.id.toBase58());
       this.fill = {
         ...result,
-        positionId: marketAccountAddress2(new PublicKey6(snapshot.owner), this.program.programId)
+        positionId: marketAccountAddress2(new PublicKey7(snapshot.owner), this.program.programId)
       };
     }
     try {
-      await this.view.close();
+      await this.view.deferClose();
     } catch (error) {
       let remaining;
       try {
@@ -46159,7 +46256,7 @@ class DepthOperation {
     return this.fill;
   }
   cleanupError(cause) {
-    return new DepthError("FILL_VIEW_CLEANUP_PENDING", "confirmation", "Private fill was read but its temporary view is still open", true, "Call privateResult again with the same operation to close the view", this.id.toBase58(), { cause });
+    return new DepthError("FILL_VIEW_CLEANUP_PENDING", "confirmation", "Private fill was read but receipt cleanup could not be scheduled", true, "Call privateResult again with the same operation to schedule cleanup", this.id.toBase58(), { cause });
   }
 }
 
@@ -46170,22 +46267,22 @@ import {
   marketAddress as marketAddress5,
   protocolAddress as protocolAddress3
 } from "@depthhq/bindings";
-import { PublicKey as PublicKey7 } from "@solana/web3.js";
+import { PublicKey as PublicKey8 } from "@solana/web3.js";
 
 class DepthRecovery {
   program;
   connection;
   owner;
   market = marketAddress5();
-  winddown = PublicKey7.findProgramAddressSync([Buffer2.from("winddown"), this.market.toBuffer()], DEPTH_PROGRAM_ID5)[0];
+  winddown = PublicKey8.findProgramAddressSync([Buffer2.from("winddown"), this.market.toBuffer()], DEPTH_PROGRAM_ID5)[0];
   marketAccount;
   claim;
   constructor(program, connection, owner) {
     this.program = program;
     this.connection = connection;
     this.owner = owner;
-    this.marketAccount = PublicKey7.findProgramAddressSync([Buffer2.from("market-account"), this.market.toBuffer(), owner.toBuffer()], DEPTH_PROGRAM_ID5)[0];
-    this.claim = PublicKey7.findProgramAddressSync([Buffer2.from("winddown-claim"), this.marketAccount.toBuffer()], DEPTH_PROGRAM_ID5)[0];
+    this.marketAccount = PublicKey8.findProgramAddressSync([Buffer2.from("market-account"), this.market.toBuffer(), owner.toBuffer()], DEPTH_PROGRAM_ID5)[0];
+    this.claim = PublicKey8.findProgramAddressSync([Buffer2.from("winddown-claim"), this.marketAccount.toBuffer()], DEPTH_PROGRAM_ID5)[0];
   }
   async read(address2, name2) {
     const result = await this.connection.getAccountInfoAndContext(address2, "confirmed");
@@ -46275,7 +46372,7 @@ import {
   marketAddress as marketAddress6,
   transferAddress as transferAddress3
 } from "@depthhq/bindings";
-import { PublicKey as PublicKey8 } from "@solana/web3.js";
+import { PublicKey as PublicKey9 } from "@solana/web3.js";
 
 // src/history/replay.ts
 function replayFill(state, fill, fundingIndex, maker = false) {
@@ -46354,7 +46451,7 @@ class ExecutionHistory {
     this.requestView = requestView;
   }
   orderAddress(trader, nonce) {
-    return PublicKey8.findProgramAddressSync([
+    return PublicKey9.findProgramAddressSync([
       Buffer2.from("order"),
       marketAddress6(this.program.programId).toBuffer(),
       trader.toBuffer(),
@@ -46376,7 +46473,7 @@ class ExecutionHistory {
     }
     const result = this.fills.get(key) ?? await view.wait({ timeoutMs: 180000 });
     if (result.status === "stale") {
-      await view.close();
+      await view.deferClose();
       this.views.delete(key);
       throw new Error("Historical private execution changed; retry with the same wallet");
     }
@@ -46384,7 +46481,7 @@ class ExecutionHistory {
       throw new Error("Historical private execution is still pending; retry with the same wallet");
     this.fills.set(key, result);
     try {
-      await view.close();
+      await view.deferClose();
     } catch (error) {
       if (await this.connection.getAccountInfo(view.id, "confirmed"))
         throw error;
@@ -46752,19 +46849,151 @@ class DepthView {
       await new Promise((resolve) => setTimeout(resolve, Math.min(pollMs, deadline - Date.now())));
     }
   }
+  async deferClose() {
+    const provider = this.program.provider;
+    if (typeof provider.deferClose !== "function") {
+      await this.close();
+      return;
+    }
+    const snapshot = await this.status();
+    if (snapshot.status === "pending")
+      throw new Error("Private view computation is still pending");
+    const instruction = await this.closeBuilder().instruction();
+    provider.deferClose(this.id, instruction);
+  }
+  closeBuilder() {
+    const builder = this.kind === "balance" ? this.program.methods.closeBalanceView() : this.kind === "market" ? this.program.methods.closeMarketView() : this.kind === "fill" ? this.program.methods.closeFillView() : this.program.methods.closeQuoteView();
+    return builder.accountsPartial({ owner: this.owner, view: this.id });
+  }
   async close() {
     const snapshot = await this.status();
     if (snapshot.status === "pending") {
       throw new Error("Private view computation is still pending");
     }
-    const builder = this.kind === "balance" ? this.program.methods.closeBalanceView() : this.kind === "market" ? this.program.methods.closeMarketView() : this.kind === "fill" ? this.program.methods.closeFillView() : this.program.methods.closeQuoteView();
-    return builder.accountsPartial({ owner: this.owner, view: this.id }).rpc({ commitment: "confirmed" });
+    return this.closeBuilder().rpc({ commitment: "confirmed" });
+  }
+}
+
+// src/view/cache.ts
+class DeviceViews {
+  database;
+  open() {
+    return this.database ??= new Promise((resolve, reject) => {
+      const request = indexedDB.open("depth-private-views", 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore("keys");
+        request.result.createObjectStore("views");
+      };
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => reject(new Error("Private view storage is blocked"));
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  async key(scope, proposed) {
+    const database = await this.open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("keys", "readwrite");
+      const store = transaction.objectStore("keys");
+      const request = store.get(scope);
+      let value2;
+      request.onsuccess = () => {
+        value2 = request.result ?? proposed;
+        if (!request.result)
+          store.put(value2, scope);
+      };
+      transaction.oncomplete = () => resolve(value2);
+      transaction.onabort = () => reject(transaction.error);
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async read(id) {
+    const database = await this.open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("views", "readonly");
+      const request = transaction.objectStore("views").get(id);
+      transaction.oncomplete = () => resolve(request.result);
+      transaction.onabort = () => reject(transaction.error);
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+  async write(id, value2) {
+    const database = await this.open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("views", "readwrite");
+      transaction.objectStore("views").put(value2, id);
+      transaction.oncomplete = () => resolve();
+      transaction.onabort = () => reject(transaction.error);
+      transaction.onerror = () => reject(transaction.error);
+    });
+  }
+}
+
+class ViewCache {
+  scope;
+  storage;
+  memory = new Map;
+  key;
+  constructor(scope, storage) {
+    this.scope = scope;
+    this.storage = storage;
+  }
+  encryptionKey() {
+    return this.key ??= crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+      "encrypt",
+      "decrypt"
+    ]).then((key) => this.storage.key(this.scope, key));
+  }
+  id(kind, account) {
+    return `${this.scope}:${kind}:${account}`;
+  }
+  async get(kind, account, version) {
+    const id = this.id(kind, account);
+    let snapshot = this.memory.get(id);
+    if (!snapshot && this.storage) {
+      try {
+        const envelope = await this.storage.read(id);
+        if (envelope) {
+          const bytes = await crypto.subtle.decrypt({
+            name: "AES-GCM",
+            iv: envelope.iv,
+            additionalData: new TextEncoder().encode(id)
+          }, await this.encryptionKey(), envelope.data);
+          snapshot = JSON.parse(new TextDecoder().decode(bytes), (_, value2) => value2 && typeof value2 === "object" && typeof value2.$bigint === "string" ? BigInt(value2.$bigint) : value2);
+        }
+      } catch {
+        return;
+      }
+    }
+    if (!snapshot || snapshot.status !== "ready" || snapshot.version !== version || typeof snapshot.id !== "string" || !Number.isSafeInteger(snapshot.slot) || (kind === "balance" ? typeof snapshot.amount !== "bigint" : [
+      "collateral",
+      "reserved",
+      "position",
+      "entryPriceE8",
+      "fundingCheckpoint"
+    ].some((field) => typeof snapshot[field] !== "bigint")))
+      return;
+    this.memory.set(id, snapshot);
+    return { ...snapshot };
+  }
+  async set(kind, account, snapshot) {
+    if (snapshot.status !== "ready")
+      return;
+    const id = this.id(kind, account);
+    this.memory.set(id, { ...snapshot });
+    if (!this.storage)
+      return;
+    try {
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const bytes = new TextEncoder().encode(JSON.stringify(snapshot, (_, value2) => typeof value2 === "bigint" ? { $bigint: value2.toString() } : value2));
+      const data = await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: new TextEncoder().encode(id) }, await this.encryptionKey(), bytes);
+      await this.storage.write(id, { iv, data });
+    } catch {}
   }
 }
 
 // src/client/client.ts
 function pda(seeds, programId = DEPTH_PROGRAM_ID7) {
-  return PublicKey9.findProgramAddressSync(seeds, programId)[0];
+  return PublicKey10.findProgramAddressSync(seeds, programId)[0];
 }
 function nonce() {
   return new anchor8.BN(randomBytes3(8), "le");
@@ -46777,6 +47006,8 @@ class DepthClient {
   options;
   program;
   provider;
+  views;
+  viewReads = new Map;
   position;
   marketAddress = marketAddress7();
   protocolAddress = protocolAddress4();
@@ -46785,7 +47016,7 @@ class DepthClient {
     return new MarketCatalog(this);
   }
   get funding() {
-    return new FundingClient(this.program, this.options.connection, this.options.wallet.publicKey, (name2, offset2) => this.queue(name2, offset2));
+    return new FundingClient(this.program, this.options.connection, this.options.wallet.publicKey, (name2, offset2) => this.queue(name2, offset2), this.options.settlement ?? (this.options.environment && this.options.environment !== "localnet" ? "keeper" : "wallet"));
   }
   get app() {
     return new AppAdmin(this.program, this.options.connection, this.options.wallet.publicKey, this.funding);
@@ -46799,6 +47030,7 @@ class DepthClient {
   }
   constructor(options) {
     this.options = options;
+    this.views = new ViewCache(`${"manifest" in options.deployment ? options.deployment.manifest.payload.genesisHash : "localnet"}:${DEPTH_PROGRAM_ID7.toBase58()}:${options.wallet.publicKey.toBase58()}`, options.privateViews === "device" && "manifest" in options.deployment && typeof indexedDB !== "undefined" && globalThis.crypto?.subtle ? new DeviceViews : undefined);
     this.provider = new DepthProvider(options.connection, options.wallet, {
       commitment: "confirmed",
       preflightCommitment: "confirmed"
@@ -46807,7 +47039,7 @@ class DepthClient {
     this.position = this.positionActions();
   }
   static async create(options) {
-    const appId = typeof options.appId === "string" ? new PublicKey9(options.appId) : options.appId;
+    const appId = typeof options.appId === "string" ? new PublicKey10(options.appId) : options.appId;
     const resolved = {
       ...options,
       ...await resolveConnection(options),
@@ -47025,7 +47257,7 @@ class DepthClient {
     return this.funding.release(amount, clientNonce ?? BigInt(nonce().toString()));
   }
   async depositRequest(sourceOrAmount, amount, clientNonce) {
-    if (sourceOrAmount instanceof PublicKey9) {
+    if (sourceOrAmount instanceof PublicKey10) {
       if (amount === undefined || clientNonce === undefined)
         throw new RangeError("Source deposits require amount and client nonce");
       return this.funding.deposit(sourceOrAmount, amount, clientNonce);
@@ -47036,7 +47268,7 @@ class DepthClient {
     return this.funding.deposit(source, sourceOrAmount, amount ?? BigInt(nonce().toString()));
   }
   async withdrawRequest(destinationOrAmount, amount, clientNonce) {
-    if (destinationOrAmount instanceof PublicKey9) {
+    if (destinationOrAmount instanceof PublicKey10) {
       if (amount === undefined || clientNonce === undefined)
         throw new RangeError("Destination withdrawals require amount and client nonce");
       return this.funding.withdraw(destinationOrAmount, amount, clientNonce);
@@ -47051,6 +47283,7 @@ class DepthClient {
   }
   accountActions() {
     const actions = {
+      state: () => balanceState(this.program, this.options.connection, this.options.wallet.publicKey, this.funding.balance),
       detail: (item) => new FundingDiscovery(this.program, this.options.connection, this.options.wallet.publicKey).detail(item),
       transaction: (item) => new FundingDiscovery(this.program, this.options.connection, this.options.wallet.publicKey).transaction(item),
       history: (options) => new FundingDiscovery(this.program, this.options.connection, this.options.wallet.publicKey).history(options),
@@ -47067,11 +47300,10 @@ class DepthClient {
       summary: async (options = {
         timeoutMs: 180000
       }) => {
-        const view = await this.requestBalanceView();
-        const result = await view.wait(options);
-        if (result.status !== "pending")
-          await view.close();
-        return result;
+        const state = await actions.state();
+        if (state.status === "uninitialized")
+          return { ...state, status: "uninitialized", amount: 0n };
+        return this.summaryView("balance", state.id, options);
       }
     };
     return Object.assign(() => actions, actions);
@@ -47107,29 +47339,7 @@ class DepthClient {
       summary: async (options = {
         timeoutMs: 180000
       }) => {
-        const deadline = Date.now() + options.timeoutMs;
-        let view;
-        for (;; ) {
-          try {
-            view = await this.requestMarketView();
-            break;
-          } catch (error) {
-            const code2 = error.error?.errorCode?.code;
-            if (code2 !== "WrongMarketAccountStatus" && !String(error).includes("Market account is processing another operation")) {
-              throw error;
-            }
-            if (Date.now() >= deadline)
-              throw error;
-            await new Promise((resolve) => setTimeout(resolve, 1000));
-          }
-        }
-        const result = await view.wait({
-          ...options,
-          timeoutMs: Math.max(0, deadline - Date.now())
-        });
-        if (result.status !== "pending")
-          await view.close();
-        return result;
+        return this.summaryView("market", address2.toBase58(), options);
       }
     };
     return Object.assign((positionId) => this.positionActions(positionId), actions);
@@ -47175,6 +47385,75 @@ class DepthClient {
       u64(clientNonce, "clientNonce").toArrayLike(Buffer2, "le", 8)
     ]);
   }
+  async deferViewClose(kind, id) {
+    const view = new PublicKey10(id);
+    const method = kind === "balance" ? this.program.methods.closeBalanceView : this.program.methods.closeMarketView;
+    this.provider.deferClose(view, await method().accountsPartial({
+      owner: this.options.wallet.publicKey,
+      view
+    }).instruction());
+  }
+  async viewState(kind, id) {
+    if (kind === "balance")
+      return this.account().state();
+    const state = await this.read("MarketAccount", new PublicKey10(id));
+    if (!state.owner.equals(this.options.wallet.publicKey) || !state.market.equals(this.marketAddress))
+      throw new Error("Position does not belong to this wallet and market");
+    return {
+      status: enumName2(state.status),
+      version: BigInt(state.version.toString())
+    };
+  }
+  summaryView(kind, id, options) {
+    const key = `${kind}:${id}`;
+    const pending = this.viewReads.get(key);
+    if (pending)
+      return pending;
+    const request = this.readSummaryView(kind, id, options).finally(() => {
+      if (this.viewReads.get(key) === request)
+        this.viewReads.delete(key);
+    });
+    this.viewReads.set(key, request);
+    return request;
+  }
+  async readSummaryView(kind, id, options) {
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 0)
+      throw new RangeError("timeoutMs must be a nonnegative integer");
+    const deadline = Date.now() + options.timeoutMs;
+    for (;; ) {
+      const state = await this.viewState(kind, id);
+      if (state.status === "ready") {
+        const cached = await this.views.get(kind, id, state.version);
+        if (cached) {
+          await this.deferViewClose(kind, cached.id);
+          return cached;
+        }
+        try {
+          const view = kind === "balance" ? await this.requestBalanceView() : await this.requestMarketView();
+          const result = await view.wait({
+            ...options,
+            timeoutMs: Math.max(0, deadline - Date.now())
+          });
+          if (result.status === "pending")
+            return result;
+          await this.deferViewClose(kind, result.id);
+          const latest = await this.viewState(kind, id);
+          if (result.status === "ready" && latest.status === "ready" && latest.version === result.version) {
+            const snapshot = { ...result, readAt: Date.now() };
+            await this.views.set(kind, id, snapshot);
+            return snapshot;
+          }
+        } catch (error) {
+          const code2 = error.error?.errorCode?.code;
+          if (code2 !== "WrongMarketAccountStatus" && !String(error).includes("processing another operation"))
+            throw error;
+        }
+      }
+      if (Date.now() >= deadline)
+        throw new Error("Private account is still processing an operation");
+      await new Promise((resolve) => setTimeout(resolve, Math.min(options.pollMs ?? 1000, deadline - Date.now())));
+    }
+  }
   async submitTrade(input, intent) {
     const appId = this.options.appId;
     if (!appId)
@@ -47206,43 +47485,13 @@ class DepthClient {
       throw new Error("Position does not belong to this wallet and market");
     await this.ensureBalanceReady();
     await this.ensureMarketReady();
-    let [market, protocol, account, app] = await Promise.all([
-      this.market(),
-      this.read("Protocol", this.protocolAddress),
-      this.read("MarketAccount", this.accountAddress()),
-      this.read("AppConfig", appAddress2(appId))
-    ]);
-    const deadline = tradeDeadline(input, Math.floor(Date.now() / 1000), market.state.config.maxOrderQueueSeconds);
+    let [market, protocol, account, app] = await this.waitForMarket(input, appId, intent);
+    let deadline;
     tradeLimit(input, "long", BigInt(market.state.oraclePriceE8.toString()));
-    this.validateTrade(market.state, protocol, account, app, appId, intent, deadline);
     if (additionalMargin > 0n) {
       const transfer = await this.funding.allocate(additionalMargin, clientNonce);
-      const allocationDeadline = Date.now() + 120000;
-      for (;; ) {
-        const current = await transfer.status();
-        if (current.state === "settled")
-          break;
-        if (current.state === "rejected" || current.state === "refunded")
-          throw new Error(`Margin allocation ${transfer.id.toBase58()} ${current.state}`);
-        if (current.state === "escrow") {
-          try {
-            await transfer.settle();
-          } catch (error) {
-            if ((await transfer.status()).state === "escrow")
-              throw error;
-          }
-        }
-        if (Date.now() >= allocationDeadline)
-          throw new Error(`Margin allocation ${transfer.id.toBase58()} is pending`);
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-      }
-      [market, protocol, account, app] = await Promise.all([
-        this.market(),
-        this.read("Protocol", this.protocolAddress),
-        this.read("MarketAccount", this.accountAddress()),
-        this.read("AppConfig", appAddress2(appId))
-      ]);
-      this.validateTrade(market.state, protocol, account, app, appId, intent, deadline);
+      await transfer.confirm({ timeoutMs: 120000 });
+      [market, protocol, account, app] = await this.waitForMarket(input, appId, intent);
     }
     const viewDeadline = Date.now() + 120000;
     let position;
@@ -47260,15 +47509,13 @@ class DepthClient {
         await new Promise((resolve) => setTimeout(resolve, 1000));
         continue;
       }
-      [market, account] = await Promise.all([
-        this.market(),
-        this.read("MarketAccount", this.accountAddress())
-      ]);
+      [market, protocol, account, app] = await this.waitForMarket(input, appId, intent);
       if (position.status === "ready" && enumName2(account.status) === "ready" && account.version.toString() === position.version.toString()) {
         break;
       }
       await new Promise((resolve) => setTimeout(resolve, 1000));
     }
+    deadline = tradeDeadline(input, Math.floor(Date.now() / 1000), market.state.config.maxOrderQueueSeconds);
     this.validateTrade(market.state, protocol, account, app, appId, intent, deadline);
     if (position.status !== "ready" || position.collateral === undefined || position.position === undefined)
       throw new Error(`Private position view ${position.id} is ${position.status}`);
@@ -47338,6 +47585,29 @@ class DepthClient {
     ]).rpc({ commitment: "confirmed" }).catch((error) => submissionError(order.toBase58(), error));
     return new DepthOperation(order, signature, this.program, this.options.connection, (id) => this.requestFillView(id), position);
   }
+  async waitForMarket(input, appId, intent) {
+    const until = Date.now() + 60000;
+    for (;; ) {
+      const [market, protocol, account, app] = await Promise.all([
+        this.market(),
+        this.read("Protocol", this.protocolAddress),
+        this.read("MarketAccount", this.accountAddress()),
+        this.read("AppConfig", appAddress2(appId))
+      ]);
+      const deadline = tradeDeadline(input, Math.floor(Date.now() / 1000), market.state.config.maxOrderQueueSeconds);
+      try {
+        this.validateTrade(market.state, protocol, account, app, appId, intent, deadline);
+        return [market, protocol, account, app];
+      } catch (error) {
+        if (!(error instanceof Error) || ![
+          "Waiting for maker liquidity",
+          "Market is processing another order"
+        ].includes(error.message) || Date.now() >= until)
+          throw error;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+  }
   validateTrade(market, protocol, account, app, appId, intent = "increase", deadline) {
     const now = Math.floor(Date.now() / 1000);
     const marketStatus = enumName2(market.status);
@@ -47350,9 +47620,10 @@ class DepthClient {
     if (enumName2(account.status) !== "ready" || !account.market.equals(this.marketAddress) || !account.owner.equals(this.options.wallet.publicKey)) {
       throw new Error("Market account is unavailable");
     }
-    if (market.pendingOrders !== 0 || market.activeQuoteCount === 0) {
-      throw new Error("Market is processing another order or has no quotes");
-    }
+    if (market.pendingOrders !== 0)
+      throw new Error("Market is processing another order");
+    if (market.activeQuoteCount === 0)
+      throw new Error("Waiting for maker liquidity");
     const age = now - market.oracleTimestamp.toNumber();
     if (age < 0 || age > market.config.maxOracleAgeSeconds) {
       throw new Error("Oracle update is stale");
@@ -47506,6 +47777,7 @@ export {
   verifyDeployment,
   resolveConnection,
   resolveAmount,
+  prepare_depth,
   positionPnl,
   manifestBytes,
   create_depth_data,

package/dist/view/cache.d.ts

@@ -0,0 +1,31 @@
+import type { BalanceSnapshot, PositionSnapshot } from "./view.js";
+type Snapshot = BalanceSnapshot | PositionSnapshot;
+type Kind = "balance" | "market";
+type Envelope = {
+    iv: Uint8Array;
+    data: ArrayBuffer;
+};
+export interface ViewStorage {
+    key(scope: string, proposed: CryptoKey): Promise<CryptoKey>;
+    read(id: string): Promise<Envelope | undefined>;
+    write(id: string, value: Envelope): Promise<void>;
+}
+export declare class DeviceViews implements ViewStorage {
+    private database?;
+    private open;
+    key(scope: string, proposed: CryptoKey): Promise<CryptoKey>;
+    read(id: string): Promise<Envelope | undefined>;
+    write(id: string, value: Envelope): Promise<void>;
+}
+export declare class ViewCache {
+    private readonly scope;
+    private readonly storage?;
+    private readonly memory;
+    private key?;
+    constructor(scope: string, storage?: ViewStorage | undefined);
+    private encryptionKey;
+    private id;
+    get<T extends Snapshot>(kind: Kind, account: string, version: bigint): Promise<T | undefined>;
+    set(kind: Kind, account: string, snapshot: Snapshot): Promise<void>;
+}
+export {};

package/dist/view/view.d.ts

@@ -1,9 +1,10 @@
 import * as anchor from "@anchor-lang/core";
 import { Connection, PublicKey } from "@solana/web3.js";
 export type BalanceSnapshot = {
-    status: "pending" | "ready" | "stale";
+    status: "uninitialized" | "pending" | "ready" | "stale";
     id: string;
     version: bigint;
+    readAt?: number;
     slot: number;
     amount?: bigint;
 };
@@ -11,6 +12,7 @@ export type PositionSnapshot = {
     status: "pending" | "ready" | "stale";
     id: string;
     version: bigint;
+    readAt?: number;
     slot: number;
     collateral?: bigint;
     reserved?: bigint;
@@ -55,5 +57,7 @@ export declare class DepthView {
         timeoutMs: number;
         pollMs?: number;
     }): Promise<BalanceSnapshot | PositionSnapshot | FillSnapshot | QuoteBalanceSnapshot>;
+    deferClose(): Promise<void>;
+    private closeBuilder;
     close(): Promise<string>;
 }

package/dist/view/view.js

@@ -26667,13 +26667,28 @@ class DepthView {
       await new Promise((resolve) => setTimeout(resolve, Math.min(pollMs, deadline - Date.now())));
     }
   }
+  async deferClose() {
+    const provider = this.program.provider;
+    if (typeof provider.deferClose !== "function") {
+      await this.close();
+      return;
+    }
+    const snapshot = await this.status();
+    if (snapshot.status === "pending")
+      throw new Error("Private view computation is still pending");
+    const instruction = await this.closeBuilder().instruction();
+    provider.deferClose(this.id, instruction);
+  }
+  closeBuilder() {
+    const builder = this.kind === "balance" ? this.program.methods.closeBalanceView() : this.kind === "market" ? this.program.methods.closeMarketView() : this.kind === "fill" ? this.program.methods.closeFillView() : this.program.methods.closeQuoteView();
+    return builder.accountsPartial({ owner: this.owner, view: this.id });
+  }
   async close() {
     const snapshot = await this.status();
     if (snapshot.status === "pending") {
       throw new Error("Private view computation is still pending");
     }
-    const builder = this.kind === "balance" ? this.program.methods.closeBalanceView() : this.kind === "market" ? this.program.methods.closeMarketView() : this.kind === "fill" ? this.program.methods.closeFillView() : this.program.methods.closeQuoteView();
-    return builder.accountsPartial({ owner: this.owner, view: this.id }).rpc({ commitment: "confirmed" });
+    return this.closeBuilder().rpc({ commitment: "confirmed" });
   }
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depthhq/sdk",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },
@@ -44,8 +44,11 @@
     "@noble/hashes": "1.8.0",
     "@solana/web3.js": "1.99.0",
     "buffer": "6.0.3",
-    "@depthhq/schema": "0.1.1",
-    "@depthhq/bindings": "0.1.1"
+    "@depthhq/bindings": "0.1.1",
+    "@depthhq/schema": "0.1.1"
+  },
+  "devDependencies": {
+    "fake-indexeddb": "6.2.4"
   },
   "scripts": {
     "build": "node ../../scripts/build-package.mjs sdk",