@depthhq/sdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -18122,7 +18122,7 @@ https://github.com/browserify/crypto-browserify`);
 
 // src/client/client.ts
 init_buffer();
-import * as anchor8 from "@anchor-lang/core";
+import * as anchor9 from "@anchor-lang/core";
 
 // ../../node_modules/@noble/hashes/esm/crypto.js
 var crypto2 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : undefined;
@@ -43622,13 +43622,13 @@ import {
   circuits as circuits2,
   computationName,
   DEPTH_IDL as DEPTH_IDL3,
-  DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID7,
-  marketAddress as marketAddress7,
+  DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID8,
+  marketAddress as marketAddress8,
   protocolAddress as protocolAddress4,
   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 PublicKey11 } from "@solana/web3.js";
 
 // src/chain/random.ts
 function randomBytes3(length) {
@@ -44335,9 +44335,21 @@ async function getExtendedPublicKey(key) {
 function getExtendedPublicKeySync(key) {
   return getKeyFromHash(sha512s(checkPrivateKey(key)));
 }
+async function getPublicKey(privateKey) {
+  return (await getExtendedPublicKey(privateKey)).pointBytes;
+}
 function getPublicKeySync(privateKey) {
   return getExtendedPublicKeySync(privateKey).pointBytes;
 }
+async function sign(message, privateKey) {
+  message = ensureBytes2(message);
+  const { prefix, scalar, pointBytes } = await getExtendedPublicKey(privateKey);
+  const r = modlLE(await utils.sha512(prefix, message));
+  const R = Point.BASE.multiply(r);
+  const k = modlLE(await utils.sha512(R.toRawBytes(), pointBytes, message));
+  const s = mod2(r + k * scalar, CURVE.l);
+  return new Signature(R, s).toRawBytes();
+}
 function signSync(message, privateKey) {
   message = ensureBytes2(message);
   const { prefix, scalar, pointBytes } = getExtendedPublicKeySync(privateKey);
@@ -44726,6 +44738,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([
@@ -44768,11 +44781,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;
@@ -45023,7 +45077,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();
@@ -45181,7 +45235,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 },
@@ -45213,7 +45267,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(),
@@ -45260,7 +45314,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",
@@ -45351,7 +45405,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(),
@@ -45437,15 +45491,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);
@@ -45779,7 +45835,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) {
@@ -45883,15 +45939,15 @@ async function balanceState(program, connection, owner, address2) {
 // 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)
@@ -45920,7 +45976,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: [
@@ -45962,7 +46018,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;
@@ -45970,22 +46026,22 @@ function positionPnl(position, priceE8, fundingIndex, fill) {
   if (position.status !== "ready" || position.position === undefined || position.position === 0n || position.entryPriceE8 === undefined || position.fundingCheckpoint === undefined || position.collateral !== undefined && position.collateral < 0n || priceE8 <= 0n)
     throw new Error("A ready open position and a positive price are required");
   const size = position.position < 0n ? -position.position : position.position;
-  const sign = position.position > 0n ? 1n : -1n;
+  const sign2 = position.position > 0n ? 1n : -1n;
   let closing = size;
   let fee = 0n;
   let state = "open";
   if (fill) {
-    if (fill.status !== "ready" || fill.side !== -sign || fill.size === undefined || fill.size <= 0n || fill.executionPriceE8 !== priceE8 || fill.fee === undefined || fill.fee < 0n)
+    if (fill.status !== "ready" || fill.side !== -sign2 || fill.size === undefined || fill.size <= 0n || fill.executionPriceE8 !== priceE8 || fill.fee === undefined || fill.fee < 0n)
       throw new Error("A ready opposite-side execution is required");
     closing = fill.size < size ? fill.size : size;
     fee = fill.fee;
     state = fill.size === size ? "closed" : fill.size < size ? "reduced" : "reversed";
   }
-  const gross = sign * closing * (priceE8 - position.entryPriceE8) / scale;
+  const gross = sign2 * closing * (priceE8 - position.entryPriceE8) / scale;
   const funding = position.position * (fundingIndex - position.fundingCheckpoint) / scale;
   const net = gross - funding - fee;
   return {
-    side: sign > 0n ? "long" : "short",
+    side: sign2 > 0n ? "long" : "short",
     state,
     entryPriceE8: position.entryPriceE8,
     priceE8,
@@ -46192,11 +46248,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 {
@@ -46212,7 +46268,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 });
   }
 }
 
@@ -46223,22 +46279,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");
@@ -46328,7 +46384,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) {
@@ -46407,7 +46463,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(),
@@ -46429,7 +46485,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");
     }
@@ -46437,7 +46493,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;
@@ -46721,7 +46777,9 @@ class DepthView {
   mxePublicKey;
   program;
   connection;
-  constructor(id, signature, kind, owner, secret, publicKey, mxePublicKey, program, connection) {
+  source;
+  release;
+  constructor(id, signature, kind, owner, secret, publicKey, mxePublicKey, program, connection, source, release) {
     this.id = id;
     this.signature = signature;
     this.kind = kind;
@@ -46731,6 +46789,8 @@ class DepthView {
     this.mxePublicKey = mxePublicKey;
     this.program = program;
     this.connection = connection;
+    this.source = source;
+    this.release = release;
   }
   async status() {
     const response = await this.connection.getAccountInfoAndContext(this.id, "confirmed");
@@ -46741,6 +46801,9 @@ class DepthView {
     if (!state.owner.equals(this.owner) || !Buffer2.from(state.viewKey).equals(Buffer2.from(this.publicKey))) {
       throw new Error("Private view authorization does not match this request");
     }
+    const source = this.kind === "balance" ? state.balance : this.kind === "market" ? state.marketAccount : this.kind === "fill" ? state.order : state.quote;
+    if (this.source && !source?.equals(this.source))
+      throw new Error("Private view source does not match this request");
     const current = Object.keys(state.status)[0];
     if (current !== "pending" && current !== "ready" && current !== "stale") {
       throw new Error("Private view has an unknown status");
@@ -46805,22 +46868,400 @@ class DepthView {
       await new Promise((resolve) => setTimeout(resolve, Math.min(pollMs, deadline - Date.now())));
     }
   }
+  async deferClose() {
+    if (this.release) {
+      await this.close();
+      return;
+    }
+    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" });
+    if (this.release)
+      return this.release();
+    return this.closeBuilder().rpc({ commitment: "confirmed" });
+  }
+}
+
+// src/view/session.ts
+init_buffer();
+import * as anchor8 from "@anchor-lang/core";
+import {
+  DEPTH_PROGRAM_ID as DEPTH_PROGRAM_ID7,
+  marketAddress as marketAddress7,
+  viewPermitAddress
+} from "@depthhq/bindings";
+import {
+  viewMessage
+} from "@depthhq/schema";
+import { PublicKey as PublicKey10 } from "@solana/web3.js";
+
+// 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 EncryptedViews {
+  scope;
+  storage;
+  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));
+  }
+  async read(name2) {
+    const id = `${this.scope}:${name2}`;
+    const envelope = await this.storage.read(id);
+    if (!envelope)
+      return;
+    const bytes = await crypto.subtle.decrypt({
+      name: "AES-GCM",
+      iv: envelope.iv,
+      additionalData: new TextEncoder().encode(id)
+    }, await this.encryptionKey(), envelope.data);
+    return JSON.parse(new TextDecoder().decode(bytes));
+  }
+  async write(name2, value2) {
+    const id = `${this.scope}:${name2}`;
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const data = await crypto.subtle.encrypt({ name: "AES-GCM", iv, additionalData: new TextEncoder().encode(id) }, await this.encryptionKey(), new TextEncoder().encode(JSON.stringify(value2)));
+    await this.storage.write(id, { iv, data });
+  }
+}
+
+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/view/session.ts
+var identities = new Map;
+var approvals = new Map;
+var requests = new Map;
+var disabled = new Set;
+
+class ViewSession {
+  program;
+  connection;
+  owner;
+  serviceUrl;
+  scope;
+  storage;
+  pending = new Map;
+  constructor(program, connection, owner, serviceUrl, scope, storage) {
+    this.program = program;
+    this.connection = connection;
+    this.owner = owner;
+    this.serviceUrl = serviceUrl;
+    this.scope = scope;
+    if (storage)
+      this.storage = new EncryptedViews(scope, storage);
+  }
+  identity() {
+    let value2 = identities.get(this.scope);
+    if (!value2) {
+      value2 = (async () => {
+        const saved = await this.storage?.read("authorization");
+        if (saved) {
+          if (![saved.signing, saved.encryption].every((key) => Array.isArray(key) && key.length === 32 && key.every((v) => Number.isInteger(v) && v >= 0 && v <= 255)))
+            throw new Error("Invalid private read identity");
+          return saved;
+        }
+        const identity = {
+          signing: Array.from(randomBytes3(32)),
+          encryption: Array.from(x25519.utils.randomSecretKey())
+        };
+        await this.storage?.write("authorization", identity);
+        return identity;
+      })();
+      identities.set(this.scope, value2);
+      value2.catch(() => identities.delete(this.scope));
+    }
+    return value2;
+  }
+  async keys() {
+    const identity = await this.identity();
+    const secret = Uint8Array.from(identity.encryption);
+    const signing = Uint8Array.from(identity.signing);
+    const reader = new PublicKey10(await getPublicKey(signing));
+    return {
+      signing,
+      secret,
+      reader,
+      viewKey: x25519.getPublicKey(secret),
+      permit: viewPermitAddress(this.owner, reader)
+    };
+  }
+  async status() {
+    const keys = await this.keys();
+    const info = await this.connection.getAccountInfo(keys.permit, "confirmed");
+    if (!info)
+      return { active: false, id: keys.permit.toBase58() };
+    if (!info.owner.equals(DEPTH_PROGRAM_ID7))
+      throw new Error("Invalid private read permission owner");
+    const permit = this.program.coder.accounts.decode("viewPermit", info.data);
+    const expiresAt = permit.expiresAt.toNumber();
+    if (!permit.owner.equals(this.owner) || !permit.reader.equals(keys.reader) || !permit.market.equals(marketAddress7()) || !Buffer2.from(permit.viewKey).equals(Buffer2.from(keys.viewKey)))
+      throw new Error("Private read permission does not match this device");
+    return {
+      id: keys.permit.toBase58(),
+      active: permit.active && expiresAt > Math.floor(Date.now() / 1000) && permit.scopes === 15,
+      expiresAt
+    };
+  }
+  async capability() {
+    if (!this.serviceUrl)
+      throw new Error("A Depth service is required for automatic private reads");
+    const response = await fetch(`${this.serviceUrl}/v1/views`, {
+      cache: "no-store",
+      signal: AbortSignal.timeout(15000)
+    });
+    if (!response.ok || (await response.json()).enabled !== true)
+      throw new Error("Automatic private reads are unavailable");
+  }
+  async authorize() {
+    const { permit, reader, viewKey } = await this.keys();
+    const id = permit.toBase58();
+    const existing = approvals.get(id);
+    if (existing)
+      return existing;
+    const approval = (async () => {
+      if ((await this.status()).active) {
+        disabled.delete(this.scope);
+        await this.storage?.write("disabled", false);
+        return;
+      }
+      await this.capability();
+      const expiresAt = new anchor8.BN(Math.floor(Date.now() / 1000) + 7 * 86400 - 60);
+      await this.program.methods.authorizeViews(reader, Array.from(viewKey), expiresAt, 15).accountsPartial({ owner: this.owner, market: marketAddress7(), permit }).rpc({ commitment: "confirmed" });
+      disabled.delete(this.scope);
+      await this.storage?.write("disabled", false);
+    })().finally(() => approvals.delete(id));
+    approvals.set(id, approval);
+    return approval;
+  }
+  async revoke() {
+    const { permit } = await this.keys();
+    const signature = await this.program.methods.revokeViews().accountsPartial({ owner: this.owner, permit }).rpc({ commitment: "confirmed" });
+    disabled.add(this.scope);
+    await this.storage?.write("disabled", true);
+    return signature;
+  }
+  async post(request, action) {
+    const { signing } = await this.keys();
+    request.expiresAt = Math.floor(Date.now() / 1000) + 120;
+    request.signature = Buffer2.from(await sign(new TextEncoder().encode(viewMessage(DEPTH_PROGRAM_ID7.toBase58(), request, action)), signing)).toString("base64");
+    return fetch(`${this.serviceUrl}/v1/views${action === "close" ? "/close" : ""}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(request),
+      signal: AbortSignal.timeout(60000)
+    });
+  }
+  request(kind, source) {
+    const key = `${this.scope}:${kind}:${source.toBase58()}`;
+    const pending = requests.get(key);
+    if (pending)
+      return pending;
+    const request = this.read(kind, source).finally(() => requests.delete(key));
+    requests.set(key, request);
+    return request;
+  }
+  async read(kind, source, retry = true) {
+    if (disabled.has(this.scope) || await this.storage?.read("disabled"))
+      throw new Error("Private reads are disabled on this device");
+    await this.authorize();
+    const keys = await this.keys();
+    const name2 = `request:${kind}:${source.toBase58()}`;
+    let pending = this.pending.get(name2) ?? await this.storage?.read(name2);
+    if (!pending) {
+      pending = { nonce: new anchor8.BN(randomBytes3(8), "le").toString() };
+      await this.storage?.write(name2, pending);
+      this.pending.set(name2, pending);
+    }
+    const request = {
+      owner: this.owner.toBase58(),
+      reader: keys.reader.toBase58(),
+      permit: keys.permit.toBase58(),
+      kind,
+      source: source.toBase58(),
+      nonce: pending.nonce,
+      expiresAt: 0,
+      signature: ""
+    };
+    const response = await this.post(request, "read");
+    if (response.status === 410 && retry) {
+      this.pending.delete(name2);
+      await this.storage?.write(name2, null);
+      return this.read(kind, source, false);
+    }
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({}));
+      if (error.error === "view_source_busy")
+        throw new Error("Private account is processing another operation");
+      throw new Error(`Private read service returned HTTP ${response.status}`);
+    }
+    const receipt = await response.json();
+    const payer = new PublicKey10(receipt.payer);
+    const nonce = new anchor8.BN(request.nonce).toArrayLike(Buffer2, "le", 8);
+    const seeds = kind === "balance" ? [Buffer2.from("view"), payer.toBuffer(), nonce] : kind === "market" ? [Buffer2.from("market-view"), source.toBuffer(), nonce] : [
+      Buffer2.from(`${kind}-view`),
+      source.toBuffer(),
+      payer.toBuffer(),
+      nonce
+    ];
+    const id = PublicKey10.findProgramAddressSync(seeds, DEPTH_PROGRAM_ID7)[0];
+    if (receipt.id !== id.toBase58() || typeof receipt.signature !== "string")
+      throw new Error("Invalid private read receipt");
+    const mxeKey = await getMXEPublicKey(this.program.provider, DEPTH_PROGRAM_ID7);
+    if (!mxeKey)
+      throw new Error("MXE public key is unavailable");
+    return new DepthView(id, receipt.signature, kind, payer, keys.secret, keys.viewKey, mxeKey, this.program, this.connection, source, async () => {
+      this.pending.delete(name2);
+      await this.storage?.write(name2, null);
+      try {
+        await this.post(request, "close");
+      } catch {}
+      return "";
+    });
   }
 }
 
 // src/client/client.ts
-function pda(seeds, programId = DEPTH_PROGRAM_ID7) {
-  return PublicKey9.findProgramAddressSync(seeds, programId)[0];
+function pda(seeds, programId = DEPTH_PROGRAM_ID8) {
+  return PublicKey11.findProgramAddressSync(seeds, programId)[0];
 }
 function nonce() {
-  return new anchor8.BN(randomBytes3(8), "le");
+  return new anchor9.BN(randomBytes3(8), "le");
 }
 function enumName2(value2) {
   return Object.keys(value2)[0] ?? "unknown";
@@ -46830,15 +47271,18 @@ class DepthClient {
   options;
   program;
   provider;
+  viewCache;
+  views;
+  viewReads = new Map;
   position;
-  marketAddress = marketAddress7();
+  marketAddress = marketAddress8();
   protocolAddress = protocolAddress4();
-  mxeAddress = getMXEAccAddress(DEPTH_PROGRAM_ID7);
+  mxeAddress = getMXEAccAddress(DEPTH_PROGRAM_ID8);
   get catalog() {
     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);
@@ -46852,15 +47296,19 @@ class DepthClient {
   }
   constructor(options) {
     this.options = options;
+    const scope = `${"manifest" in options.deployment ? options.deployment.manifest.payload.genesisHash : "localnet"}:${DEPTH_PROGRAM_ID8.toBase58()}:${options.wallet.publicKey.toBase58()}`;
+    const storage = options.privateViews === "device" && "manifest" in options.deployment && typeof indexedDB !== "undefined" && globalThis.crypto?.subtle ? new DeviceViews : undefined;
+    this.viewCache = new ViewCache(scope, storage);
     this.provider = new DepthProvider(options.connection, options.wallet, {
       commitment: "confirmed",
       preflightCommitment: "confirmed"
     });
-    this.program = new anchor8.Program(DEPTH_IDL3, this.provider);
+    this.program = new anchor9.Program(DEPTH_IDL3, this.provider);
+    this.views = new ViewSession(this.program, options.connection, options.wallet.publicKey, options.serviceUrl, scope, storage);
     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 PublicKey11(options.appId) : options.appId;
     const resolved = {
       ...options,
       ...await resolveConnection(options),
@@ -46873,7 +47321,7 @@ class DepthClient {
   }
   async verifyDeployment() {
     const [programInfo, protocol, market, app, mxe] = await Promise.all([
-      this.options.connection.getAccountInfo(DEPTH_PROGRAM_ID7, "confirmed"),
+      this.options.connection.getAccountInfo(DEPTH_PROGRAM_ID8, "confirmed"),
       this.read("Protocol", this.protocolAddress),
       this.read("Market", this.marketAddress),
       this.options.appId ? this.read("AppConfig", appAddress2(this.options.appId)) : Promise.resolve(undefined),
@@ -46881,13 +47329,13 @@ class DepthClient {
     ]);
     if (!programInfo?.executable)
       throw new Error("Depth program is not deployed");
-    if (!market.settlementMint.equals(protocol.settlementMint) || !market.vault.equals(protocol.vault) || this.options.appId && !app?.app.equals(this.options.appId) || !mxe.mxeProgramId.equals(DEPTH_PROGRAM_ID7)) {
+    if (!market.settlementMint.equals(protocol.settlementMint) || !market.vault.equals(protocol.vault) || this.options.appId && !app?.app.equals(this.options.appId) || !mxe.mxeProgramId.equals(DEPTH_PROGRAM_ID8)) {
       throw new Error("Depth deployment accounts disagree");
     }
   }
   async read(name2, address2) {
     const info = await this.options.connection.getAccountInfo(address2, "confirmed");
-    if (!info || !info.owner.equals(DEPTH_PROGRAM_ID7)) {
+    if (!info || !info.owner.equals(DEPTH_PROGRAM_ID8)) {
       throw new Error(`${name2} account is unavailable`);
     }
     return this.program.coder.accounts.decode(name2[0].toLowerCase() + name2.slice(1), info.data);
@@ -46895,7 +47343,7 @@ class DepthClient {
   async queue(name2, offset2) {
     const mxe = await arciumAccount(this.provider).fetch(this.mxeAddress);
     const cluster = mxe.cluster;
-    const definition = getCompDefAccAddress(DEPTH_PROGRAM_ID7, Buffer2.from(getCompDefAccOffset(computationName(name2))).readUInt32LE());
+    const definition = getCompDefAccAddress(DEPTH_PROGRAM_ID8, Buffer2.from(getCompDefAccOffset(computationName(name2))).readUInt32LE());
     const definitionInfo = await this.options.connection.getAccountInfo(definition, "confirmed");
     if (!definitionInfo)
       throw new Error(`${name2} computation is not deployed`);
@@ -46917,7 +47365,7 @@ class DepthClient {
   }
   async market() {
     const response = await this.options.connection.getAccountInfoAndContext(this.marketAddress, "confirmed");
-    if (!response.value || !response.value.owner.equals(DEPTH_PROGRAM_ID7)) {
+    if (!response.value || !response.value.owner.equals(DEPTH_PROGRAM_ID8)) {
       throw new Error("Depth market is unavailable");
     }
     return {
@@ -46929,6 +47377,9 @@ class DepthClient {
   operation(id) {
     return new DepthOperation(id, undefined, this.program, this.options.connection, (order) => this.requestFillView(order));
   }
+  async requestQuoteView(quote) {
+    return this.views.request("quote", quote);
+  }
   async requestBalanceView() {
     const owner = this.options.wallet.publicKey;
     const balance = pda([Buffer2.from("balance"), owner.toBuffer()]);
@@ -46976,7 +47427,10 @@ class DepthClient {
     return this.requestView("fill", view, viewNonce, { order });
   }
   async requestView(kind, view, viewNonce, accounts2) {
-    const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID7);
+    const source = accounts2.balance ?? accounts2.marketAccount ?? accounts2.order;
+    if (this.options.viewAuthorization === "session" || this.options.viewAuthorization !== "wallet" && this.options.privateViews === "device" && this.options.serviceUrl)
+      return this.views.request(kind, source);
+    const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID8);
     if (!mxePublicKey)
       throw new Error("MXE public key is unavailable");
     const secret = x25519.utils.randomSecretKey();
@@ -46991,7 +47445,7 @@ class DepthClient {
       ...kind === "balance" ? {} : { grant: null },
       view
     }).rpc({ commitment: "confirmed" });
-    return new DepthView(view, signature, kind, this.options.wallet.publicKey, secret, publicKey, mxePublicKey, this.program, this.options.connection);
+    return new DepthView(view, signature, kind, this.options.wallet.publicKey, secret, publicKey, mxePublicKey, this.program, this.options.connection, source);
   }
   async ensureBalanceReady() {
     const address2 = this.funding.balance;
@@ -47078,7 +47532,7 @@ class DepthClient {
     return this.funding.release(amount, clientNonce ?? BigInt(nonce().toString()));
   }
   async depositRequest(sourceOrAmount, amount, clientNonce) {
-    if (sourceOrAmount instanceof PublicKey9) {
+    if (sourceOrAmount instanceof PublicKey11) {
       if (amount === undefined || clientNonce === undefined)
         throw new RangeError("Source deposits require amount and client nonce");
       return this.funding.deposit(sourceOrAmount, amount, clientNonce);
@@ -47089,7 +47543,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 PublicKey11) {
       if (amount === undefined || clientNonce === undefined)
         throw new RangeError("Destination withdrawals require amount and client nonce");
       return this.funding.withdraw(destinationOrAmount, amount, clientNonce);
@@ -47124,11 +47578,7 @@ class DepthClient {
         const state = await actions.state();
         if (state.status === "uninitialized")
           return { ...state, status: "uninitialized", amount: 0n };
-        const view = await this.requestBalanceView();
-        const result = await view.wait(options);
-        if (result.status !== "pending")
-          await view.close();
-        return result;
+        return this.summaryView("balance", state.id, options);
       }
     };
     return Object.assign(() => actions, actions);
@@ -47164,29 +47614,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);
@@ -47232,6 +47660,75 @@ class DepthClient {
       u64(clientNonce, "clientNonce").toArrayLike(Buffer2, "le", 8)
     ]);
   }
+  async deferViewClose(kind, id) {
+    const view = new PublicKey11(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 PublicKey11(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.viewCache.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 view.deferClose();
+          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.viewCache.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)
@@ -47263,43 +47760,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;
@@ -47317,15 +47784,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}`);
@@ -47350,11 +47815,11 @@ class DepthClient {
     const keys = [market.state.backstopOffer, ...quotes];
     const records = await this.options.connection.getMultipleAccountsInfo(keys, "confirmed");
     records.forEach((info, index) => {
-      if (!info?.owner.equals(DEPTH_PROGRAM_ID7)) {
+      if (!info?.owner.equals(DEPTH_PROGRAM_ID8)) {
         throw new Error(`Market quote snapshot missing account ${index}`);
       }
     });
-    const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID7);
+    const mxePublicKey = await getMXEPublicKey(this.provider, DEPTH_PROGRAM_ID8);
     if (!mxePublicKey)
       throw new Error("MXE public key is unavailable");
     const secret = x25519.utils.randomSecretKey();
@@ -47372,7 +47837,7 @@ class DepthClient {
     }), inputNonce);
     const offset2 = nonce();
     const queue = await this.queue("match_order", offset2);
-    const signature = await this.program.methods.submitOrder(offset2, orderNonce, appId, app.feeBps, app.version, new anchor8.BN(deadline), market.state.revision, market.state.oracleTimestamp, ciphertexts, Array.from(inputKey), new anchor8.BN(inputNonce, "le")).accountsPartial({
+    const signature = await this.program.methods.submitOrder(offset2, orderNonce, appId, app.feeBps, app.version, new anchor9.BN(deadline), market.state.revision, market.state.oracleTimestamp, ciphertexts, Array.from(inputKey), new anchor9.BN(inputNonce, "le")).accountsPartial({
       ...queue,
       trader: this.options.wallet.publicKey,
       protocol: this.protocolAddress,
@@ -47395,6 +47860,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);
@@ -47407,9 +47895,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");
@@ -47572,6 +48061,7 @@ export {
   captureDeployment,
   authenticateManifest,
   WithdrawalHandle,
+  ViewSession,
   TransferHandle,
   TradeFlow,
   MarketData,