@opendatalabs/vana-sdk 4.1.0 → 4.2.0

package/dist/index.node.cjs

@@ -1205,10 +1205,10 @@ __export(index_node_exports, {
   ENCLAVE_IDENTITY_EVIDENCE_VERSION: () => ENCLAVE_IDENTITY_EVIDENCE_VERSION,
   ENCLAVE_TRUST_ANCHORS: () => ENCLAVE_TRUST_ANCHORS,
   ENCLAVE_WALLET_PURPOSE: () => ENCLAVE_WALLET_PURPOSE,
-  ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI2,
+  ESCROW_DEPOSIT_ABI: () => ESCROW_DEPOSIT_ABI,
   EscrowWithdrawalLifecycleError: () => EscrowWithdrawalLifecycleError,
   EscrowWithdrawalRejectionError: () => EscrowWithdrawalRejectionError,
-  ExpiredTokenError: () => import_errors14.ExpiredTokenError,
+  ExpiredTokenError: () => import_errors15.ExpiredTokenError,
   FEE_REGISTRY_ABI: () => FEE_REGISTRY_ABI,
   GENERIC_PAYMENT_TYPES: () => GENERIC_PAYMENT_TYPES,
   GRANT_OP_TYPE: () => GRANT_OP_TYPE,
@@ -1218,7 +1218,7 @@ __export(index_node_exports, {
   InMemoryTokenStore: () => InMemoryTokenStore,
   IngestResponseSchema: () => IngestResponseSchema,
   InvalidScopeEntryError: () => InvalidScopeEntryError,
-  InvalidSignatureError: () => import_errors14.InvalidSignatureError,
+  InvalidSignatureError: () => import_errors15.InvalidSignatureError,
   IpfsStorage: () => IpfsStorage,
   JOB_OPERATIONS: () => JOB_OPERATIONS,
   JOB_PROTOCOL_VERSION: () => JOB_PROTOCOL_VERSION,
@@ -1242,7 +1242,7 @@ __export(index_node_exports, {
   MAX_QUESTION_MODEL_CHARS: () => MAX_QUESTION_MODEL_CHARS,
   MAX_QUESTION_SOURCE_SCOPES: () => MAX_QUESTION_SOURCE_SCOPES,
   MAX_WAIT_SECONDS: () => MAX_WAIT_SECONDS,
-  MissingAuthError: () => import_errors14.MissingAuthError,
+  MissingAuthError: () => import_errors15.MissingAuthError,
   NATIVE_ASSET_ADDRESS: () => NATIVE_ASSET_ADDRESS,
   NATIVE_VANA_ASSET: () => NATIVE_VANA_ASSET,
   NodeECIESProvider: () => NodeECIESUint8Provider,
@@ -31922,7 +31922,7 @@ async function verifyWeb3Signed(params) {
 }
 
 // src/index.node.ts
-var import_errors14 = require("./auth/errors.cjs");
+var import_errors15 = require("./auth/errors.cjs");
 
 // src/auth/pkce.ts
 var PKCE_VERIFIER_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
@@ -32547,7 +32547,7 @@ var MAX_JOB_DEADLINE_SECONDS = 3600;
 // src/protocol/jobs-client.ts
 var import_node_crypto = require("node:crypto");
 var import_sha26 = require("@noble/hashes/sha2");
-var import_viem16 = require("viem");
+var import_viem17 = require("viem");
 var import_accounts2 = require("viem/accounts");
 
 // src/crypto/envelope/job.ts
@@ -33324,6 +33324,517 @@ async function openJobResult(sealedBytes, builderPrivateKey, ecies, expect) {
 
 // src/protocol/jobs-client.ts
 var import_errors3 = require("./errors.cjs");
+var import_errors4 = require("./direct/errors.cjs");
+
+// src/config/contracts.config.ts
+var CONTRACTS2 = {
+  // ========================================
+  // DATA PORTABILITY CONTRACTS
+  // ========================================
+  DataPortabilityEscrow: {
+    addresses: {
+      14800: "0x07d7769081adc3a3DBe91f5E4B98E9A5a6B292e3",
+      1480: "0x07d7769081adc3a3DBe91f5E4B98E9A5a6B292e3"
+    }
+  },
+  FeeRegistry: {
+    addresses: {
+      14800: "0xb4FA18443E0FA6cdC0280D20b8cCDB2377D13Bf2",
+      1480: "0xb4FA18443E0FA6cdC0280D20b8cCDB2377D13Bf2"
+    }
+  },
+  // V2 deployment (DataPortabilityPermissionsV2Proxy). The gateway is the source
+  // of truth for which deployment is live; verify with
+  // `cast call <address> "eip712Domain()(bytes1,string,string,uint256,address,bytes32,uint256[])"`
+  // which must return the domain name "Vana Data Portability".
+  DataPortabilityPermissions: {
+    addresses: {
+      14800: "0x4d3FA76064D88e0454cFc4CaD7e5FeC3e3124011",
+      1480: "0x4d3FA76064D88e0454cFc4CaD7e5FeC3e3124011"
+    }
+  },
+  // V2 deployment (DataPortabilityServersV2Proxy) on both chains.
+  DataPortabilityServers: {
+    addresses: {
+      14800: "0xCae2CE0e9caa6643ed28186cF57bd40Bd9E17Eab",
+      1480: "0xCae2CE0e9caa6643ed28186cF57bd40Bd9E17Eab"
+    }
+  },
+  DataPortabilityGrantees: {
+    addresses: {
+      14800: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234",
+      1480: "0x8325C0A0948483EdA023A1A2Fd895e62C5131234"
+    }
+  },
+  DataRegistry: {
+    addresses: {
+      14800: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C",
+      1480: "0x8C8788f98385F6ba1adD4234e551ABba0f82Cb7C"
+    }
+  },
+  // ========================================
+  // COMPUTING INFRASTRUCTURE
+  // ========================================
+  ComputeEngine: {
+    addresses: {
+      14800: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd",
+      1480: "0xb2BFe33FA420c45F1Cf1287542ad81ae935447bd"
+    }
+  },
+  ComputeEngineTreasury: {
+    addresses: {
+      14800: "0xceB33C501B624D984bD1Ed3298f6D1d8F7CE03d1",
+      1480: "0xceB33C501B624D984bD1Ed3298f6D1d8F7CE03d1"
+    },
+    discovery: {
+      parent: "ComputeEngine",
+      getter: "computeEngineTreasury"
+    }
+  },
+  QueryEngine: {
+    addresses: {
+      14800: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490",
+      1480: "0xd25Eb66EA2452cf3238A2eC6C1FD1B7F5B320490"
+    }
+  },
+  VanaTreasury: {
+    addresses: {
+      14800: "0x8B32Ef32f22e72cc25D53f6E858f57cAe7E198f9",
+      1480: "0x8B32Ef32f22e72cc25D53f6E858f57cAe7E198f9"
+    },
+    discovery: {
+      parent: "QueryEngine",
+      getter: "queryEngineTreasury"
+    }
+  },
+  DataRefinerRegistry: {
+    addresses: {
+      14800: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c",
+      1480: "0x93c3EF89369fDcf08Be159D9DeF0F18AB6Be008c"
+    }
+  },
+  ComputeInstructionRegistry: {
+    addresses: {
+      14800: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5",
+      1480: "0x5786B12b4c6Ba2bFAF0e77Ed30Bf6d32805563A5"
+    }
+  },
+  // ========================================
+  // TEE POOLS (Canonical Deployments)
+  // ========================================
+  TeePoolPhala: {
+    addresses: {
+      14800: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A",
+      1480: "0xE8EC6BD73b23Ad40E6B9a6f4bD343FAc411bD99A"
+    }
+  },
+  TeePoolEphemeralStandard: {
+    addresses: {
+      14800: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A",
+      1480: "0xe124bae846D5ec157f75Bd9e68ca87C4d2AB835A"
+    }
+  },
+  TeePoolPersistentStandard: {
+    addresses: {
+      14800: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76",
+      1480: "0xe8bB8d0629651Cf33e0845d743976Dc1f0971d76"
+    }
+  },
+  TeePoolPersistentGpu: {
+    addresses: {
+      14800: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9",
+      1480: "0x1c346Cd74f8551f8fa13f3F4b6b8dAE22338E6a9"
+    }
+  },
+  TeePoolDedicatedStandard: {
+    addresses: {
+      14800: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d",
+      1480: "0xf024b7ac5E8417416f53B41ecfa58C8e9396687d"
+    }
+  },
+  TeePoolDedicatedGpu: {
+    addresses: {
+      14800: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E",
+      1480: "0xB1686FA9620bBf851714d1cB47b8a4Bf4664644E"
+    }
+  },
+  // ========================================
+  // VANA EPOCH / DLP REGISTRY
+  // ========================================
+  // Note: DLP rewards-specific contracts (DLPPerformance, DLPRewardDeployer,
+  // DLPRewardDeployerTreasury, DLPRewardSwap, SwapHelper) were removed in the
+  // protocol unification cleanup. VanaEpoch, DLPRegistry, and DLPRegistryTreasury
+  // are kept because they may be referenced beyond the rewards system.
+  VanaEpoch: {
+    addresses: {
+      14800: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0",
+      1480: "0x2063cFF0609D59bCCc196E20Eb58A8696a6b15A0"
+    }
+  },
+  DLPRegistry: {
+    addresses: {
+      14800: "0x4D59880a924526d1dD33260552Ff4328b1E18a43",
+      1480: "0x4D59880a924526d1dD33260552Ff4328b1E18a43"
+    }
+  },
+  DLPRegistryTreasury: {
+    addresses: {
+      14800: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a",
+      1480: "0xb12ce1d27bEeFe39b6F0110b1AB77C21Aa0c9F9a"
+    },
+    discovery: {
+      parent: "DLPRegistry",
+      getter: "treasury"
+    }
+  },
+  // ========================================
+  // VANA POOL (STAKING)
+  // ========================================
+  VanaPoolStaking: {
+    addresses: {
+      14800: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e",
+      1480: "0x641C18E2F286c86f96CE95C8ec1EB9fC0415Ca0e"
+    }
+  },
+  VanaPoolTreasury: {
+    addresses: {
+      14800: "0x143BE72CF2541604A7691933CAccd6D9cC17c003",
+      1480: "0x143BE72CF2541604A7691933CAccd6D9cC17c003"
+    },
+    discovery: {
+      parent: "VanaPoolStaking",
+      getter: "vanaPoolTreasury"
+    }
+  },
+  VanaPoolEntity: {
+    addresses: {
+      14800: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30",
+      1480: "0x44f20490A82e1f1F1cC25Dd3BA8647034eDdce30"
+    },
+    discovery: {
+      parent: "VanaPoolStaking",
+      getter: "vanaPoolEntity"
+    }
+  },
+  // ========================================
+  // DLP DEPLOYMENT & TOKEN SYSTEM
+  // ========================================
+  DATFactory: {
+    addresses: {
+      14800: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644",
+      1480: "0x40f8bccF35a75ecef63BC3B1B3E06ffEB9220644"
+    }
+  },
+  DAT: {
+    addresses: {
+      14800: "0xA706b93ccED89f13340673889e29F0a5cd84212d",
+      1480: "0xA706b93ccED89f13340673889e29F0a5cd84212d"
+    }
+  },
+  DATPausable: {
+    addresses: {
+      14800: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e",
+      1480: "0xe69FE86f0B95cC2f8416Fe22815c85DC8887e76e"
+    }
+  },
+  DATVotes: {
+    addresses: {
+      14800: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831",
+      1480: "0xaE04c8A77E9B27869eb563720524A9aE0baf1831"
+    }
+  },
+  // ========================================
+  // EXTERNAL DEPENDENCIES (DeFi)
+  // ========================================
+  WVANA: {
+    addresses: {
+      14800: "0xbccc4b4c6530F82FE309c5E845E50b5E9C89f2AD",
+      1480: "0x00EDdD9621Fb08436d0331c149D1690909a5906d"
+    }
+  },
+  UniswapV3NonfungiblePositionManager: {
+    addresses: {
+      14800: "0x48Bd633f4B9128a38Ebb4a48b6975EB3Eaf1931b",
+      1480: "0x45a2992e1bFdCF9b9AcE0a84A238f2E56F481816"
+    }
+  },
+  UniswapV3QuoterV2: {
+    addresses: {
+      14800: "0x3152246f3CD4dD465292Dd4Ffd792E2Cf602e332",
+      1480: "0x1b13728ea3C90863990aC0e05987CfeC1888908c"
+    }
+  },
+  // ========================================
+  // UTILITY CONTRACTS
+  // ========================================
+  Multicall3: {
+    addresses: {
+      14800: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E",
+      1480: "0xD8d2dFca27E8797fd779F8547166A2d3B29d360E"
+    }
+  },
+  Multisend: {
+    addresses: {
+      14800: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d",
+      1480: "0x8807e8BCDFbaA8c2761760f3FBA37F6f7F2C5b2d"
+    }
+  }
+};
+
+// src/protocol/escrow.ts
+var import_viem16 = require("viem");
+var GENERIC_PAYMENT_TYPES = {
+  GenericPayment: [
+    { name: "payerAddress", type: "address" },
+    { name: "opType", type: "string" },
+    { name: "opId", type: "bytes32" },
+    { name: "asset", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "paymentNonce", type: "uint256" }
+  ]
+};
+function genericPaymentDomain(chainId, escrowContract) {
+  return {
+    name: "Vana Data Portability",
+    version: "1",
+    chainId,
+    verifyingContract: escrowContract
+  };
+}
+var ESCROW_DEPOSIT_ABI = [
+  {
+    type: "function",
+    name: "depositNative",
+    stateMutability: "payable",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "depositToken",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "token", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var NATIVE_ASSET_ADDRESS = "0x0000000000000000000000000000000000000000";
+var EscrowWithdrawalLifecycleError = class extends Error {
+  constructor(httpStatus, result) {
+    super(result.error);
+    this.httpStatus = httpStatus;
+    this.result = result;
+  }
+  httpStatus;
+  result;
+  name = "EscrowWithdrawalLifecycleError";
+};
+var EscrowWithdrawalRejectionError = class extends Error {
+  constructor(httpStatus, result) {
+    super(result.error);
+    this.httpStatus = httpStatus;
+    this.result = result;
+  }
+  httpStatus;
+  result;
+  name = "EscrowWithdrawalRejectionError";
+};
+function createEscrowGatewayClient(baseUrl) {
+  const base = baseUrl.replace(/\/+$/, "");
+  async function throwOnError(res, context) {
+    if (!res.ok) {
+      let detail = "";
+      try {
+        const body = await res.json();
+        if (body.error) detail = `: ${body.error}`;
+      } catch {
+      }
+      throw new Error(
+        `Escrow gateway error (${context}): ${res.status} ${res.statusText}${detail}`
+      );
+    }
+  }
+  async function throwOnWithdrawError(res) {
+    if (res.ok) return;
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      throw new Error(
+        `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}`
+      );
+    }
+    if (isEscrowWithdrawalFailureResult(body)) {
+      throw new EscrowWithdrawalLifecycleError(res.status, body);
+    }
+    if (isEscrowWithdrawalRejectedResult(body)) {
+      throw new EscrowWithdrawalRejectionError(res.status, body);
+    }
+    const error = getGatewayErrorMessage(body);
+    throw new Error(
+      `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}${error ? `: ${error}` : ""}`
+    );
+  }
+  return {
+    async submitDeposit({ txHash }) {
+      const res = await fetch(`${base}/v1/escrow/deposit`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ txHash })
+      });
+      if (res.status !== 200 && res.status !== 202) {
+        await throwOnError(res, "POST /v1/escrow/deposit");
+      }
+      return res.json();
+    },
+    async getEscrowBalance(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/balance?account=${encodeURIComponent(account)}`
+      );
+      await throwOnError(res, "GET /v1/escrow/balance");
+      return res.json();
+    },
+    async syncEscrowBalance(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/balance/sync?account=${encodeURIComponent(account)}`,
+        { method: "POST" }
+      );
+      await throwOnError(res, "POST /v1/escrow/balance/sync");
+      return res.json();
+    },
+    async payForOp({
+      payerAddress,
+      opType,
+      opId,
+      asset,
+      amount,
+      paymentNonce,
+      signature,
+      accessRecord
+    }) {
+      const res = await fetch(`${base}/v1/escrow/pay`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Web3Signed ${signature}`
+        },
+        body: JSON.stringify({
+          payerAddress,
+          opType,
+          opId,
+          asset,
+          amount,
+          paymentNonce,
+          ...accessRecord ? { accessRecord } : {}
+        })
+      });
+      await throwOnError(res, "POST /v1/escrow/pay");
+      return res.json();
+    },
+    async withdraw({
+      account,
+      asset,
+      amount,
+      withdrawNonce,
+      deadline,
+      signature
+    }) {
+      const res = await fetch(`${base}/v1/escrow/withdraw`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Web3Signed ${signature}`
+        },
+        body: JSON.stringify({
+          account,
+          asset,
+          amount,
+          withdrawNonce,
+          deadline
+        })
+      });
+      await throwOnWithdrawError(res);
+      return res.json();
+    },
+    async getWithdrawNonce(account) {
+      const res = await fetch(
+        `${base}/v1/escrow/withdraw/nonce?account=${encodeURIComponent(account)}`,
+        { cache: "no-store" }
+      );
+      await throwOnError(res, "GET /v1/escrow/withdraw/nonce");
+      const body = await res.json();
+      if (!isWithdrawNonceResponse(body, account)) {
+        throw new Error(
+          "GET /v1/escrow/withdraw/nonce: invalid response structure"
+        );
+      }
+      return body;
+    }
+  };
+}
+function getGatewayErrorMessage(body) {
+  if (typeof body === "object" && body !== null && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return void 0;
+}
+function isEscrowWithdrawalFailureResult(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  return value.success === false && (value.status === "retryable" || value.status === "reorged" || value.status === "failed") && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && (isHash(value.txHash) || value.txHash === null) && (!("blockNumber" in value) || isBlockNumber(value.blockNumber));
+}
+function isEscrowWithdrawalRejectedResult(body) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  return value.success === false && value.status === "rejected" && isWithdrawalRejectionCode(value.code) && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && optionalUint256Decimal(value.balance) && optionalUint256Decimal(value.authorizedAmount) && optionalUint256Decimal(value.withdrawingAmount) && optionalUint256Decimal(value.availableAmount) && optionalUint256Decimal(value.requestedAmount) && optionalUint256Decimal(value.minimumAmount);
+}
+function isWithdrawalRejectionCode(value) {
+  return value === "below_minimum" || value === "deadline_too_far" || value === "expired" || value === "insufficient_available" || value === "stale_nonce";
+}
+function optionalUint256Decimal(value) {
+  return value === void 0 || isUint256Decimal(value);
+}
+function isAddressHex(value) {
+  return typeof value === "string" && (0, import_viem16.isHex)(value, { strict: true }) && value.length === 42;
+}
+function isHash(value) {
+  return typeof value === "string" && (0, import_viem16.isHex)(value, { strict: true }) && value.length === 66;
+}
+function isUint256Decimal(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 78) {
+    return false;
+  }
+  if (!/^(0|[1-9]\d*)$/.test(value)) return false;
+  return BigInt(value) <= 2n ** 256n - 1n;
+}
+function isBlockNumber(value) {
+  return value === null || isUint256Decimal(value);
+}
+function isWithdrawNonceResponse(body, requestedAccount) {
+  if (typeof body !== "object" || body === null) return false;
+  const value = body;
+  if (value.success !== true) return false;
+  if (!isAddressHex(value.account)) return false;
+  if (value.account.toLowerCase() !== requestedAccount.toLowerCase())
+    return false;
+  if (typeof value.chainId !== "string") return false;
+  if (!/^(0|[1-9]\d*)$/.test(value.chainId)) return false;
+  const isLastNull = value.lastWithdrawNonce === null;
+  const lastNonceValid = isLastNull || isUint256Decimal(value.lastWithdrawNonce);
+  if (!lastNonceValid) return false;
+  if (!isUint256Decimal(value.nextWithdrawNonce)) return false;
+  if (isLastNull) {
+    return value.nextWithdrawNonce === "1";
+  }
+  const lastNonce = BigInt(value.lastWithdrawNonce);
+  const nextNonce = BigInt(value.nextWithdrawNonce);
+  const expectedNextNonce = lastNonce + 1n;
+  if (expectedNextNonce > 2n ** 256n - 1n) return false;
+  return nextNonce === expectedNextNonce;
+}
 
 // src/protocol/write-signer.ts
 var import_errors2 = require("./errors.cjs");
@@ -33369,7 +33880,9 @@ function resolveWriteSigner(source, options = {}) {
 // src/protocol/jobs-client.ts
 var IDENTITY_PATH = "/v1/identity";
 var JOBS_PATH = "/v1/jobs";
+var JOB_QUOTE_PATH = "/v1/jobs/quote";
 var JOB_EXECUTE_PATH = "/v1/jobs/execute";
+var JOB_ACCESS_OP_TYPE = "job_access";
 var AUTHORIZATION_HEADER = "Authorization";
 var CONTENT_TYPE_HEADER = "Content-Type";
 var JSON_CONTENT_TYPE = "application/json";
@@ -33383,7 +33896,11 @@ var HTTP_UNAUTHORIZED = 401;
 var HTTP_FORBIDDEN = 403;
 var HTTP_NOT_FOUND = 404;
 var HTTP_CONFLICT = 409;
+var HTTP_PAYMENT_REQUIRED = 402;
 var HTTP_PAYLOAD_TOO_LARGE = 413;
+var NONCE_TIMESTAMP_SHIFT = 32n;
+var UINT256_DECIMAL = /^(0|[1-9]\d*)$/;
+var POSITIVE_UINT256_DECIMAL = /^[1-9]\d*$/;
 var MILLISECONDS_PER_SECOND = 1e3;
 var DEFAULT_JOB_TIMEOUT_MS = 12e4;
 var DEFAULT_JOB_POLL_MS = CLAIM_POLL_FLOOR_MS;
@@ -33466,11 +33983,17 @@ function resolveBuilder(options) {
       "Builder signer must expose both address and publicKey"
     );
   }
+  const typedDataSigner = source.signTypedData;
   return {
     builder: {
       address: signer.address,
       publicKey,
-      signMessage: signer.signMessage
+      signMessage: signer.signMessage,
+      ...typedDataSigner ? {
+        signTypedData: typedDataSigner.bind(
+          source
+        )
+      } : {}
     },
     ...options.builderPrivateKey ? { privateKey: options.builderPrivateKey } : {}
   };
@@ -33554,7 +34077,7 @@ function isResultHandle(value) {
 function hasMatchingIdentityKey(value) {
   const address = value["address"];
   const publicKey = value["publicKey"];
-  if (typeof address !== "string" || !(0, import_viem16.isAddress)(address) || typeof publicKey !== "string" || !(0, import_viem16.isHex)(publicKey)) {
+  if (typeof address !== "string" || !(0, import_viem17.isAddress)(address) || typeof publicKey !== "string" || !(0, import_viem17.isHex)(publicKey)) {
     return false;
   }
   try {
@@ -33567,14 +34090,59 @@ function hasExpectedIdentity(value, owner, chainId) {
   const identityOwner = value["ownerAddress"];
   const identityChainId = value["chainId"];
   const identityUserPsId = value["userPsId"];
-  if (!hasMatchingIdentityKey(value) || typeof identityOwner !== "string" || !(0, import_viem16.isAddress)(identityOwner) || typeof identityChainId !== "number" || typeof identityUserPsId !== "string" || !(0, import_viem16.isHex)(identityUserPsId)) {
+  if (!hasMatchingIdentityKey(value) || typeof identityOwner !== "string" || !(0, import_viem17.isAddress)(identityOwner) || typeof identityChainId !== "number" || typeof identityUserPsId !== "string" || !(0, import_viem17.isHex)(identityUserPsId)) {
     return false;
   }
-  return (0, import_viem16.isAddressEqual)(identityOwner, owner) && identityChainId === chainId && identityUserPsId.toLowerCase() === userPsId(chainId, owner).toLowerCase();
+  return (0, import_viem17.isAddressEqual)(identityOwner, owner) && identityChainId === chainId && identityUserPsId.toLowerCase() === userPsId(chainId, owner).toLowerCase();
 }
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function resolveEscrowContract(options) {
+  if (options.escrowContract) return options.escrowContract;
+  const addresses = CONTRACTS2["DataPortabilityEscrow"]?.addresses;
+  const address = addresses?.[options.chainId];
+  if (!address || !(0, import_viem17.isAddress)(address)) {
+    throw new import_errors3.JobRejectedError(
+      `No DataPortabilityEscrow address for chain ${options.chainId}; pass escrowContract`
+    );
+  }
+  return address;
+}
+function nextPaymentNonce() {
+  const random = new Uint32Array(1);
+  globalThis.crypto.getRandomValues(random);
+  return (BigInt(Date.now()) << NONCE_TIMESTAMP_SHIFT) + BigInt(random[0] ?? 0);
+}
+function parseJobQuote(body) {
+  if (!isRecord2(body)) return null;
+  const { chainId, price, asset, payable, enforced } = body;
+  if (typeof chainId !== "number" || !Number.isSafeInteger(chainId))
+    return null;
+  if (typeof price !== "string" || !UINT256_DECIMAL.test(price)) return null;
+  if (typeof asset !== "string" || !(0, import_viem17.isAddress)(asset)) return null;
+  if (typeof payable !== "boolean" || typeof enforced !== "boolean")
+    return null;
+  return { chainId, price, asset, payable, enforced };
+}
+async function paymentQuote(response) {
+  const body = await responseBody(response);
+  const asset = isRecord2(body) ? body["asset"] : void 0;
+  const amount = isRecord2(body) ? body["amount"] : void 0;
+  if (typeof asset !== "string" || !(0, import_viem17.isAddress)(asset) || typeof amount !== "string" || !POSITIVE_UINT256_DECIMAL.test(amount)) {
+    throw new import_errors3.JobRejectedError(
+      "Gateway asked for payment without a usable quote",
+      response.status
+    );
+  }
+  return { asset, amount };
+}
+async function paymentRefusal(response) {
+  const body = await responseBody(response);
+  const parsed = isRecord2(body) ? body : {};
+  const message = typeof parsed["error"] === "string" ? parsed["error"] : "This read requires payment the builder escrow cannot back";
+  return { message, details: parsed };
+}
 function requireFiniteDuration(value, field) {
   if (!Number.isFinite(value)) {
     throw new import_errors3.JobRejectedError(`${field} must be a finite number`);
@@ -33587,6 +34155,73 @@ function createJobsClient(options) {
   const { builder, privateKey } = resolveBuilder(options);
   const ecies = options.ecies ?? new NodeECIESUint8Provider();
   const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  async function signQuote(jobId, quote) {
+    if (!builder.signTypedData) {
+      throw new import_errors3.JobRejectedError(
+        "This read is charged, but the builder signer cannot sign typed data"
+      );
+    }
+    const paymentNonce = nextPaymentNonce();
+    const signature = await builder.signTypedData({
+      domain: genericPaymentDomain(
+        options.chainId,
+        resolveEscrowContract(options)
+      ),
+      types: GENERIC_PAYMENT_TYPES,
+      primaryType: "GenericPayment",
+      message: {
+        payerAddress: builder.address,
+        opType: JOB_ACCESS_OP_TYPE,
+        opId: (0, import_viem17.keccak256)((0, import_viem17.toHex)(jobId.toLowerCase())),
+        asset: quote.asset,
+        amount: BigInt(quote.amount),
+        paymentNonce
+      }
+    });
+    return {
+      signature,
+      amount: quote.amount,
+      asset: quote.asset,
+      paymentNonce: paymentNonce.toString()
+    };
+  }
+  async function postSubmission(submission, wait) {
+    const identifiers = {
+      jobId: submission.jobId,
+      idempotencyKey: submission.idempotencyKey
+    };
+    const bodyBytes = new TextEncoder().encode(JSON.stringify(submission));
+    const authorization = await buildWeb3SignedHeader({
+      signMessage: builder.signMessage,
+      aud: audience,
+      method: POST_METHOD,
+      uri: JOBS_PATH,
+      body: bodyBytes,
+      nonce: (0, import_node_crypto.randomUUID)()
+    });
+    try {
+      return await request(
+        `${baseUrl}${JOBS_PATH}?wait=${wait}`,
+        {
+          method: POST_METHOD,
+          headers: {
+            [AUTHORIZATION_HEADER]: authorization,
+            [CONTENT_TYPE_HEADER]: JSON_CONTENT_TYPE
+          },
+          body: bodyBytes
+        },
+        "Job submission"
+      );
+    } catch (error) {
+      if (error instanceof import_errors3.JobTransportError) {
+        throw new import_errors3.JobTransportError(error.message, error.cause, {
+          ...error.details,
+          ...identifiers
+        });
+      }
+      throw error;
+    }
+  }
   async function request(url, init, description) {
     try {
       return await fetchFn(url, init);
@@ -33642,7 +34277,8 @@ function createJobsClient(options) {
         "deadlineSeconds"
       );
       const wait = clampInteger(params.wait, 0, 0, MAX_WAIT_SECONDS, "wait");
-      const jobId = (0, import_node_crypto.randomUUID)();
+      const jobId = params.jobId ?? (0, import_node_crypto.randomUUID)();
+      const idempotencyKey = params.idempotencyKey ?? (0, import_node_crypto.randomUUID)();
       const nowMs = now().getTime();
       if (!Number.isFinite(nowMs)) {
         throw new import_errors3.JobRejectedError("now must return a valid Date");
@@ -33680,32 +34316,41 @@ function createJobsClient(options) {
         grantId: requestBody.grantId,
         scope: requestBody.scope,
         operation: requestBody.operation,
-        idempotencyKey: (0, import_node_crypto.randomUUID)(),
+        idempotencyKey,
         jobId,
         deadline,
-        requestCiphertext
+        requestCiphertext,
+        ...params.maxPrice === void 0 ? {} : { maxPrice: params.maxPrice }
       };
-      const bodyBytes = new TextEncoder().encode(JSON.stringify(submission));
-      const authorization = await buildWeb3SignedHeader({
-        signMessage: builder.signMessage,
-        aud: audience,
-        method: POST_METHOD,
-        uri: JOBS_PATH,
-        body: bodyBytes,
-        nonce: (0, import_node_crypto.randomUUID)()
-      });
-      const response = await request(
-        `${baseUrl}${JOBS_PATH}?wait=${wait}`,
-        {
-          method: POST_METHOD,
-          headers: {
-            [AUTHORIZATION_HEADER]: authorization,
-            [CONTENT_TYPE_HEADER]: JSON_CONTENT_TYPE
-          },
-          body: bodyBytes
-        },
-        "Job submission"
-      );
+      let response = await postSubmission(submission, wait);
+      if (response.status === HTTP_PAYMENT_REQUIRED) {
+        const quote = await paymentQuote(response);
+        if (params.maxPrice !== void 0 && BigInt(quote.amount) > BigInt(params.maxPrice)) {
+          throw new import_errors4.PaymentRequiredError(
+            "The quoted price is above the maxPrice you set for this read",
+            {
+              jobId,
+              scope: params.scope,
+              grantId: params.grantId,
+              asset: quote.asset,
+              amount: quote.amount,
+              maxPrice: params.maxPrice
+            }
+          );
+        }
+        submission.payment = await signQuote(jobId, quote);
+        submission.priceAsset = quote.asset;
+        response = await postSubmission(submission, wait);
+        if (response.status === HTTP_PAYMENT_REQUIRED) {
+          const refusal = await paymentRefusal(response);
+          throw new import_errors4.PaymentRequiredError(refusal.message, {
+            jobId,
+            scope: params.scope,
+            grantId: params.grantId,
+            ...refusal.details
+          });
+        }
+      }
       if (!response.ok) {
         throw await rejectedResponse(response, "Job submission rejected");
       }
@@ -33728,6 +34373,40 @@ function createJobsClient(options) {
         response.status
       );
     },
+    async quoteJob() {
+      const authorization = await buildWeb3SignedHeader({
+        signMessage: builder.signMessage,
+        aud: audience,
+        method: GET_METHOD,
+        uri: JOB_QUOTE_PATH,
+        nonce: (0, import_node_crypto.randomUUID)()
+      });
+      const response = await request(
+        `${baseUrl}${JOB_QUOTE_PATH}`,
+        {
+          method: GET_METHOD,
+          headers: { [AUTHORIZATION_HEADER]: authorization }
+        },
+        "Job quote"
+      );
+      if (!response.ok) {
+        throw await rejectedResponse(response, "Job quote rejected");
+      }
+      const quote = parseJobQuote(await responseBody(response));
+      if (!quote) {
+        throw new import_errors3.JobRejectedError(
+          "Gateway returned an undocumented job quote",
+          response.status
+        );
+      }
+      if (quote.chainId !== options.chainId) {
+        throw new import_errors3.JobRejectedError(
+          `Gateway quoted chain ${quote.chainId}, not the configured ${options.chainId}`,
+          response.status
+        );
+      }
+      return quote;
+    },
     async getJob(jobId) {
       const path = `${JOBS_PATH}/${encodeURIComponent(jobId)}`;
       const authorization = await buildWeb3SignedHeader({
@@ -33819,7 +34498,7 @@ function createJobsClient(options) {
           error
         );
       }
-      const actualHash = (0, import_viem16.bytesToHex)((0, import_sha26.sha256)(bytes));
+      const actualHash = (0, import_viem17.bytesToHex)((0, import_sha26.sha256)(bytes));
       if (actualHash.toLowerCase() !== handle.hash.toLowerCase()) {
         throw new import_errors3.JobResultIntegrityError(
           "Fetched job result hash does not match its handle",
@@ -33881,14 +34560,14 @@ function createJobsClient(options) {
 }
 
 // src/protocol/personal-server-registration.ts
-var import_viem17 = require("viem");
+var import_viem18 = require("viem");
 var PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID = vanaMainnet2.id;
 var PERSONAL_SERVER_REGISTRATION_DEFAULT_VERIFYING_CONTRACT = getContractAddress(
   PERSONAL_SERVER_REGISTRATION_DEFAULT_CHAIN_ID,
   "DataPortabilityServers"
 );
 function assertAddress(value, name) {
-  if (!(0, import_viem17.isAddress)(value)) {
+  if (!(0, import_viem18.isAddress)(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -33974,12 +34653,12 @@ async function buildPersonalServerRegistrationSignature(input) {
 var registerPersonalServerSignature = buildPersonalServerRegistrationSignature;
 
 // src/personal-server-lite/owner-binding.ts
-var import_viem18 = require("viem");
+var import_viem19 = require("viem");
 var PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION = "vana.ps-lite.owner-binding.v1";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE = "ps-lite-owner";
 var PERSONAL_SERVER_LITE_OWNER_BINDING_PREFIX = `${PERSONAL_SERVER_LITE_OWNER_BINDING_VERSION}:${PERSONAL_SERVER_LITE_OWNER_BINDING_PURPOSE}:`;
 function assertAddress2(value, name) {
-  if (!(0, import_viem18.isAddress)(value)) {
+  if (!(0, import_viem19.isAddress)(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -34029,7 +34708,7 @@ async function buildPersonalServerLiteOwnerBindingSignature(input) {
 var signPersonalServerLiteOwnerBinding = buildPersonalServerLiteOwnerBindingSignature;
 
 // src/account/personal-server-registration.ts
-var import_viem19 = require("viem");
+var import_viem20 = require("viem");
 var ACCOUNT_PERSONAL_SERVER_REGISTRATION_INTENT = "personal_server.server_registration.v1";
 var AccountPersonalServerRegistrationError = class extends Error {
   status;
@@ -34048,7 +34727,7 @@ function trimTrailingSlash(value) {
   return value.replace(/\/+$/, "");
 }
 function assertAddress3(value, name) {
-  if (!(0, import_viem19.isAddress)(value)) {
+  if (!(0, import_viem20.isAddress)(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
@@ -34312,7 +34991,7 @@ function accountOwnerBindingError(error) {
 }
 
 // src/protocol/grants.ts
-var import_viem20 = require("viem");
+var import_viem21 = require("viem");
 function isHexString(value) {
   return typeof value === "string" && value.startsWith("0x");
 }
@@ -34357,7 +35036,7 @@ async function verifyGrantRegistration(input) {
   }
   let valid;
   try {
-    valid = await (0, import_viem20.verifyTypedData)({
+    valid = await (0, import_viem21.verifyTypedData)({
       address: input.grantorAddress,
       domain: grantRegistrationDomain(input.gatewayConfig),
       types: GRANT_REGISTRATION_TYPES,
@@ -34392,8 +35071,8 @@ async function verifyGrantRegistration(input) {
 }
 
 // src/protocol/fee-registry.ts
-var import_viem21 = require("viem");
-var FEE_REGISTRY_ABI = (0, import_viem21.parseAbi)([
+var import_viem22 = require("viem");
+var FEE_REGISTRY_ABI = (0, import_viem22.parseAbi)([
   "struct Fee { uint256 amount; address asset; address payee; bool enabled; }",
   "function fees(bytes32 operation) view returns (Fee)",
   "function operationKey(string name) pure returns (bytes32)"
@@ -34476,8 +35155,8 @@ async function getOpFee(client, config, opType, opts) {
 }
 
 // src/protocol/escrow-deposit.ts
-var import_viem22 = require("viem");
-var ESCROW_DEPOSIT_ABI = [
+var import_viem23 = require("viem");
+var ESCROW_DEPOSIT_ABI2 = [
   {
     type: "function",
     name: "depositNative",
@@ -34501,15 +35180,15 @@ function escrowContractAddress(config) {
   return config.contracts.dataPortabilityEscrow;
 }
 function encodeDepositNativeData(input) {
-  return (0, import_viem22.encodeFunctionData)({
-    abi: ESCROW_DEPOSIT_ABI,
+  return (0, import_viem23.encodeFunctionData)({
+    abi: ESCROW_DEPOSIT_ABI2,
     functionName: "depositNative",
     args: [input.account]
   });
 }
 function encodeDepositTokenData(input) {
-  return (0, import_viem22.encodeFunctionData)({
-    abi: ESCROW_DEPOSIT_ABI,
+  return (0, import_viem23.encodeFunctionData)({
+    abi: ESCROW_DEPOSIT_ABI2,
     functionName: "depositToken",
     args: [input.account, input.token, input.amount]
   });
@@ -34529,7 +35208,7 @@ function buildDepositTokenRequest(config, input) {
 }
 
 // src/protocol/data-point-status.ts
-var import_viem23 = require("viem");
+var import_viem24 = require("viem");
 var DataPointStatus = /* @__PURE__ */ ((DataPointStatus2) => {
   DataPointStatus2[DataPointStatus2["None"] = 0] = "None";
   DataPointStatus2[DataPointStatus2["Active"] = 1] = "Active";
@@ -34553,7 +35232,7 @@ function dataRegistryContractAddress(config) {
   return config.contracts.dataRegistry;
 }
 function encodeSetDataPointStatusData(input) {
-  return (0, import_viem23.encodeFunctionData)({
+  return (0, import_viem24.encodeFunctionData)({
     abi: DATA_REGISTRY_STATUS_ABI,
     functionName: "setStatus",
     args: [input.scope, input.status]
@@ -34573,13 +35252,13 @@ function buildMarkDataPointUnavailableRequest(config, input) {
 }
 
 // src/protocol/data-point-deletion.ts
-var import_viem25 = require("viem");
-var import_errors5 = require("./errors.cjs");
+var import_viem26 = require("viem");
+var import_errors6 = require("./errors.cjs");
 
 // src/protocol/lineage.ts
-var import_viem24 = require("viem");
+var import_viem25 = require("viem");
 var import_zod = require("zod");
-var import_errors4 = require("./errors.cjs");
+var import_errors5 = require("./errors.cjs");
 
 // src/protocol/personal-server-error-body.ts
 function isRecord4(value) {
@@ -34616,13 +35295,13 @@ function isDataPointId(value) {
   return typeof value === "string" && DATA_POINT_ID_PATTERN.test(value);
 }
 function deriveDataPointId(ownerAddress, scope) {
-  if (!(0, import_viem24.isAddress)(ownerAddress, { strict: false })) {
+  if (!(0, import_viem25.isAddress)(ownerAddress, { strict: false })) {
     throw new Error(
       `ownerAddress is not an EVM address: ${String(ownerAddress)}`
     );
   }
-  return (0, import_viem24.keccak256)(
-    (0, import_viem24.encodeAbiParameters)(
+  return (0, import_viem25.keccak256)(
+    (0, import_viem25.encodeAbiParameters)(
       [
         { name: "ownerAddress", type: "address" },
         { name: "scope", type: "string" }
@@ -34651,7 +35330,7 @@ function derivedScopeViolatesNaming(derivedScope, sourceScope) {
 function assertDerivedScopeNaming(derivedScope, sourceScopes) {
   for (const sourceScope of sourceScopes) {
     if (derivedScopeViolatesNaming(derivedScope, sourceScope)) {
-      throw new import_errors4.WriteRequestError(
+      throw new import_errors5.WriteRequestError(
         `Derived scope ${derivedScope} must not share its first segment with source scope ${sourceScope}; put derivatives in the app's own namespace`,
         { scope: derivedScope, sourceScope }
       );
@@ -34714,7 +35393,7 @@ function normalizeBaseUrl(url) {
 function resolveFetch2(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new import_errors4.LineageReadError("No fetch implementation available");
+    throw new import_errors5.LineageReadError("No fetch implementation available");
   }
   return resolved;
 }
@@ -34722,7 +35401,7 @@ function normalizeVersion(version) {
   if (version === void 0) return void 0;
   const text = String(version);
   if (!VERSION_PATTERN.test(text)) {
-    throw new import_errors4.LineageReadError(
+    throw new import_errors5.LineageReadError(
       "version must be a positive decimal integer",
       void 0,
       "INVALID_VERSION",
@@ -34733,7 +35412,7 @@ function normalizeVersion(version) {
 }
 async function lineageReadFailure(source, response) {
   const { errorCode, message, details } = await readPersonalServerErrorBody(response);
-  return new import_errors4.LineageReadError(
+  return new import_errors5.LineageReadError(
     message ?? `${source} lineage read failed: ${response.status} ${response.statusText}`,
     response.status,
     errorCode,
@@ -34745,7 +35424,7 @@ async function parseLineageGraph(source, response) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new import_errors4.LineageReadError(
+    throw new import_errors5.LineageReadError(
       `${source} lineage response is not JSON`,
       response.status,
       null,
@@ -34755,7 +35434,7 @@ async function parseLineageGraph(source, response) {
   const envelope = isRecord4(body) && isRecord4(body.data) ? body : void 0;
   const parsed = LineageGraphSchema.safeParse(envelope?.data ?? body);
   if (!parsed.success) {
-    throw new import_errors4.LineageReadError(
+    throw new import_errors5.LineageReadError(
       `${source} lineage response is not a lineage view`,
       response.status,
       null,
@@ -34770,7 +35449,7 @@ async function sendLineageRead(source, fetchFn, url, headers) {
   try {
     response = await fetchFn(url, { method: "GET", headers });
   } catch (err) {
-    throw new import_errors4.LineageReadError(
+    throw new import_errors5.LineageReadError(
       `${source} lineage read failed: ${err instanceof Error ? err.message : String(err)}`,
       void 0,
       null,
@@ -34811,7 +35490,7 @@ async function getPersonalServerLineage(params) {
 }
 async function getGatewayLineage(params) {
   if (!isDataPointId(params.dataPointId)) {
-    throw new import_errors4.LineageReadError(
+    throw new import_errors5.LineageReadError(
       "dataPointId must be a 32-byte hex string (see deriveDataPointId)",
       void 0,
       "INVALID_DATA_POINT_ID",
@@ -34848,7 +35527,7 @@ var TOMBSTONE_METADATA_HASH_PREIMAGE = "vana.data-point.tombstone.metadata.v1";
 var TOMBSTONE_DATA_HASH = "0x30c45ee72fe56d1927701316925ab7ceacd3b6f9267061735d59396f075c6222";
 var TOMBSTONE_METADATA_HASH = "0xc5255a141acd6a2ae55971b62c0a85977c2511989dc114ad2abc2b7644f57d90";
 function computeTombstoneHash(preimage) {
-  return (0, import_viem25.keccak256)((0, import_viem25.stringToBytes)(preimage));
+  return (0, import_viem26.keccak256)((0, import_viem26.stringToBytes)(preimage));
 }
 function isTombstoneHashes(dataHash, metadataHash) {
   return typeof dataHash === "string" && typeof metadataHash === "string" && dataHash.toLowerCase() === TOMBSTONE_DATA_HASH && metadataHash.toLowerCase() === TOMBSTONE_METADATA_HASH;
@@ -34867,12 +35546,12 @@ function tombstoneDeletedAt(value) {
   return typeof deletedAt === "string" ? deletedAt : null;
 }
 function assertAddress4(value, name) {
-  if (!(0, import_viem25.isAddress)(value)) {
+  if (!(0, import_viem26.isAddress)(value)) {
     throw new Error(`${name} must be a valid EVM address`);
   }
 }
 function assertUint256(value, name) {
-  if (value < 0n || value > import_viem25.maxUint256) {
+  if (value < 0n || value > import_viem26.maxUint256) {
     throw new Error(`${name} must fit in uint256, got ${value}`);
   }
 }
@@ -34957,13 +35636,13 @@ async function deleteDataPoint(input) {
   if (currentVersion === void 0) {
     const record = await input.gateway.getDataPoint(dataPointId);
     if (record === null) {
-      throw new import_errors5.DataPointNotFoundError(
+      throw new import_errors6.DataPointNotFoundError(
         `No data point registered for scope '${input.scope}' owned by ${ownerAddress}`,
         { dataPointId, scope: input.scope, ownerAddress }
       );
     }
     if (isDataPointTombstone(record)) {
-      throw new import_errors5.DataPointDeletedError(
+      throw new import_errors6.DataPointDeletedError(
         `Data point ${dataPointId} (scope '${input.scope}') is already deleted`,
         {
           dataPointId,
@@ -34975,7 +35654,7 @@ async function deleteDataPoint(input) {
     }
     currentVersion = parseExpectedVersion(record.expectedVersion);
   }
-  if (currentVersion < 0n || currentVersion >= import_viem25.maxUint256) {
+  if (currentVersion < 0n || currentVersion >= import_viem26.maxUint256) {
     throw new Error(
       `currentVersion ${currentVersion} cannot be incremented to a uint256 tombstone version`
     );
@@ -35010,7 +35689,7 @@ async function deleteDataPoint(input) {
 }
 
 // src/protocol/personal-server-data.ts
-var import_errors6 = require("./errors.cjs");
+var import_errors7 = require("./errors.cjs");
 
 // src/protocol/data-file.ts
 var import_zod2 = require("zod");
@@ -35070,7 +35749,7 @@ async function readPersonalServerData(params) {
   const request = await buildPersonalServerDataReadRequest(params);
   const response = await fetchFn(request);
   if (response.status === 410) {
-    throw new import_errors6.DataPointDeletedError(
+    throw new import_errors7.DataPointDeletedError(
       `Personal Server scope '${params.scope}' has been deleted`,
       {
         scope: params.scope,
@@ -35085,7 +35764,7 @@ async function readPersonalServerData(params) {
   }
   const body = await response.json();
   if (isDataPointTombstone(body)) {
-    throw new import_errors6.DataPointDeletedError(
+    throw new import_errors7.DataPointDeletedError(
       `Personal Server scope '${params.scope}' has been deleted`,
       { scope: params.scope, deletedAt: tombstoneDeletedAt(body) }
     );
@@ -35286,21 +35965,21 @@ function tryGrantPermissions(scopes) {
 
 // src/protocol/personal-server-write.ts
 var import_sha28 = require("@noble/hashes/sha2");
-var import_viem27 = require("viem");
+var import_viem28 = require("viem");
 var import_zod4 = require("zod");
-var import_errors8 = require("./errors.cjs");
+var import_errors9 = require("./errors.cjs");
 
 // src/protocol/write-request.ts
 var import_sha27 = require("@noble/hashes/sha2");
-var import_viem26 = require("viem");
-var import_errors7 = require("./errors.cjs");
+var import_viem27 = require("viem");
+var import_errors8 = require("./errors.cjs");
 function normalizeBaseUrl2(url) {
   return url.replace(/\/+$/, "");
 }
 function resolveFetch3(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new import_errors7.WriteRequestError("No fetch implementation available");
+    throw new import_errors8.WriteRequestError("No fetch implementation available");
   }
   return resolved;
 }
@@ -35360,14 +36039,14 @@ function freshProofNonce() {
     return webCrypto2.randomUUID();
   }
   if (typeof webCrypto2?.getRandomValues === "function") {
-    return (0, import_viem26.bytesToHex)(webCrypto2.getRandomValues(new Uint8Array(16)));
+    return (0, import_viem27.bytesToHex)(webCrypto2.getRandomValues(new Uint8Array(16)));
   }
-  throw new import_errors7.WriteRequestError(
+  throw new import_errors8.WriteRequestError(
     "No secure random source available to build a proof nonce; provide a crypto global"
   );
 }
 function proofKeyFor(parts) {
-  return (0, import_viem26.bytesToHex)(
+  return (0, import_viem27.bytesToHex)(
     (0, import_sha27.sha256)(
       new TextEncoder().encode(
         JSON.stringify([
@@ -35375,7 +36054,7 @@ function proofKeyFor(parts) {
           parts.method,
           parts.uri,
           parts.grantId,
-          parts.signedBytes ? (0, import_viem26.bytesToHex)((0, import_sha27.sha256)(parts.signedBytes)) : ""
+          parts.signedBytes ? (0, import_viem27.bytesToHex)((0, import_sha27.sha256)(parts.signedBytes)) : ""
         ])
       )
     )
@@ -35397,7 +36076,7 @@ async function sendWithFreshProof(label, fetchFn, options, proofKey, build) {
       delayMs *= 2;
     }
   }
-  throw new import_errors7.WriteTransportError(
+  throw new import_errors8.WriteTransportError(
     `${label} failed after ${attempts} attempt(s): ${errorMessage(lastError)}`,
     attempts,
     lastError
@@ -35468,7 +36147,7 @@ async function openWriteSession(params) {
   const mintedAt = Date.now();
   if (!response.ok) {
     const { errorCode, message, details } = await readPersonalServerErrorBody(response);
-    throw new import_errors8.WriteSessionError(
+    throw new import_errors9.WriteSessionError(
       message ?? `Write session handshake failed: ${response.status} ${response.statusText}`,
       response.status,
       errorCode,
@@ -35479,7 +36158,7 @@ async function openWriteSession(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new import_errors8.WriteSessionError(
+    throw new import_errors9.WriteSessionError(
       "Write session response is not JSON",
       response.status,
       null,
@@ -35488,7 +36167,7 @@ async function openWriteSession(params) {
   }
   const parsed = WriteSessionResponseSchema.safeParse(body);
   if (!parsed.success) {
-    throw new import_errors8.WriteSessionError(
+    throw new import_errors9.WriteSessionError(
       "Write session response is not a session",
       response.status,
       null,
@@ -35496,7 +36175,7 @@ async function openWriteSession(params) {
     );
   }
   if (parsed.data.token_type.toLowerCase() !== "bearer") {
-    throw new import_errors8.WriteSessionError(
+    throw new import_errors9.WriteSessionError(
       `Write session token type is not Bearer: ${parsed.data.token_type}`,
       response.status
     );
@@ -35518,7 +36197,7 @@ function isWriteSession(value) {
 }
 function sessionCoversScope(session, scope) {
   if (!isRecord4(session) || !Array.isArray(session.writeScopes) || !session.writeScopes.every((pattern) => typeof pattern === "string")) {
-    throw new import_errors8.WriteRequestError("session must come from openWriteSession");
+    throw new import_errors9.WriteRequestError("session must come from openWriteSession");
   }
   return session.writeScopes.some(
     (pattern) => scopeMatchesPattern(scope, pattern)
@@ -35543,12 +36222,12 @@ function encodeWriteMetadataHeader(metadata) {
   try {
     json = JSON.stringify(metadata);
   } catch (err) {
-    throw new import_errors8.WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `metadata is not JSON-serialisable: ${errorMessage(err)}`
     );
   }
   if (typeof json !== "string") {
-    throw new import_errors8.WriteRequestError("metadata must serialise to JSON");
+    throw new import_errors9.WriteRequestError("metadata must serialise to JSON");
   }
   return json.replace(
     /[\u007f-\uffff]/g,
@@ -35562,7 +36241,7 @@ function binaryWriteSignedBytes(input) {
     mimeType: normalizeBinaryMimeType(input.contentType),
     ...input.filename ? { filename: input.filename } : {},
     sizeBytes: input.bytes.length,
-    contentHash: (0, import_viem27.bytesToHex)((0, import_sha28.sha256)(input.bytes)),
+    contentHash: (0, import_viem28.bytesToHex)((0, import_sha28.sha256)(input.bytes)),
     encoding: "base64",
     content: toBase64(input.bytes),
     ...metadata !== void 0 ? { metadata } : {}
@@ -35583,7 +36262,7 @@ function setFilenameHeader(headers, filename) {
 function assertNoReservedKeys(value, where) {
   for (const key of RESERVED_WRITE_KEYS) {
     if (Object.prototype.hasOwnProperty.call(value, key)) {
-      throw new import_errors8.WriteRequestError(
+      throw new import_errors9.WriteRequestError(
         `${where} must not contain the reserved ${key} key; the Personal Server stamps it`,
         { key }
       );
@@ -35595,10 +36274,10 @@ function isLineagePair(value) {
 }
 function normalizeLineage(lineage, derivedScope) {
   if (!Array.isArray(lineage)) {
-    throw new import_errors8.WriteRequestError("lineage must be an array of data point ids");
+    throw new import_errors9.WriteRequestError("lineage must be an array of data point ids");
   }
   if (lineage.length > MAX_LINEAGE_SOURCES) {
-    throw new import_errors8.WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `lineage lists ${lineage.length} sources; the maximum is ${MAX_LINEAGE_SOURCES}`,
       { max: MAX_LINEAGE_SOURCES, count: lineage.length }
     );
@@ -35610,14 +36289,14 @@ function normalizeLineage(lineage, derivedScope) {
   for (const entry of lineage) {
     let id;
     if (isLineagePair(entry)) {
-      if (!(0, import_viem27.isAddress)(entry.ownerAddress, { strict: false })) {
-        throw new import_errors8.WriteRequestError(
+      if (!(0, import_viem28.isAddress)(entry.ownerAddress, { strict: false })) {
+        throw new import_errors9.WriteRequestError(
           "lineage source ownerAddress must be an EVM address",
           { ownerAddress: entry.ownerAddress }
         );
       }
       if (entry.scope.length === 0) {
-        throw new import_errors8.WriteRequestError("lineage source scope is required");
+        throw new import_errors9.WriteRequestError("lineage source scope is required");
       }
       id = deriveDataPointId(entry.ownerAddress, entry.scope);
       sourceScopes.push(entry.scope);
@@ -35625,14 +36304,14 @@ function normalizeLineage(lineage, derivedScope) {
     } else if (isDataPointId(entry)) {
       id = entry;
     } else {
-      throw new import_errors8.WriteRequestError(
+      throw new import_errors9.WriteRequestError(
         "lineage entries must be 32-byte hex data point ids or { ownerAddress, scope } pairs",
         { entry }
       );
     }
     const normalized = id.toLowerCase();
     if (seen.has(normalized)) {
-      throw new import_errors8.WriteRequestError("lineage must not repeat a data point id", {
+      throw new import_errors9.WriteRequestError("lineage must not repeat a data point id", {
         dataPointId: normalized
       });
     }
@@ -35641,7 +36320,7 @@ function normalizeLineage(lineage, derivedScope) {
   }
   for (const own of ownIds) {
     if (seen.has(own)) {
-      throw new import_errors8.WriteRequestError(
+      throw new import_errors9.WriteRequestError(
         "lineage must not cite the record's own data point",
         { dataPointId: own, scope: derivedScope }
       );
@@ -35652,7 +36331,7 @@ function normalizeLineage(lineage, derivedScope) {
 }
 function assertNoLineageField(value, where) {
   if (Object.prototype.hasOwnProperty.call(value, LINEAGE_FIELD)) {
-    throw new import_errors8.WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `${where}.${LINEAGE_FIELD} is reserved; pass sources through the lineage option`
     );
   }
@@ -35660,7 +36339,7 @@ function assertNoLineageField(value, where) {
 function buildMetadataHeader(metadata, sources) {
   if (metadata !== void 0) {
     if (!isRecord4(metadata)) {
-      throw new import_errors8.WriteRequestError("metadata must be a plain object");
+      throw new import_errors9.WriteRequestError("metadata must be a plain object");
     }
     assertNoReservedKeys(metadata, "metadata");
     assertNoLineageField(metadata, "metadata");
@@ -35673,24 +36352,24 @@ function buildMetadataHeader(metadata, sources) {
 }
 function prepareWrite(params) {
   if (params.binary !== void 0 && params.data !== void 0) {
-    throw new import_errors8.WriteRequestError("Pass either data or binary, not both");
+    throw new import_errors9.WriteRequestError("Pass either data or binary, not both");
   }
   const rawLineage = params.lineage;
   const sources = rawLineage === void 0 || rawLineage === null ? void 0 : normalizeLineage(rawLineage, params.scope);
   if (params.binary !== void 0) {
     const { bytes, contentType, filename } = params.binary;
     if (!(bytes instanceof Uint8Array)) {
-      throw new import_errors8.WriteRequestError("binary.bytes must be a Uint8Array");
+      throw new import_errors9.WriteRequestError("binary.bytes must be a Uint8Array");
     }
     if (typeof contentType !== "string" || contentType.trim() === "") {
-      throw new import_errors8.WriteRequestError("binary.contentType is required");
+      throw new import_errors9.WriteRequestError("binary.contentType is required");
     }
     if (filename !== void 0) {
       if (typeof filename !== "string") {
-        throw new import_errors8.WriteRequestError("binary.filename must be a string");
+        throw new import_errors9.WriteRequestError("binary.filename must be a string");
       }
       if (filename !== filename.trim()) {
-        throw new import_errors8.WriteRequestError(
+        throw new import_errors9.WriteRequestError(
           "binary.filename must not have leading or trailing whitespace"
         );
       }
@@ -35710,13 +36389,13 @@ function prepareWrite(params) {
     };
   }
   if (params.data === void 0) {
-    throw new import_errors8.WriteRequestError("Pass data (a JSON object) or binary");
+    throw new import_errors9.WriteRequestError("Pass data (a JSON object) or binary");
   }
   if (!isRecord4(params.data)) {
-    throw new import_errors8.WriteRequestError("data must be a plain JSON object");
+    throw new import_errors9.WriteRequestError("data must be a plain JSON object");
   }
   if (params.metadata !== void 0) {
-    throw new import_errors8.WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       "metadata applies to binary writes; put fields to store inside data"
     );
   }
@@ -35727,12 +36406,12 @@ function prepareWrite(params) {
   try {
     text = JSON.stringify(record);
   } catch (err) {
-    throw new import_errors8.WriteRequestError(
+    throw new import_errors9.WriteRequestError(
       `data is not JSON-serialisable: ${errorMessage(err)}`
     );
   }
   if (typeof text !== "string" || !text.startsWith("{")) {
-    throw new import_errors8.WriteRequestError("data must serialise to a JSON object");
+    throw new import_errors9.WriteRequestError("data must serialise to a JSON object");
   }
   const body = new TextEncoder().encode(text);
   return {
@@ -35745,31 +36424,31 @@ async function writeErrorFromResponse(response) {
   const { errorCode, message, details } = await readPersonalServerErrorBody(response);
   const text = message ?? `Personal Server write failed: ${response.status} ${response.statusText}`;
   if (response.status === 422 || errorCode?.startsWith("LINEAGE_")) {
-    return new import_errors8.WriteLineageError(text, response.status, errorCode, details);
+    return new import_errors9.WriteLineageError(text, response.status, errorCode, details);
   }
   switch (response.status) {
     case 401:
-      return new import_errors8.WriteUnauthorizedError(text, errorCode, details);
+      return new import_errors9.WriteUnauthorizedError(text, errorCode, details);
     case 403:
-      return new import_errors8.WriteForbiddenError(text, errorCode, details);
+      return new import_errors9.WriteForbiddenError(text, errorCode, details);
     case 409:
-      return new import_errors8.WriteConflictError(text, errorCode, details);
+      return new import_errors9.WriteConflictError(text, errorCode, details);
     default:
-      return new import_errors8.WriteRejectedError(text, response.status, errorCode, details);
+      return new import_errors9.WriteRejectedError(text, response.status, errorCode, details);
   }
 }
 async function writeData(params) {
   const { session } = params;
   if (!isWriteSession(session)) {
-    throw new import_errors8.WriteRequestError("session must come from openWriteSession");
+    throw new import_errors9.WriteRequestError("session must come from openWriteSession");
   }
   const fetchFn = resolveFetch3(params.fetch);
   if (typeof params.scope !== "string" || params.scope.length === 0) {
-    throw new import_errors8.WriteRequestError("scope is required");
+    throw new import_errors9.WriteRequestError("scope is required");
   }
   const prepared = prepareWrite(params);
   if (Date.now() >= session.expiresAt) {
-    throw new import_errors8.WriteSessionExpiredError(
+    throw new import_errors9.WriteSessionExpiredError(
       "Write session has expired; open a new session",
       { grantId: session.grantId, expiresAt: session.expiresAt }
     );
@@ -35825,7 +36504,7 @@ async function writeData(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new import_errors8.WriteRejectedError(
+    throw new import_errors9.WriteRejectedError(
       "Personal Server write response is not JSON",
       response.status,
       null,
@@ -35834,7 +36513,7 @@ async function writeData(params) {
   }
   const parsed = WriteDataResultSchema.safeParse(body);
   if (!parsed.success) {
-    throw new import_errors8.WriteRejectedError(
+    throw new import_errors9.WriteRejectedError(
       "Personal Server write response is not an ingest result",
       response.status,
       null,
@@ -35861,7 +36540,7 @@ async function writePersonalServerData(params) {
 
 // src/protocol/derivative-questions.ts
 var import_zod5 = require("zod");
-var import_errors9 = require("./errors.cjs");
+var import_errors10 = require("./errors.cjs");
 var DERIVATIVE_QUESTIONS_PATH = "/v1/derivatives/questions";
 var MAX_QUESTION_SOURCE_SCOPES = 16;
 var MAX_QUESTION_CHARS = 8e3;
@@ -35944,15 +36623,15 @@ function fetchIdOf(fetchFn) {
 }
 function resolveRequest(params) {
   if (typeof params.personalServerUrl !== "string" || params.personalServerUrl.length === 0) {
-    throw new import_errors9.WriteRequestError("personalServerUrl is required");
+    throw new import_errors10.WriteRequestError("personalServerUrl is required");
   }
   if (typeof params.grantId !== "string" || params.grantId.length === 0) {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       "grantId is required; a question call runs under the grant carrying write:<derivedScope>"
     );
   }
   if (params.signer === null || typeof params.signer !== "object") {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       "signer must be a viem LocalAccount, a viem WalletClient, or a { signMessage } object"
     );
   }
@@ -36006,37 +36685,37 @@ async function questionErrorFromResponse(response, body) {
   const text = message ?? `Derivative question request failed: ${response.status} ${response.statusText}`;
   switch (errorCode) {
     case "DERIVATIVE_SOURCE_NOT_GRANTED":
-      return new import_errors9.DerivativeSourceNotGrantedError(text, errorCode, details);
+      return new import_errors10.DerivativeSourceNotGrantedError(text, errorCode, details);
     case "DERIVATIVE_CYCLE":
-      return new import_errors9.DerivativeCycleError(text, errorCode, details);
+      return new import_errors10.DerivativeCycleError(text, errorCode, details);
     case "DERIVATIVE_COMPUTE_UNAVAILABLE":
-      return new import_errors9.DerivativeComputeUnavailableError(text, errorCode, details);
+      return new import_errors10.DerivativeComputeUnavailableError(text, errorCode, details);
     case "DERIVATIVE_QUESTION_INVALID":
     case "LINEAGE_SCOPE_UNDER_SOURCE_PREFIX":
-      return new import_errors9.DerivativeQuestionInvalidError(
+      return new import_errors10.DerivativeQuestionInvalidError(
         text,
         response.status,
         errorCode,
         details
       );
     case "DERIVATIVE_QUESTION_NOT_FOUND":
-      return new import_errors9.DerivativeQuestionNotFoundError(text, errorCode, details);
+      return new import_errors10.DerivativeQuestionNotFoundError(text, errorCode, details);
     case "DERIVATIVE_DERIVED_SCOPE_REQUIRED":
-      return new import_errors9.DerivativeDerivedScopeRequiredError(text, errorCode, details);
+      return new import_errors10.DerivativeDerivedScopeRequiredError(text, errorCode, details);
     default:
       break;
   }
   switch (response.status) {
     case 401:
-      return new import_errors9.WriteUnauthorizedError(text, errorCode, details);
+      return new import_errors10.WriteUnauthorizedError(text, errorCode, details);
     case 403:
-      return new import_errors9.WriteForbiddenError(text, errorCode, details);
+      return new import_errors10.WriteForbiddenError(text, errorCode, details);
     case 404:
-      return new import_errors9.DerivativeQuestionNotFoundError(text, errorCode, details);
+      return new import_errors10.DerivativeQuestionNotFoundError(text, errorCode, details);
     case 409:
-      return new import_errors9.WriteConflictError(text, errorCode, details);
+      return new import_errors10.WriteConflictError(text, errorCode, details);
     default:
-      return new import_errors9.DerivativeQuestionRejectedError(
+      return new import_errors10.DerivativeQuestionRejectedError(
         text,
         response.status,
         errorCode,
@@ -36116,7 +36795,7 @@ async function sendQuestionRequest(params, spec, schema) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new import_errors9.DerivativeQuestionRejectedError(
+    throw new import_errors10.DerivativeQuestionRejectedError(
       `${spec.label} response is not JSON`,
       response.status,
       null,
@@ -36125,7 +36804,7 @@ async function sendQuestionRequest(params, spec, schema) {
   }
   const parsed = schema.safeParse(body);
   if (!parsed.success) {
-    throw new import_errors9.DerivativeQuestionRejectedError(
+    throw new import_errors10.DerivativeQuestionRejectedError(
       `${spec.label} response is not a derivative question answer`,
       response.status,
       null,
@@ -36136,22 +36815,22 @@ async function sendQuestionRequest(params, spec, schema) {
 }
 function assertQuestionId(questionId) {
   if (typeof questionId !== "string" || questionId.length === 0) {
-    throw new import_errors9.WriteRequestError("questionId is required");
+    throw new import_errors10.WriteRequestError("questionId is required");
   }
   return `${DERIVATIVE_QUESTIONS_PATH}/${encodeURIComponent(questionId)}`;
 }
 function registrationBody(params) {
   const { derivedScope, question } = params;
   if (typeof derivedScope !== "string" || derivedScope.length === 0) {
-    throw new import_errors9.WriteRequestError("derivedScope is required");
+    throw new import_errors10.WriteRequestError("derivedScope is required");
   }
   if (!Array.isArray(params.sourceScopes) || params.sourceScopes.length === 0) {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       "sourceScopes must be a non-empty array of scopes"
     );
   }
   if (params.sourceScopes.length > MAX_QUESTION_SOURCE_SCOPES) {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       `sourceScopes lists ${params.sourceScopes.length} scopes; the maximum is ${MAX_QUESTION_SOURCE_SCOPES}`,
       { max: MAX_QUESTION_SOURCE_SCOPES, count: params.sourceScopes.length }
     );
@@ -36159,15 +36838,15 @@ function registrationBody(params) {
   const sourceScopes = [];
   for (const scope of params.sourceScopes) {
     if (typeof scope !== "string" || scope.length === 0) {
-      throw new import_errors9.WriteRequestError("sourceScopes entries must be scope strings");
+      throw new import_errors10.WriteRequestError("sourceScopes entries must be scope strings");
     }
     if (sourceScopes.includes(scope)) {
-      throw new import_errors9.WriteRequestError("sourceScopes must not repeat a scope", {
+      throw new import_errors10.WriteRequestError("sourceScopes must not repeat a scope", {
         duplicate: scope
       });
     }
     if (scope === derivedScope) {
-      throw new import_errors9.WriteRequestError(
+      throw new import_errors10.WriteRequestError(
         "derivedScope cannot be one of its own sources",
         { scope }
       );
@@ -36175,17 +36854,17 @@ function registrationBody(params) {
     sourceScopes.push(scope);
   }
   if (typeof question !== "string" || question.trim() === "") {
-    throw new import_errors9.WriteRequestError("question must be a non-empty string");
+    throw new import_errors10.WriteRequestError("question must be a non-empty string");
   }
   if (question.length > MAX_QUESTION_CHARS) {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       `question is ${question.length} characters; the maximum is ${MAX_QUESTION_CHARS}`,
       { max: MAX_QUESTION_CHARS, length: question.length }
     );
   }
   if (params.model !== void 0) {
     if (typeof params.model !== "string" || params.model.length > MAX_QUESTION_MODEL_CHARS || !MODEL_ID_PATTERN.test(params.model)) {
-      throw new import_errors9.WriteRequestError("model must be a provider model id", {
+      throw new import_errors10.WriteRequestError("model must be a provider model id", {
         model: params.model
       });
     }
@@ -36221,7 +36900,7 @@ async function getQuestion(params) {
 }
 async function listQuestions(params) {
   if (typeof params.derivedScope !== "string" || params.derivedScope.length === 0) {
-    throw new import_errors9.WriteRequestError(
+    throw new import_errors10.WriteRequestError(
       "derivedScope is required; a builder may only list its own questions on a scope it may write"
     );
   }
@@ -36279,7 +36958,7 @@ async function waitForQuestion(params) {
     if (isSettled(latest.status)) return latest;
     const remaining = deadline - Date.now();
     if (remaining <= 0) {
-      throw new import_errors9.DerivativeQuestionTimeoutError(
+      throw new import_errors10.DerivativeQuestionTimeoutError(
         `Derivative question ${latest.questionId} was still ${latest.status} after ${timeoutMs}ms`,
         {
           questionId: latest.questionId,
@@ -36299,7 +36978,7 @@ async function askPersonalServer(params) {
     questionId: registered.questionId
   });
   if (registration.status !== "ready") {
-    throw new import_errors9.DerivativeQuestionFailedError(
+    throw new import_errors10.DerivativeQuestionFailedError(
       `Derivative question ${registration.questionId} failed: ${registration.error ?? "no reason given"}`,
       {
         questionId: registration.questionId,
@@ -36326,7 +37005,7 @@ async function askPersonalServer(params) {
 
 // src/protocol/derivative-status.ts
 var import_zod6 = require("zod");
-var import_errors10 = require("./errors.cjs");
+var import_errors11 = require("./errors.cjs");
 var DERIVATIVE_STATUS_PATH = "/v1/derivatives/status";
 var DEFAULT_DERIVATIVE_STATUS_TIMEOUT_MS = 12e4;
 var DEFAULT_DERIVATIVE_STATUS_POLL_INTERVAL_MS = 2e3;
@@ -36357,13 +37036,13 @@ function normalizeBaseUrl3(url) {
 function resolveFetch4(fetchFn) {
   const resolved = fetchFn ?? globalThis.fetch;
   if (resolved === void 0) {
-    throw new import_errors10.WriteRequestError("No fetch implementation available");
+    throw new import_errors11.WriteRequestError("No fetch implementation available");
   }
   return resolved;
 }
 function requireDerivedScope(derivedScope) {
   if (typeof derivedScope !== "string" || derivedScope.length === 0) {
-    throw new import_errors10.WriteRequestError("derivedScope is required");
+    throw new import_errors11.WriteRequestError("derivedScope is required");
   }
   return derivedScope;
 }
@@ -36382,7 +37061,7 @@ function sleep4(ms, signal) {
   });
 }
 function timeoutError(latest, timeoutMs) {
-  return new import_errors10.DerivativeQuestionTimeoutError(
+  return new import_errors11.DerivativeQuestionTimeoutError(
     `Derived scope ${latest.derivedScope} was still ${latest.status} after ${timeoutMs}ms`,
     {
       derivedScope: latest.derivedScope,
@@ -36395,7 +37074,7 @@ function timeoutError(latest, timeoutMs) {
 }
 function abortError2(signal) {
   const reason = signal?.reason;
-  return reason instanceof Error ? reason : new import_errors10.WriteRequestError("Derivative status wait was aborted");
+  return reason instanceof Error ? reason : new import_errors11.WriteRequestError("Derivative status wait was aborted");
 }
 function isDerivativeStatusSettled(status) {
   if (status.status === "ready") return true;
@@ -36428,7 +37107,7 @@ async function getDerivativeStatus(params) {
       }
     );
   } catch (err) {
-    throw new import_errors10.WriteTransportError(
+    throw new import_errors11.WriteTransportError(
       `Derivative status read failed: ${err instanceof Error ? err.message : String(err)}`,
       1,
       err
@@ -36443,7 +37122,7 @@ async function getDerivativeStatus(params) {
   try {
     body = await response.json();
   } catch (err) {
-    throw new import_errors10.DerivativeQuestionRejectedError(
+    throw new import_errors11.DerivativeQuestionRejectedError(
       "Derivative status response is not JSON",
       response.status,
       null,
@@ -36452,7 +37131,7 @@ async function getDerivativeStatus(params) {
   }
   const parsed = DerivativeStatusSchema.safeParse(body);
   if (!parsed.success) {
-    throw new import_errors10.DerivativeQuestionRejectedError(
+    throw new import_errors11.DerivativeQuestionRejectedError(
       "Derivative status response is not a status view",
       response.status,
       null,
@@ -36486,7 +37165,7 @@ async function waitForDerivativeStatus(params) {
 }
 
 // src/protocol/gateway.ts
-var import_errors11 = require("./errors.cjs");
+var import_errors12 = require("./errors.cjs");
 function withGrantPermissions(grant) {
   const stripped = { ...grant };
   delete stripped.permissions;
@@ -36532,7 +37211,7 @@ function createGatewayClient(baseUrl) {
   }
   async function deletedError(res, details) {
     const body = await readBody(res);
-    return new import_errors11.DataPointDeletedError(
+    return new import_errors12.DataPointDeletedError(
       `Data point ${details.dataPointId ?? details.scope ?? ""} has been deleted`,
       { ...details, deletedAt: tombstoneDeletedAt(body) }
     );
@@ -36605,7 +37284,7 @@ function createGatewayClient(baseUrl) {
       }
       const record = await unwrapEnvelope(res);
       if (!options?.includeDeleted && isDataPointTombstone(record)) {
-        throw new import_errors11.DataPointDeletedError(
+        throw new import_errors12.DataPointDeletedError(
           `Data point ${dataPointId} has been deleted`,
           {
             dataPointId,
@@ -36767,7 +37446,7 @@ function createGatewayClient(baseUrl) {
         })
       });
       if (res.status === 404) {
-        throw new import_errors11.DataPointNotFoundError(
+        throw new import_errors12.DataPointNotFoundError(
           `Data point ${dataPointId} (scope '${params.scope}') is not registered`,
           details
         );
@@ -36778,7 +37457,7 @@ function createGatewayClient(baseUrl) {
           body2["currentExpectedVersion"]
         );
         const detail = stringOrUndefined(body2["error"]) ?? res.statusText;
-        throw new import_errors11.DataPointVersionConflictError(
+        throw new import_errors12.DataPointVersionConflictError(
           `Gateway error: 409 ${detail}`,
           {
             ...details,
@@ -36908,261 +37587,6 @@ function createGatewayClient(baseUrl) {
   };
 }
 
-// src/protocol/escrow.ts
-var import_viem28 = require("viem");
-var GENERIC_PAYMENT_TYPES = {
-  GenericPayment: [
-    { name: "payerAddress", type: "address" },
-    { name: "opType", type: "string" },
-    { name: "opId", type: "bytes32" },
-    { name: "asset", type: "address" },
-    { name: "amount", type: "uint256" },
-    { name: "paymentNonce", type: "uint256" }
-  ]
-};
-function genericPaymentDomain(chainId, escrowContract) {
-  return {
-    name: "Vana Data Portability",
-    version: "1",
-    chainId,
-    verifyingContract: escrowContract
-  };
-}
-var ESCROW_DEPOSIT_ABI2 = [
-  {
-    type: "function",
-    name: "depositNative",
-    stateMutability: "payable",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: []
-  },
-  {
-    type: "function",
-    name: "depositToken",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "account", type: "address" },
-      { name: "token", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  }
-];
-var NATIVE_ASSET_ADDRESS = "0x0000000000000000000000000000000000000000";
-var EscrowWithdrawalLifecycleError = class extends Error {
-  constructor(httpStatus, result) {
-    super(result.error);
-    this.httpStatus = httpStatus;
-    this.result = result;
-  }
-  httpStatus;
-  result;
-  name = "EscrowWithdrawalLifecycleError";
-};
-var EscrowWithdrawalRejectionError = class extends Error {
-  constructor(httpStatus, result) {
-    super(result.error);
-    this.httpStatus = httpStatus;
-    this.result = result;
-  }
-  httpStatus;
-  result;
-  name = "EscrowWithdrawalRejectionError";
-};
-function createEscrowGatewayClient(baseUrl) {
-  const base = baseUrl.replace(/\/+$/, "");
-  async function throwOnError(res, context) {
-    if (!res.ok) {
-      let detail = "";
-      try {
-        const body = await res.json();
-        if (body.error) detail = `: ${body.error}`;
-      } catch {
-      }
-      throw new Error(
-        `Escrow gateway error (${context}): ${res.status} ${res.statusText}${detail}`
-      );
-    }
-  }
-  async function throwOnWithdrawError(res) {
-    if (res.ok) return;
-    let body;
-    try {
-      body = await res.json();
-    } catch {
-      throw new Error(
-        `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}`
-      );
-    }
-    if (isEscrowWithdrawalFailureResult(body)) {
-      throw new EscrowWithdrawalLifecycleError(res.status, body);
-    }
-    if (isEscrowWithdrawalRejectedResult(body)) {
-      throw new EscrowWithdrawalRejectionError(res.status, body);
-    }
-    const error = getGatewayErrorMessage(body);
-    throw new Error(
-      `Escrow gateway error (POST /v1/escrow/withdraw): ${res.status} ${res.statusText}${error ? `: ${error}` : ""}`
-    );
-  }
-  return {
-    async submitDeposit({ txHash }) {
-      const res = await fetch(`${base}/v1/escrow/deposit`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ txHash })
-      });
-      if (res.status !== 200 && res.status !== 202) {
-        await throwOnError(res, "POST /v1/escrow/deposit");
-      }
-      return res.json();
-    },
-    async getEscrowBalance(account) {
-      const res = await fetch(
-        `${base}/v1/escrow/balance?account=${encodeURIComponent(account)}`
-      );
-      await throwOnError(res, "GET /v1/escrow/balance");
-      return res.json();
-    },
-    async syncEscrowBalance(account) {
-      const res = await fetch(
-        `${base}/v1/escrow/balance/sync?account=${encodeURIComponent(account)}`,
-        { method: "POST" }
-      );
-      await throwOnError(res, "POST /v1/escrow/balance/sync");
-      return res.json();
-    },
-    async payForOp({
-      payerAddress,
-      opType,
-      opId,
-      asset,
-      amount,
-      paymentNonce,
-      signature,
-      accessRecord
-    }) {
-      const res = await fetch(`${base}/v1/escrow/pay`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Web3Signed ${signature}`
-        },
-        body: JSON.stringify({
-          payerAddress,
-          opType,
-          opId,
-          asset,
-          amount,
-          paymentNonce,
-          ...accessRecord ? { accessRecord } : {}
-        })
-      });
-      await throwOnError(res, "POST /v1/escrow/pay");
-      return res.json();
-    },
-    async withdraw({
-      account,
-      asset,
-      amount,
-      withdrawNonce,
-      deadline,
-      signature
-    }) {
-      const res = await fetch(`${base}/v1/escrow/withdraw`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Web3Signed ${signature}`
-        },
-        body: JSON.stringify({
-          account,
-          asset,
-          amount,
-          withdrawNonce,
-          deadline
-        })
-      });
-      await throwOnWithdrawError(res);
-      return res.json();
-    },
-    async getWithdrawNonce(account) {
-      const res = await fetch(
-        `${base}/v1/escrow/withdraw/nonce?account=${encodeURIComponent(account)}`,
-        { cache: "no-store" }
-      );
-      await throwOnError(res, "GET /v1/escrow/withdraw/nonce");
-      const body = await res.json();
-      if (!isWithdrawNonceResponse(body, account)) {
-        throw new Error(
-          "GET /v1/escrow/withdraw/nonce: invalid response structure"
-        );
-      }
-      return body;
-    }
-  };
-}
-function getGatewayErrorMessage(body) {
-  if (typeof body === "object" && body !== null && "error" in body && typeof body.error === "string") {
-    return body.error;
-  }
-  return void 0;
-}
-function isEscrowWithdrawalFailureResult(body) {
-  if (typeof body !== "object" || body === null) return false;
-  const value = body;
-  return value.success === false && (value.status === "retryable" || value.status === "reorged" || value.status === "failed") && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && (isHash(value.txHash) || value.txHash === null) && (!("blockNumber" in value) || isBlockNumber(value.blockNumber));
-}
-function isEscrowWithdrawalRejectedResult(body) {
-  if (typeof body !== "object" || body === null) return false;
-  const value = body;
-  return value.success === false && value.status === "rejected" && isWithdrawalRejectionCode(value.code) && typeof value.error === "string" && isAddressHex(value.account) && isAddressHex(value.asset) && isUint256Decimal(value.amount) && isUint256Decimal(value.withdrawNonce) && isUint256Decimal(value.deadline) && optionalUint256Decimal(value.balance) && optionalUint256Decimal(value.authorizedAmount) && optionalUint256Decimal(value.withdrawingAmount) && optionalUint256Decimal(value.availableAmount) && optionalUint256Decimal(value.requestedAmount) && optionalUint256Decimal(value.minimumAmount);
-}
-function isWithdrawalRejectionCode(value) {
-  return value === "below_minimum" || value === "deadline_too_far" || value === "expired" || value === "insufficient_available" || value === "stale_nonce";
-}
-function optionalUint256Decimal(value) {
-  return value === void 0 || isUint256Decimal(value);
-}
-function isAddressHex(value) {
-  return typeof value === "string" && (0, import_viem28.isHex)(value, { strict: true }) && value.length === 42;
-}
-function isHash(value) {
-  return typeof value === "string" && (0, import_viem28.isHex)(value, { strict: true }) && value.length === 66;
-}
-function isUint256Decimal(value) {
-  if (typeof value !== "string" || value.length === 0 || value.length > 78) {
-    return false;
-  }
-  if (!/^(0|[1-9]\d*)$/.test(value)) return false;
-  return BigInt(value) <= 2n ** 256n - 1n;
-}
-function isBlockNumber(value) {
-  return value === null || isUint256Decimal(value);
-}
-function isWithdrawNonceResponse(body, requestedAccount) {
-  if (typeof body !== "object" || body === null) return false;
-  const value = body;
-  if (value.success !== true) return false;
-  if (!isAddressHex(value.account)) return false;
-  if (value.account.toLowerCase() !== requestedAccount.toLowerCase())
-    return false;
-  if (typeof value.chainId !== "string") return false;
-  if (!/^(0|[1-9]\d*)$/.test(value.chainId)) return false;
-  const isLastNull = value.lastWithdrawNonce === null;
-  const lastNonceValid = isLastNull || isUint256Decimal(value.lastWithdrawNonce);
-  if (!lastNonceValid) return false;
-  if (!isUint256Decimal(value.nextWithdrawNonce)) return false;
-  if (isLastNull) {
-    return value.nextWithdrawNonce === "1";
-  }
-  const lastNonce = BigInt(value.lastWithdrawNonce);
-  const nextNonce = BigInt(value.nextWithdrawNonce);
-  const expectedNextNonce = lastNonce + 1n;
-  if (expectedNextNonce > 2n ** 256n - 1n) return false;
-  return nextNonce === expectedNextNonce;
-}
-
 // src/direct/escrow-payment.ts
 var GRANT_OP_TYPE = "grant";
 var DATA_ACCESS_OP_TYPE = "data_access";
@@ -37399,8 +37823,8 @@ async function authorizeEscrowPayment(params) {
 }
 
 // src/direct/personal-server-read.ts
-var import_errors12 = require("./direct/errors.cjs");
-var import_errors13 = require("./errors.cjs");
+var import_errors13 = require("./direct/errors.cjs");
+var import_errors14 = require("./errors.cjs");
 function asRecord2(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -37444,7 +37868,7 @@ function parseLegacyGrantOperation(params) {
   const { challengeGrantId, challengeOpId, challengeOpType, grantId } = params;
   const opType = challengeOpType ?? GRANT_OP_TYPE;
   if (opType !== GRANT_OP_TYPE) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server payment challenge used an unsupported escrow op type",
       402,
       { opType: challengeOpType }
@@ -37452,14 +37876,14 @@ function parseLegacyGrantOperation(params) {
   }
   const opId = challengeOpId ?? challengeGrantId ?? grantId;
   if (!opId || !isBytes32Hex(opId)) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server payment challenge used an invalid escrow op id",
       402,
       { opId }
     );
   }
   if (opId.toLowerCase() !== grantId.toLowerCase()) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server payment challenge did not match the requested grant",
       402,
       { opId, grantId }
@@ -37505,7 +37929,7 @@ function parseCanonicalDataAccessAccept(value) {
 function parseCanonicalDataAccessPayment(params) {
   const { body, grantId, raw } = params;
   if (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED") {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server data-access payment response was not a canonical x402 challenge",
       402
     );
@@ -37544,20 +37968,20 @@ async function parsePersonalServerPaymentRequired(res, grantId) {
     "accepts"
   );
   if (hasAcceptsEnvelope && (body.x402Version !== 1 || body.error !== "PAYMENT_REQUIRED")) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server grant payment response was not a canonical x402 challenge",
       402
     );
   }
   const accept = preferredLegacyAccept(body);
   if (hasDataAccessMarker(body) && !accept) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server data-access payment challenge was untrusted or incomplete",
       402
     );
   }
   if (hasAcceptsEnvelope && !accept) {
-    throw new import_errors12.PersonalServerReadError(
+    throw new import_errors13.PersonalServerReadError(
       "Personal Server grant payment challenge had no compatible escrow offer",
       402
     );
@@ -37575,7 +37999,7 @@ async function parsePersonalServerPaymentRequired(res, grantId) {
     const accessRecord2 = parseAccessRecord(accept.accessRecord);
     const hasAccessRecord = accept.accessRecord !== void 0;
     if (!network || !payerAddress || !isAddressHex2(payerAddress) || !opId || !isBytes32Hex(opId) || !asset || !isAddressHex2(asset) || !amount || !isUint256Decimal3(amount, true) || !paymentNonce || !isUint256Decimal3(paymentNonce, false) || !acceptAsset || acceptAsset.toLowerCase() !== asset.toLowerCase() || acceptAmount !== amount || hasAccessRecord && (!accessRecord2 || !isValidDataAccessRecord(accessRecord2) || accessRecord2.accessor.toLowerCase() !== payerAddress.toLowerCase()) || amount === "0" && !accessRecord2) {
-      throw new import_errors12.PersonalServerReadError(
+      throw new import_errors13.PersonalServerReadError(
         "Personal Server grant payment challenge was untrusted or incomplete",
         402
       );