@depthhq/sdk 0.1.3 → 0.1.4

package/dist/client/client.d.ts

@@ -12,13 +12,15 @@ import { ExecutionHistory } from "../history/history.js";
 import type { AmountSelector } from "../trade/amount.js";
 import { TradeFlow } from "../trade/flow.js";
 import { DepthView } from "../view/view.js";
+import { ViewSession } from "../view/session.js";
 import type { BalanceSnapshot } from "../view/view.js";
 import type { CloseInput, DepthOptions, ResolvedDepthOptions, MarketState, ReductionInput, ReverseInput, TradeInput } from "./types.js";
 export declare class DepthClient {
     readonly options: ResolvedDepthOptions;
     readonly program: anchor.Program;
     readonly provider: DepthProvider;
-    private readonly views;
+    private readonly viewCache;
+    readonly views: ViewSession;
     private readonly viewReads;
     readonly position: ReturnType<DepthClient["positionActions"]>;
     readonly marketAddress: anchor.web3.PublicKey;
@@ -42,6 +44,7 @@ export declare class DepthClient {
         slot: number;
     }>;
     operation(id: PublicKey): DepthOperation;
+    requestQuoteView(quote: PublicKey): Promise<DepthView>;
     requestBalanceView(): Promise<DepthView>;
     requestMarketView(): Promise<DepthView>;
     requestFillView(order: PublicKey): Promise<DepthView>;

package/dist/client/types.d.ts

@@ -12,12 +12,14 @@ export type DepthOptions = ConnectionOptions & {
     appId?: PublicKey | string;
     wallet: DepthWallet;
     privateViews?: "memory" | "device";
+    viewAuthorization?: "session" | "wallet";
     settlement?: "keeper" | "wallet";
 };
 export type ResolvedDepthOptions = ResolvedConnection & {
     appId?: PublicKey;
     wallet: DepthWallet;
     privateViews?: "memory" | "device";
+    viewAuthorization?: "session" | "wallet";
     settlement?: "keeper" | "wallet";
 };
 export type TradeTerms = {

package/dist/index.d.ts

@@ -33,3 +33,4 @@ export { DepthError } from "./operation/error.js";
 export { DepthProvider } from "./chain/provider.js";
 export { authenticateManifest, captureDeployment, manifestBytes, verifyDeployment, } from "./chain/manifest.js";
 export type { DeploymentManifest, SignedManifest, DeploymentPolicy, } from "./chain/manifest.js";
+export { ViewSession } from "./view/session.js";

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 PublicKey10 } 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);
@@ -46014,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,
@@ -46765,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;
@@ -46775,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");
@@ -46785,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");
@@ -46850,6 +46869,10 @@ class DepthView {
     }
   }
   async deferClose() {
+    if (this.release) {
+      await this.close();
+      return;
+    }
     const provider = this.program.provider;
     if (typeof provider.deferClose !== "function") {
       await this.close();
@@ -46870,10 +46893,25 @@ class DepthView {
     if (snapshot.status === "pending") {
       throw new Error("Private view computation is still pending");
     }
+    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;
@@ -46928,6 +46966,40 @@ class DeviceViews {
   }
 }
 
+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;
@@ -46991,12 +47063,205 @@ class ViewCache {
   }
 }
 
+// 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 PublicKey10.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";
@@ -47006,12 +47271,13 @@ 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);
   }
@@ -47030,16 +47296,19 @@ 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);
+    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 PublicKey10(options.appId) : options.appId;
+    const appId = typeof options.appId === "string" ? new PublicKey11(options.appId) : options.appId;
     const resolved = {
       ...options,
       ...await resolveConnection(options),
@@ -47052,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),
@@ -47060,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);
@@ -47074,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`);
@@ -47096,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 {
@@ -47108,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()]);
@@ -47155,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();
@@ -47170,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;
@@ -47257,7 +47532,7 @@ class DepthClient {
     return this.funding.release(amount, clientNonce ?? BigInt(nonce().toString()));
   }
   async depositRequest(sourceOrAmount, amount, clientNonce) {
-    if (sourceOrAmount instanceof PublicKey10) {
+    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);
@@ -47268,7 +47543,7 @@ class DepthClient {
     return this.funding.deposit(source, sourceOrAmount, amount ?? BigInt(nonce().toString()));
   }
   async withdrawRequest(destinationOrAmount, amount, clientNonce) {
-    if (destinationOrAmount instanceof PublicKey10) {
+    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);
@@ -47386,7 +47661,7 @@ class DepthClient {
     ]);
   }
   async deferViewClose(kind, id) {
-    const view = new PublicKey10(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,
@@ -47396,7 +47671,7 @@ class DepthClient {
   async viewState(kind, id) {
     if (kind === "balance")
       return this.account().state();
-    const state = await this.read("MarketAccount", new PublicKey10(id));
+    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 {
@@ -47423,7 +47698,7 @@ class DepthClient {
     for (;; ) {
       const state = await this.viewState(kind, id);
       if (state.status === "ready") {
-        const cached = await this.views.get(kind, id, state.version);
+        const cached = await this.viewCache.get(kind, id, state.version);
         if (cached) {
           await this.deferViewClose(kind, cached.id);
           return cached;
@@ -47436,11 +47711,11 @@ class DepthClient {
           });
           if (result.status === "pending")
             return result;
-          await this.deferViewClose(kind, result.id);
+          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.views.set(kind, id, snapshot);
+            await this.viewCache.set(kind, id, snapshot);
             return snapshot;
           }
         } catch (error) {
@@ -47540,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();
@@ -47562,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,
@@ -47786,6 +48061,7 @@ export {
   captureDeployment,
   authenticateManifest,
   WithdrawalHandle,
+  ViewSession,
   TransferHandle,
   TradeFlow,
   MarketData,

package/dist/view/cache.d.ts

@@ -17,6 +17,15 @@ export declare class DeviceViews implements ViewStorage {
     read(id: string): Promise<Envelope | undefined>;
     write(id: string, value: Envelope): Promise<void>;
 }
+export declare class EncryptedViews {
+    private readonly scope;
+    private readonly storage;
+    private key?;
+    constructor(scope: string, storage: ViewStorage);
+    private encryptionKey;
+    read<T>(name: string): Promise<T | undefined>;
+    write(name: string, value: unknown): Promise<void>;
+}
 export declare class ViewCache {
     private readonly scope;
     private readonly storage?;

package/dist/view/session.d.ts

@@ -0,0 +1,28 @@
+import * as anchor from "@anchor-lang/core";
+import { type ViewKind } from "@depthhq/schema";
+import { PublicKey, type Connection } from "@solana/web3.js";
+import { type ViewStorage } from "./cache.js";
+import { DepthView } from "./view.js";
+export declare class ViewSession {
+    private readonly program;
+    private readonly connection;
+    private readonly owner;
+    private readonly serviceUrl;
+    private readonly scope;
+    private readonly storage?;
+    private readonly pending;
+    constructor(program: anchor.Program, connection: Connection, owner: PublicKey, serviceUrl: string | undefined, scope: string, storage?: ViewStorage);
+    private identity;
+    private keys;
+    status(): Promise<{
+        active: boolean;
+        expiresAt?: number;
+        id: string;
+    }>;
+    private capability;
+    authorize(): Promise<void>;
+    revoke(): Promise<string>;
+    private post;
+    request(kind: ViewKind, source: PublicKey): Promise<DepthView>;
+    private read;
+}

package/dist/view/view.d.ts

@@ -51,7 +51,9 @@ export declare class DepthView {
     private readonly mxePublicKey;
     private readonly program;
     private readonly connection;
-    constructor(id: PublicKey, signature: string, kind: "balance" | "market" | "fill" | "quote", owner: PublicKey, secret: Uint8Array, publicKey: Uint8Array, mxePublicKey: Uint8Array, program: anchor.Program, connection: Connection);
+    private readonly source?;
+    private readonly release?;
+    constructor(id: PublicKey, signature: string, kind: "balance" | "market" | "fill" | "quote", owner: PublicKey, secret: Uint8Array, publicKey: Uint8Array, mxePublicKey: Uint8Array, program: anchor.Program, connection: Connection, source?: PublicKey | undefined, release?: (() => Promise<string>) | undefined);
     status(): Promise<BalanceSnapshot | PositionSnapshot | FillSnapshot | QuoteBalanceSnapshot>;
     wait(options: {
         timeoutMs: number;

package/dist/view/view.js

@@ -26583,7 +26583,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;
@@ -26593,6 +26595,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");
@@ -26603,6 +26607,9 @@ class DepthView {
     if (!state.owner.equals(this.owner) || !Buffer.from(state.viewKey).equals(Buffer.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");
@@ -26668,6 +26675,10 @@ class DepthView {
     }
   }
   async deferClose() {
+    if (this.release) {
+      await this.close();
+      return;
+    }
     const provider = this.program.provider;
     if (typeof provider.deferClose !== "function") {
       await this.close();
@@ -26688,6 +26699,8 @@ class DepthView {
     if (snapshot.status === "pending") {
       throw new Error("Private view computation is still pending");
     }
+    if (this.release)
+      return this.release();
     return this.closeBuilder().rpc({ commitment: "confirmed" });
   }
 }

package/package.json

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