@dignetwork/dig-sdk 0.0.1-alpha.99 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1186 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/methods.ts
+var WALLET_METHODS = [
+  "chip0002_connect",
+  "chip0002_chainId",
+  "chip0002_getPublicKeys",
+  "chip0002_getAssetCoins",
+  "chip0002_getAssetBalance",
+  "chip0002_signCoinSpends",
+  "chip0002_signMessage",
+  "chia_getAddress",
+  "chia_signMessageByAddress",
+  "chia_takeOffer"
+];
+var SIGN_METHODS = [
+  "chia_signMessageByAddress",
+  "chip0002_signMessage"
+];
+var DEFAULT_CHAIN = "chia:mainnet";
+
+// src/errors.ts
+var DIG_SDK_ERROR_CODES = Object.freeze({
+  // ---- provider / connect (provider/chia-provider.ts, provider/*) ----
+  /** WalletConnect was requested/needed but no `walletConnect` options were supplied. */
+  WC_OPTIONS_REQUIRED: "WC_OPTIONS_REQUIRED",
+  /** `mode: "injected"` (or the injected leg of `auto`) found no usable `window.chia`. */
+  NO_INJECTED_WALLET: "NO_INJECTED_WALLET",
+  /** The optional `@walletconnect/sign-client` peer dependency is not installed/usable. */
+  WC_DEPENDENCY_MISSING: "WC_DEPENDENCY_MISSING",
+  /** The active wallet session/transport does not grant the requested method. */
+  METHOD_NOT_SUPPORTED: "METHOD_NOT_SUPPORTED",
+  /** A wallet RPC timed out (e.g. Sage did not respond within the per-request timeout). */
+  WALLET_TIMEOUT: "WALLET_TIMEOUT",
+  /** The wallet returned no public keys / no key to sign with. */
+  WALLET_NO_KEYS: "WALLET_NO_KEYS",
+  // ---- read-crypto / RPC (dig-client.ts, loader.ts) ----
+  /** A content read needs a confirmed on-chain root and none was supplied/derivable. */
+  ROOT_REQUIRED: "ROOT_REQUIRED",
+  /** The resource did not decrypt+authenticate under this URN (wrong key/salt, or a decoy). */
+  DECRYPT_FAILED: "DECRYPT_FAILED",
+  /** The dig RPC could not be reached (network/transport failure). */
+  RPC_TRANSPORT: "RPC_TRANSPORT",
+  /** The dig RPC responded with an HTTP error or a JSON-RPC `error` object. */
+  RPC_ERROR: "RPC_ERROR",
+  /** The dig RPC returned a malformed / inconsistent payload (e.g. chunk-length mismatch). */
+  RPC_MALFORMED_RESPONSE: "RPC_MALFORMED_RESPONSE",
+  /** The vendored read-crypto wasm failed its SRI integrity check — fail closed. */
+  WASM_INTEGRITY: "WASM_INTEGRITY",
+  /** The read-crypto wasm could not be loaded (fetch/resolve failure). */
+  WASM_LOAD_FAILED: "WASM_LOAD_FAILED",
+  // ---- paywall / spends (paywall.ts) ----
+  /** The canonical chip35 wasm builder for this operation is unavailable (never hand-rolled). */
+  SPEND_BUILDER_UNAVAILABLE: "SPEND_BUILDER_UNAVAILABLE",
+  /** No secure random source was available to generate a payment nonce. */
+  NO_SECURE_RANDOM: "NO_SECURE_RANDOM",
+  // ---- deploy / adapters (adapters/run.ts, adapters/deploy.ts) ----
+  /** The `digstore` binary could not be spawned (not installed / not on PATH). */
+  DIGSTORE_NOT_FOUND: "DIGSTORE_NOT_FOUND",
+  /** `digstore deploy` exited non-zero. */
+  DEPLOY_FAILED: "DEPLOY_FAILED",
+  /** `digstore deploy --json` output could not be parsed into a capsule result. */
+  DEPLOY_OUTPUT_UNPARSEABLE: "DEPLOY_OUTPUT_UNPARSEABLE",
+  // ---- argument validation (shared) ----
+  /** An argument was malformed (e.g. a non-hex string, a bad URN, mutually-exclusive options). */
+  INVALID_ARGUMENT: "INVALID_ARGUMENT"
+});
+var DIG_SDK_ERROR_BRAND = "__dignetwork_dig_sdk_error__";
+var DigSdkError = class _DigSdkError extends Error {
+  constructor(code, message, context = {}, options = {}) {
+    super(message);
+    this.name = "DigSdkError";
+    this.code = code;
+    this.context = context;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    Object.defineProperty(this, DIG_SDK_ERROR_BRAND, { value: true, enumerable: false });
+    Object.setPrototypeOf(this, _DigSdkError.prototype);
+  }
+  /** A JSON-friendly view of the error: `{ code, message, context }`. */
+  toJSON() {
+    return { code: this.code, message: this.message, context: this.context };
+  }
+};
+function isDigSdkError(e, code) {
+  const branded = e instanceof DigSdkError || typeof e === "object" && e !== null && e[DIG_SDK_ERROR_BRAND] === true;
+  return branded && (code === void 0 || e.code === code);
+}
+
+// src/provider/injected.ts
+function getInjectedProvider() {
+  const g = globalThis;
+  return typeof g !== "undefined" ? g.chia : void 0;
+}
+function isInjectedAvailable(opts = {}) {
+  const p = getInjectedProvider();
+  if (!p) return false;
+  if (opts.anyChia) return typeof p.request === "function";
+  return !!p.isDIG;
+}
+var INJECTED_TOPIC = "injected";
+var InjectedTransport = class {
+  constructor(provider, chain = DEFAULT_CHAIN) {
+    this.backend = "injected";
+    this.topic = INJECTED_TOPIC;
+    this.provider = provider;
+    this.chain = chain;
+  }
+  /** Connect: ask the native wallet to approve this origin. Blocks until approved/rejected. */
+  async connect(eager = false) {
+    if (typeof this.provider.connect === "function") {
+      await this.provider.connect(eager);
+    }
+  }
+  // The native wallet implements the full canonical set (it returns Sage-shaped responses), so
+  // support is a static allowlist — no per-session negotiation as with WalletConnect.
+  supports(method) {
+    return WALLET_METHODS.includes(method);
+  }
+  async request(method, params) {
+    if (!this.supports(method)) {
+      throw new DigSdkError(
+        "METHOD_NOT_SUPPORTED",
+        `The DIG Browser wallet does not support "${method}".`,
+        { method }
+      );
+    }
+    return this.provider.request({ method, params });
+  }
+  async disconnect() {
+  }
+};
+
+// src/provider/wc-retry.ts
+function isTransientPublishError(err) {
+  const msg = (err instanceof Error ? err.message : typeof err === "string" ? err : "").toLowerCase();
+  if (!msg) return false;
+  return msg.includes("publish") || msg.includes("failed or timed out to publish") || msg.includes("websocket connection failed") || msg.includes("connection closed") || msg.includes("socket stalled") || msg.includes("request reset");
+}
+
+// src/provider/walletconnect.ts
+var WalletConnectTransport = class _WalletConnectTransport {
+  constructor(client, session, chain, requestTimeoutMs) {
+    this.backend = "walletconnect";
+    this.client = client;
+    this.topic = session.topic;
+    this.chain = chain;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  /**
+   * Initialize SignClient, open a pairing (emitting the URI via `onUri`), and resolve to a
+   * connected transport once the user approves in Sage. Requires `@walletconnect/sign-client`.
+   */
+  static async connect(options) {
+    const chain = options.chain ?? DEFAULT_CHAIN;
+    const timeout = options.requestTimeoutMs ?? 6e4;
+    const SignClient = await loadSignClient();
+    const client = await SignClient.init({
+      logger: "error",
+      projectId: options.projectId,
+      metadata: options.metadata
+    });
+    const { uri, approval } = await client.connect({
+      // optionalNamespaces ONLY — Sage rejects requiredNamespaces.
+      optionalNamespaces: {
+        chia: { methods: WALLET_METHODS, chains: [chain], events: [] }
+      }
+    });
+    if (uri && options.onUri) options.onUri(uri);
+    const session = await approval();
+    return new _WalletConnectTransport(client, session, chain, timeout);
+  }
+  /**
+   * Restore an existing session that grants a sign method (so message signing actually reaches
+   * Sage). Returns a transport or null if none qualifies. Requires `@walletconnect/sign-client`.
+   */
+  static async restore(options) {
+    const chain = options.chain ?? DEFAULT_CHAIN;
+    const timeout = options.requestTimeoutMs ?? 6e4;
+    const SignClient = await loadSignClient();
+    const client = await SignClient.init({
+      logger: "error",
+      projectId: options.projectId,
+      metadata: options.metadata
+    });
+    const sessions = client.session.getAll();
+    for (let i = sessions.length - 1; i >= 0; i--) {
+      const s = sessions[i];
+      const methods = s.namespaces?.chia?.methods ?? [];
+      if (SIGN_METHODS.some((m) => methods.includes(m))) {
+        return new _WalletConnectTransport(client, s, chain, timeout);
+      }
+    }
+    return null;
+  }
+  sessionMethods() {
+    try {
+      return this.client.session.get(this.topic)?.namespaces?.chia?.methods ?? [];
+    } catch {
+      return [];
+    }
+  }
+  // True iff the active session granted `method` (empty list = unknown ⇒ treated as granted).
+  supports(method) {
+    const m = this.sessionMethods();
+    return m.length === 0 || m.includes(method);
+  }
+  async request(method, params) {
+    if (!this.supports(method)) {
+      throw new DigSdkError(
+        "METHOD_NOT_SUPPORTED",
+        `Your wallet session does not grant "${method}". Disconnect and reconnect your wallet to refresh the session (and make sure Sage is up to date).`,
+        { method }
+      );
+    }
+    const MAX_ATTEMPTS = 3;
+    let lastErr;
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      try {
+        return await this.attempt(method, params);
+      } catch (e) {
+        lastErr = e;
+        if (i < MAX_ATTEMPTS - 1 && isTransientPublishError(e)) {
+          await sleep(1200 * (i + 1));
+          continue;
+        }
+        throw e;
+      }
+    }
+    throw lastErr;
+  }
+  attempt(method, params) {
+    let t;
+    const timeout = new Promise((_, rej) => {
+      t = setTimeout(
+        () => rej(
+          new DigSdkError(
+            "WALLET_TIMEOUT",
+            "Sage did not respond \u2014 open the Sage app and try again.",
+            { method, timeoutMs: this.requestTimeoutMs }
+          )
+        ),
+        this.requestTimeoutMs
+      );
+    });
+    return Promise.race([
+      this.client.request({ topic: this.topic, chainId: this.chain, request: { method, params } }),
+      timeout
+    ]).finally(() => clearTimeout(t));
+  }
+  async disconnect() {
+    try {
+      await this.client.disconnect({
+        topic: this.topic,
+        reason: { code: 6e3, message: "bye" }
+      });
+    } catch {
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function loadSignClient() {
+  try {
+    const mod = await import('@walletconnect/sign-client');
+    const SignClient = mod.default ?? mod;
+    if (!SignClient || typeof SignClient.init !== "function") {
+      throw new Error("unexpected @walletconnect/sign-client shape");
+    }
+    return SignClient;
+  } catch (e) {
+    throw new DigSdkError(
+      "WC_DEPENDENCY_MISSING",
+      "WalletConnect fallback requires the optional peer dependency '@walletconnect/sign-client'. Install it (npm i @walletconnect/sign-client) to use the WalletConnect\u2192Sage transport.",
+      {},
+      { cause: e }
+    );
+  }
+}
+
+// src/provider/methods.ts
+function with0x(hex) {
+  if (!hex) return hex ?? null;
+  return hex.startsWith("0x") ? hex : `0x${hex}`;
+}
+function strip0x(h) {
+  return String(h ?? "").replace(/^0x/i, "").toLowerCase();
+}
+async function getAddress(request) {
+  const resp = await request("chia_getAddress", {});
+  if (typeof resp === "string") return resp;
+  const r = resp;
+  return r?.address ?? r?.data?.address ?? null;
+}
+async function getPublicKeys(request) {
+  const resp = await request("chip0002_getPublicKeys", { limit: 500, offset: 0 });
+  if (Array.isArray(resp)) return resp;
+  const r = resp;
+  return r?.publicKeys ?? r?.public_keys ?? r?.keys ?? [];
+}
+function normalizeSig(resp) {
+  const r = resp;
+  const publicKey = typeof r === "object" && r ? r.publicKey ?? r.public_key ?? r.pubkey ?? null : null;
+  const signature = typeof r === "string" ? r : r ? r.signature ?? r.aggregatedSignature ?? r.aggregated_signature ?? null : null;
+  return { publicKey: with0x(publicKey), signature };
+}
+async function signMessage(request, supports, message, address) {
+  if (supports("chia_signMessageByAddress")) {
+    return normalizeSig(await request("chia_signMessageByAddress", { message, address }));
+  }
+  const keys = await getPublicKeys(request);
+  const publicKey = keys[0];
+  if (!publicKey)
+    throw new DigSdkError("WALLET_NO_KEYS", "Wallet returned no keys to sign with.");
+  const sig = normalizeSig(await request("chip0002_signMessage", { message, publicKey }));
+  return { publicKey: sig.publicKey ?? with0x(publicKey), signature: sig.signature };
+}
+async function signCoinSpends(request, coinSpends) {
+  const resp = await request("chip0002_signCoinSpends", { coinSpends, partialSign: true });
+  if (typeof resp === "string") return resp;
+  const r = resp;
+  return r?.signature ?? r?.aggregatedSignature ?? r?.aggregated_signature ?? "";
+}
+async function takeOffer(request, supports, offer, fee = 0) {
+  if (!supports("chia_takeOffer")) {
+    throw new DigSdkError(
+      "METHOD_NOT_SUPPORTED",
+      "Your wallet session does not support taking offers. Reconnect your wallet.",
+      { method: "chia_takeOffer" }
+    );
+  }
+  return request("chia_takeOffer", { offer, fee });
+}
+function balanceFrom(resp) {
+  const raw = resp == null ? null : typeof resp === "object" ? resp.confirmed ?? resp.spendable ?? resp.confirmedWalletBalance ?? resp.confirmed_wallet_balance ?? resp.balance ?? resp.data?.confirmed ?? null : resp;
+  if (raw == null) return null;
+  try {
+    return BigInt(raw).toString();
+  } catch {
+    return null;
+  }
+}
+async function getXchBalance(request) {
+  return balanceFrom(await request("chip0002_getAssetBalance", { type: null, assetId: null }));
+}
+async function getCatBalance(request, assetIdHex) {
+  return balanceFrom(
+    await request("chip0002_getAssetBalance", { type: "cat", assetId: strip0x(assetIdHex) })
+  );
+}
+async function getXchCoins(request, limit = 100) {
+  const resp = await request("chip0002_getAssetCoins", {
+    type: null,
+    assetId: null,
+    includedLocked: false,
+    offset: 0,
+    limit
+  });
+  return Array.isArray(resp) ? resp : resp?.coins ?? [];
+}
+async function getCatCoins(request, assetIdHex, limit = 200) {
+  const resp = await request("chip0002_getAssetCoins", {
+    type: "cat",
+    assetId: strip0x(assetIdHex),
+    includedLocked: false,
+    offset: 0,
+    limit
+  });
+  return Array.isArray(resp) ? resp : resp?.coins ?? [];
+}
+
+// src/provider/chia-provider.ts
+var ChiaProvider = class _ChiaProvider {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /** Which transport is backing this provider. */
+  get backend() {
+    return this.transport.backend;
+  }
+  /** The connected session descriptor. */
+  get session() {
+    return {
+      backend: this.transport.backend,
+      chain: this.transport.chain,
+      topic: this.transport.topic,
+      address: this.cachedAddress ?? null
+    };
+  }
+  /** True iff a method is granted by the active session/transport. */
+  supports(method) {
+    return this.transport.supports(method);
+  }
+  /** Escape hatch: issue a raw CHIP-0002 request through the active transport. */
+  request(method, params = {}) {
+    return this.transport.request(method, params);
+  }
+  /**
+   * Connect a wallet using the selection policy. With `mode: "auto"` (default) it prefers an
+   * injected DIG wallet and falls back to WalletConnect.
+   */
+  static async connect(options = {}) {
+    const mode = options.mode ?? "auto";
+    const chain = options.chain ?? DEFAULT_CHAIN;
+    const tryInjected = async () => {
+      if (!isInjectedAvailable({ anyChia: options.acceptAnyInjected })) return null;
+      const provider = getInjectedProvider();
+      const transport = new InjectedTransport(provider, chain);
+      await transport.connect();
+      return new _ChiaProvider(transport);
+    };
+    const tryWalletConnect = async () => {
+      if (!options.walletConnect) {
+        throw new DigSdkError(
+          "WC_OPTIONS_REQUIRED",
+          "WalletConnect options are required to connect via WalletConnect (pass { walletConnect: { projectId, metadata, onUri } }).",
+          { mode }
+        );
+      }
+      const transport = await WalletConnectTransport.connect({
+        ...options.walletConnect,
+        chain
+      });
+      return new _ChiaProvider(transport);
+    };
+    if (mode === "injected") {
+      const injected = await tryInjected();
+      if (!injected) {
+        throw new DigSdkError(
+          "NO_INJECTED_WALLET",
+          "No injected DIG wallet found. Open this page in the DIG Browser, or use mode 'auto'.",
+          { mode, acceptAnyInjected: !!options.acceptAnyInjected }
+        );
+      }
+      return injected;
+    }
+    if (mode === "walletconnect") return tryWalletConnect();
+    return await tryInjected() ?? await tryWalletConnect();
+  }
+  /** Wrap an already-constructed transport (advanced / restored sessions). */
+  static fromTransport(transport) {
+    return new _ChiaProvider(transport);
+  }
+  // ---- normalized CHIP-0002 surface -------------------------------------------------------------
+  /** The wallet's receive address (cached after first read). */
+  async getAddress() {
+    if (this.cachedAddress === void 0) {
+      this.cachedAddress = await getAddress((m, p) => this.transport.request(m, p));
+    }
+    return this.cachedAddress;
+  }
+  /** The wallet's (synthetic) public keys. */
+  getPublicKeys() {
+    return getPublicKeys((m, p) => this.transport.request(m, p));
+  }
+  /**
+   * Sign a UTF-8 message with the wallet BLS key. `address` defaults to the wallet's own address.
+   * Returns `{ publicKey, signature }`.
+   */
+  async signMessage(message, address) {
+    const addr = address ?? await this.getAddress() ?? "";
+    return signMessage(
+      (m, p) => this.transport.request(m, p),
+      (m) => this.transport.supports(m),
+      message,
+      addr
+    );
+  }
+  /** Sign raw CHIP-0035 coin spends (partialSign). Returns the aggregated signature hex. */
+  signCoinSpends(coinSpends) {
+    return signCoinSpends((m, p) => this.transport.request(m, p), coinSpends);
+  }
+  /** Accept a Chia offer string (e.g. an NFT offer). */
+  takeOffer(offer, fee = 0) {
+    return takeOffer(
+      (m, p) => this.transport.request(m, p),
+      (m) => this.transport.supports(m),
+      offer,
+      fee
+    );
+  }
+  /** Spendable XCH balance (mojos, string) or null. */
+  getXchBalance() {
+    return getXchBalance((m, p) => this.transport.request(m, p));
+  }
+  /** Spendable balance (base units, string) for a CAT `assetIdHex` (the tail hash), or null. */
+  getCatBalance(assetIdHex) {
+    return getCatBalance((m, p) => this.transport.request(m, p), assetIdHex);
+  }
+  /** Unspent XCH coins for funding a spend. */
+  getXchCoins(limit) {
+    return getXchCoins((m, p) => this.transport.request(m, p), limit);
+  }
+  /** Unspent CAT coins for `assetIdHex`. */
+  getCatCoins(assetIdHex, limit) {
+    return getCatCoins((m, p) => this.transport.request(m, p), assetIdHex, limit);
+  }
+  /** Disconnect the wallet (best-effort). */
+  disconnect() {
+    return this.transport.disconnect();
+  }
+};
+function connectWallet(options) {
+  return ChiaProvider.connect(options);
+}
+
+// src/paywall.ts
+function strip0x2(hex) {
+  return hex.replace(/^0x/i, "").toLowerCase();
+}
+function hexToBytes(hex) {
+  const h = strip0x2(hex);
+  if (h.length % 2 !== 0 || /[^0-9a-f]/.test(h)) {
+    throw new DigSdkError("INVALID_ARGUMENT", `invalid hex string: ${hex}`, { value: hex });
+  }
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+async function randomNonce() {
+  const out = new Uint8Array(32);
+  const webcrypto = globalThis.crypto;
+  if (webcrypto?.getRandomValues) {
+    webcrypto.getRandomValues(out);
+    return out;
+  }
+  const nodeCrypto = await import('crypto');
+  if (!nodeCrypto.webcrypto?.getRandomValues) {
+    throw new DigSdkError(
+      "NO_SECURE_RANDOM",
+      "No secure random source available to generate a payment nonce."
+    );
+  }
+  nodeCrypto.webcrypto.getRandomValues(out);
+  return out;
+}
+var Paywall = class {
+  constructor(provider, options = {}) {
+    this.provider = provider;
+    this.injectedSpends = options.spends;
+  }
+  /**
+   * Resolve the canonical monetization spends (injected, or lazily imported + `init()`ed). Memoized.
+   * This is the ONLY source of coin-spend construction in the Paywall — there is no fallback that
+   * hand-rolls a spend.
+   */
+  spends() {
+    if (this.injectedSpends) {
+      if (typeof this.injectedSpends.init === "function") this.injectedSpends.init();
+      return Promise.resolve(this.injectedSpends);
+    }
+    if (!this.spendsReady) {
+      this.spendsReady = (async () => {
+        const mod = await import(
+          /* @vite-ignore */
+          '@dignetwork/chip35-dl-coin-wasm'
+        );
+        if (typeof mod.init === "function") mod.init();
+        return mod;
+      })().catch((e) => {
+        this.spendsReady = void 0;
+        throw e;
+      });
+    }
+    return this.spendsReady;
+  }
+  /** The wallet's first synthetic public key, as bytes (the buyer key the spends are built against). */
+  async buyerKey() {
+    const keys = await this.provider.getPublicKeys();
+    const key = keys?.[0];
+    if (!key)
+      throw new DigSdkError(
+        "WALLET_NO_KEYS",
+        "Wallet returned no public keys to build the payment against."
+      );
+    return hexToBytes(key);
+  }
+  /** Resolve the 32-byte unlock nonce: explicit hex, else derived from `memo`, else random. */
+  async resolveNonce(spends, args) {
+    if (args.nonce) return hexToBytes(args.nonce);
+    if (args.memo) {
+      if (typeof spends.paymentNonce !== "function") {
+        throw new DigSdkError(
+          "SPEND_BUILDER_UNAVAILABLE",
+          "Cannot derive a nonce from `memo`: the chip35 wasm `paymentNonce` is unavailable.",
+          { builder: "paymentNonce" }
+        );
+      }
+      return spends.paymentNonce(new TextEncoder().encode(args.memo));
+    }
+    return randomNonce();
+  }
+  /**
+   * Charge the buyer (the connected wallet) `amount` to pay the dapp `owner`, then push the
+   * wasm-built coin spends to the wallet for signing. Returns the wallet signature + the receipt.
+   * Builds via the canonical wasm `buildPayment` (XCH) or `buildCatPayment` (CAT) — never hand-rolled.
+   */
+  async requestPayment(args) {
+    const spends = await this.spends();
+    const ownerPh = hexToBytes(args.owner);
+    const amount = BigInt(args.amount);
+    const nonce = await this.resolveNonce(spends, args);
+    const buyerKey = await this.buyerKey();
+    let built;
+    if (args.assetId) {
+      if (typeof spends.buildCatPayment !== "function") {
+        throw new DigSdkError(
+          "SPEND_BUILDER_UNAVAILABLE",
+          "chip35 wasm `buildCatPayment` is unavailable \u2014 cannot build a CAT payment (the Paywall never hand-rolls spends).",
+          { builder: "buildCatPayment" }
+        );
+      }
+      const cats = await this.provider.getCatCoins(strip0x2(args.assetId), args.coinLimit);
+      built = spends.buildCatPayment(buyerKey, cats, ownerPh, amount, nonce);
+    } else {
+      if (typeof spends.buildPayment !== "function") {
+        throw new DigSdkError(
+          "SPEND_BUILDER_UNAVAILABLE",
+          "chip35 wasm `buildPayment` is unavailable \u2014 cannot build an XCH payment (the Paywall never hand-rolls spends).",
+          { builder: "buildPayment" }
+        );
+      }
+      const coins = await this.provider.getXchCoins(args.coinLimit);
+      built = spends.buildPayment(buyerKey, coins, ownerPh, amount, nonce, BigInt(args.fee ?? 0));
+    }
+    const signature = await this.provider.signCoinSpends(built.coinSpends);
+    return {
+      signature,
+      receipt: built.receipt,
+      coinSpends: built.coinSpends,
+      nonce: bytesToHex(nonce)
+    };
+  }
+  /**
+   * Verify an observed on-chain payment unlocks the paywall (pay-to-unlock). Delegates to the wasm
+   * `verifyPaymentReceipt`; returns its `{ ok, error? }` verdict. `ok:true` grants access.
+   */
+  async verifyReceipt(args) {
+    const spends = await this.spends();
+    if (typeof spends.verifyPaymentReceipt !== "function") {
+      throw new DigSdkError(
+        "SPEND_BUILDER_UNAVAILABLE",
+        "chip35 wasm `verifyPaymentReceipt` is unavailable.",
+        { builder: "verifyPaymentReceipt" }
+      );
+    }
+    const asset = args.asset ?? { xch: true };
+    const requiredAsset = "assetId" in asset && asset.assetId ? { assetId: hexToBytes(asset.assetId) } : { xch: true };
+    const requireNonce = args.nonce ? hexToBytes(args.nonce) : null;
+    return spends.verifyPaymentReceipt(
+      args.observed,
+      hexToBytes(args.owner),
+      BigInt(args.minAmount),
+      requiredAsset,
+      requireNonce
+    );
+  }
+  /**
+   * Prove the `owner` holds access: gate on a specific NFT (`nft` launcher id) via the wasm
+   * `proveNftOwnership`, or on collection/creator membership (`collection` DID) via
+   * `proveCollectionMembership`. Returns `{ ok, proof?, error? }`. The caller still confirms the
+   * proof's coin is unspent on-chain for liveness.
+   */
+  async proveAccess(args) {
+    if (args.nft && args.collection) {
+      throw new DigSdkError(
+        "INVALID_ARGUMENT",
+        "proveAccess: pass either `nft` or `collection`, not both.",
+        { value: "nft+collection" }
+      );
+    }
+    const spends = await this.spends();
+    const owner = hexToBytes(args.owner);
+    if (args.collection) {
+      if (typeof spends.proveCollectionMembership !== "function") {
+        throw new DigSdkError(
+          "SPEND_BUILDER_UNAVAILABLE",
+          "chip35 wasm `proveCollectionMembership` is unavailable.",
+          { builder: "proveCollectionMembership" }
+        );
+      }
+      return spends.proveCollectionMembership(args.parentSpend, owner, hexToBytes(args.collection));
+    }
+    if (typeof spends.proveNftOwnership !== "function") {
+      throw new DigSdkError(
+        "SPEND_BUILDER_UNAVAILABLE",
+        "chip35 wasm `proveNftOwnership` is unavailable.",
+        { builder: "proveNftOwnership" }
+      );
+    }
+    const requiredNft = args.nft ? hexToBytes(args.nft) : null;
+    return spends.proveNftOwnership(args.parentSpend, owner, requiredNft);
+  }
+};
+
+// src/loader.ts
+var DIG_CLIENT_WASM_SHA256 = "ff486be806f908a2a90780e499a04dbd34e10e3b97be0470cb9ee841a1e49e77";
+var _config = {};
+var _ready = null;
+function configureWasm(config) {
+  _config = { ...config };
+  _ready = null;
+}
+var isNode = typeof process !== "undefined" && !!process.versions?.node;
+async function sha256Hex(bytes) {
+  if (isNode) {
+    const { createHash } = await import('crypto');
+    const view = bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : new Uint8Array(
+      bytes.buffer,
+      bytes.byteOffset,
+      bytes.byteLength
+    );
+    return createHash("sha256").update(view).digest("hex");
+  }
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function assertIntegrity(hex) {
+  if (_config.skipIntegrity) return;
+  if (hex !== DIG_CLIENT_WASM_SHA256) {
+    throw new DigSdkError(
+      "WASM_INTEGRITY",
+      `dig-client wasm integrity check failed \u2014 refusing to run unverified crypto (expected ${DIG_CLIENT_WASM_SHA256}, got ${hex}).`,
+      { expected: DIG_CLIENT_WASM_SHA256, actual: hex }
+    );
+  }
+}
+async function loadNode() {
+  const { readFile } = await import('fs/promises');
+  const { fileURLToPath, pathToFileURL } = await import('url');
+  const path = await import('path');
+  const here = path.dirname(fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+  const vendorDir = path.resolve(here, "..", "vendor");
+  const wasmPath = path.join(vendorDir, "dig_client_bg.wasm");
+  const gluePath = path.join(vendorDir, "dig_client.mjs");
+  const buf = await readFile(wasmPath);
+  const bytes = new Uint8Array(buf.byteLength);
+  bytes.set(buf);
+  return { glueHref: pathToFileURL(gluePath).href, bytes };
+}
+async function loadBrowser() {
+  const glueHref = _config.glueUrl ?? new URL("../vendor/dig_client.mjs", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+  let bytes;
+  if (_config.wasmBytes) {
+    bytes = _config.wasmBytes;
+  } else {
+    const wasmUrl = _config.wasmUrl ?? new URL("../vendor/dig_client_bg.wasm", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))).href;
+    const res = await fetch(wasmUrl);
+    if (!res.ok)
+      throw new DigSdkError("WASM_LOAD_FAILED", `dig-client wasm fetch failed (${res.status})`, {
+        httpStatus: res.status,
+        wasmUrl
+      });
+    bytes = await res.arrayBuffer();
+  }
+  return { glueHref, bytes };
+}
+function loadDigClientWasm() {
+  if (_ready) return _ready;
+  _ready = (async () => {
+    const { glueHref, bytes } = isNode ? await loadNode() : await loadBrowser();
+    assertIntegrity(await sha256Hex(bytes));
+    const mod = await import(
+      /* @vite-ignore */
+      glueHref
+    );
+    await mod.default({ module_or_path: bytes });
+    return mod;
+  })().catch((e) => {
+    _ready = null;
+    throw e;
+  });
+  return _ready;
+}
+
+// src/urn.ts
+var URN_RE = /^urn:dig:chia:([0-9a-fA-F]{64})(?::([0-9a-fA-F]{64}))?\/(.+?)(?:\?salt=([0-9a-fA-F]+))?$/;
+function parseUrn(raw) {
+  const s = String(raw ?? "").trim();
+  const m = URN_RE.exec(s);
+  if (!m) {
+    throw new DigSdkError(
+      "INVALID_ARGUMENT",
+      "Not a valid dig URN (expected urn:dig:chia:<store-id>[:<root>]/<path>[?salt=<hex>]).",
+      { value: s, expected: "urn:dig:chia:<store-id>[:<root>]/<path>[?salt=<hex>]" }
+    );
+  }
+  return {
+    storeId: m[1].toLowerCase(),
+    root: m[2] ? m[2].toLowerCase() : null,
+    resourceKey: m[3],
+    salt: m[4] ? m[4].toLowerCase() : null
+  };
+}
+function isUrn(raw) {
+  try {
+    parseUrn(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reconstructUrn(storeId, resourceKey) {
+  const key = resourceKey && resourceKey.length > 0 ? resourceKey : "index.html";
+  return `urn:dig:chia:${storeId.toLowerCase()}/${key}`;
+}
+function reconstructUrnWithRoot(storeId, root, resourceKey) {
+  const key = resourceKey && resourceKey.length > 0 ? resourceKey : "index.html";
+  return `urn:dig:chia:${storeId.toLowerCase()}:${root.toLowerCase()}/${key}`;
+}
+
+// src/dig-client.ts
+var DEFAULT_RPC = "https://rpc.dig.net";
+var RPC_CHUNK_BYTES = 3 * 1024 * 1024;
+function b64ToBytes(b64) {
+  if (typeof atob === "function") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return new Uint8Array(globalThis.Buffer.from(b64, "base64"));
+}
+var DigClient = class {
+  constructor(options = {}) {
+    this.rpc = options.rpc ?? DEFAULT_RPC;
+    this.fetchImpl = options.fetch ?? (typeof fetch === "function" ? fetch.bind(globalThis) : undefinedFetch());
+  }
+  /** Load (and SRI-verify) the read-crypto wasm. Exposed for callers that want the raw functions. */
+  async wasm() {
+    return loadDigClientWasm();
+  }
+  /** `retrieval_key = SHA-256(canonical rootless URN)`, lowercase hex. */
+  async retrievalKey(storeId, resourceKey) {
+    return (await this.wasm()).retrievalKey(storeId, resourceKey);
+  }
+  /** Derive the per-URN AES-256-GCM-SIV key, lowercase hex. `salt` for a private store. */
+  async deriveKey(storeId, resourceKey, salt) {
+    return (await this.wasm()).deriveKey(storeId, resourceKey, salt ?? void 0);
+  }
+  /** Verify served `ciphertext` is included under `root` via the base64 merkle `proof`. */
+  async verifyInclusion(ciphertext, proof, root) {
+    return (await this.wasm()).verifyInclusion(ciphertext, proof, root);
+  }
+  /** Reconstruct the canonical rootless URN whose SHA-256 is the retrieval key. */
+  async reconstructUrn(storeId, resourceKey) {
+    return (await this.wasm()).reconstructUrn(storeId, resourceKey);
+  }
+  /**
+   * Derive, client-side, the two root-independent keys a URN maps to (retrieval + decryption).
+   * Nothing is sent to the network — pure local derivation via the wasm.
+   */
+  async deriveUrnKeys(input) {
+    const parsed = parseUrn(input.urn);
+    const wasm = await this.wasm();
+    const effSalt = input.salt ?? parsed.salt ?? void 0;
+    return {
+      storeId: parsed.storeId,
+      root: parsed.root,
+      resourceKey: parsed.resourceKey,
+      salt: effSalt ?? null,
+      retrievalKey: wasm.retrievalKey(parsed.storeId, parsed.resourceKey),
+      decryptionKey: wasm.deriveKey(parsed.storeId, parsed.resourceKey, effSalt)
+    };
+  }
+  /**
+   * Fetch + verify + decrypt one resource by URN. `root` is the on-chain generation root to verify
+   * against (resolved by the caller from the chain); when omitted, the root embedded in the URN is
+   * used. Returns the bytes plus advisory `verified`/`decrypted` flags. NEVER throws "not found"
+   * (presence is unknowable) — it throws only on a transport failure.
+   */
+  async read(input, opts = {}) {
+    const parsed = parseUrn(input.urn);
+    const effSalt = input.salt ?? parsed.salt ?? null;
+    const effRoot = input.root ?? parsed.root ?? null;
+    if (!effRoot) {
+      throw new DigSdkError(
+        "ROOT_REQUIRED",
+        "a confirmed on-chain root is required to read content (pass { root } or use a root-pinned URN)",
+        { urn: input.urn }
+      );
+    }
+    return this.readResource(
+      { storeId: parsed.storeId, resourceKey: parsed.resourceKey, root: effRoot, salt: effSalt },
+      opts
+    );
+  }
+  /** As `read`, but decoding the plaintext to a UTF-8 string when it decrypts (else throws). */
+  async readText(input, opts = {}) {
+    const r = await this.read(input, opts);
+    if (!r.decrypted) {
+      throw new DigSdkError(
+        "DECRYPT_FAILED",
+        "resource did not decrypt under this URN \u2014 wrong store/key/salt, or a decoy response",
+        { urn: input.urn }
+      );
+    }
+    return new TextDecoder().decode(r.bytes);
+  }
+  /**
+   * Read by explicit (storeId, resourceKey, root, salt) rather than a URN string. The oblivious
+   * download primitive the URN read is built on.
+   */
+  async readResource(input, opts = {}) {
+    const rpc = opts.rpc ?? this.rpc;
+    const wasm = await this.wasm();
+    const rk = wasm.retrievalKey(input.storeId, input.resourceKey);
+    const { ciphertext, proof, chunkLens } = await this.fetchCiphertext(
+      input.storeId,
+      rk,
+      input.root,
+      rpc
+    );
+    let verified = false;
+    try {
+      verified = !!wasm.verifyInclusion(ciphertext, proof, input.root);
+    } catch {
+      verified = false;
+    }
+    const keyHex = wasm.deriveKey(input.storeId, input.resourceKey, input.salt ?? void 0);
+    try {
+      const bytes = decryptResourceChunks(wasm, keyHex, ciphertext, chunkLens);
+      return {
+        storeId: input.storeId,
+        root: input.root,
+        resourceKey: input.resourceKey,
+        salt: input.salt ?? null,
+        bytes,
+        verified,
+        decrypted: true
+      };
+    } catch {
+      return {
+        storeId: input.storeId,
+        root: input.root,
+        resourceKey: input.resourceKey,
+        salt: input.salt ?? null,
+        bytes: ciphertext,
+        verified,
+        decrypted: false
+      };
+    }
+  }
+  /**
+   * Read a collection's public, owner-independent facts (creator DID, item count, uniform royalty)
+   * from the dig RPC (`dig.getCollection`). The collection's item set is its NFT launcher ids — the
+   * authoritative, owner-independent anchor the mint produced (a DID-attributed NFT is hinted to its
+   * OWNER at mint, not to the creator DID, so launcher ids — not the DID — are the read key). Pass
+   * the optional `did` to have it echoed back and recorded as the declared creator.
+   *
+   * No wallet, no read-crypto wasm — a plain JSON-RPC read. Throws a coded {@link DigSdkError} on a
+   * transport/RPC failure (never a "not found": an empty/partly-confirmed set just resolves to fewer
+   * items).
+   *
+   * @example
+   * const meta = await dig.getCollection({ launcherIds: ["ab…", "cd…"], did: "ef…" });
+   * console.log(meta.resolved_count, meta.royalty_basis_points);
+   */
+  async getCollection(input, opts = {}) {
+    const rpc = opts.rpc ?? this.rpc;
+    const params = { launcher_ids: input.launcherIds };
+    if (input.did) params.did = input.did;
+    const r = await this.rpcCall(rpc, "dig.getCollection", params);
+    if (!r)
+      throw new DigSdkError(
+        "RPC_MALFORMED_RESPONSE",
+        "The content network returned no collection facts for this request.",
+        { rpcMethod: "dig.getCollection" }
+      );
+    return r;
+  }
+  /**
+   * Read a deterministic, paginated page of a collection's items (`dig.listCollectionItems`), each
+   * resolved to its CURRENT on-chain state — current owner, royalty, and CHIP-0007 metadata — by the
+   * RPC walking the singleton lineage forward to the live tip (so the owner is never the stale
+   * mint-time owner). Items come back in the input launcher-id order. `limit` is clamped to the
+   * server cap (200); `offset` defaults to 0.
+   *
+   * Throws a coded {@link DigSdkError} on a transport/RPC failure.
+   *
+   * @example
+   * let page = await dig.listCollectionItems({ launcherIds, limit: 50 });
+   * for (const item of page.items) console.log(item.launcher_id, item.owner_puzzle_hash);
+   * // page.next_offset is null on the last page.
+   */
+  async listCollectionItems(input, opts = {}) {
+    const rpc = opts.rpc ?? this.rpc;
+    const params = { launcher_ids: input.launcherIds };
+    if (input.offset !== void 0) params.offset = input.offset;
+    if (input.limit !== void 0) params.limit = input.limit;
+    const r = await this.rpcCall(rpc, "dig.listCollectionItems", params);
+    if (!r)
+      throw new DigSdkError(
+        "RPC_MALFORMED_RESPONSE",
+        "The content network returned no collection items for this request.",
+        { rpcMethod: "dig.listCollectionItems" }
+      );
+    return r;
+  }
+  // Stream the FULL ciphertext for a resource from the RPC by retrieval key, reassembling 3-MiB
+  // chunks. A null result is a TRANSPORT failure, never a presence judgment.
+  async fetchCiphertext(storeId, rk, root, rpc) {
+    let offset = 0;
+    let total = null;
+    let buf = null;
+    let proof = "";
+    let chunkLens = null;
+    for (; ; ) {
+      const r = await this.rpcCall(rpc, "dig.getContent", {
+        store_id: storeId,
+        root,
+        retrieval_key: rk,
+        offset,
+        length: RPC_CHUNK_BYTES
+      });
+      if (!r)
+        throw new DigSdkError(
+          "RPC_MALFORMED_RESPONSE",
+          "The content network returned no data for this request.",
+          { rpcMethod: "dig.getContent" }
+        );
+      if (total === null) {
+        total = r.total_length >>> 0;
+        buf = new Uint8Array(total);
+      }
+      if (chunkLens === null && Array.isArray(r.chunk_lens)) {
+        chunkLens = r.chunk_lens.map((n) => n >>> 0);
+      }
+      const chunk = b64ToBytes(r.ciphertext ?? "");
+      const at = r.offset >>> 0;
+      buf.set(chunk.subarray(0, Math.max(0, Math.min(chunk.length, total - at))), at);
+      if (r.inclusion_proof) proof = r.inclusion_proof;
+      if (r.complete || r.next_offset == null) break;
+      offset = r.next_offset >>> 0;
+    }
+    return { ciphertext: buf ?? new Uint8Array(0), proof, chunkLens };
+  }
+  // One JSON-RPC 2.0 call. Throws a coded DigSdkError on transport failure (RPC_TRANSPORT) or a
+  // JSON-RPC/HTTP error (RPC_ERROR, carrying rpcMethod/httpStatus/rpcCode context); returns `result`.
+  async rpcCall(rpc, method, params) {
+    let res;
+    try {
+      res = await this.fetchImpl(rpc, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+      });
+    } catch (e) {
+      throw new DigSdkError(
+        "RPC_TRANSPORT",
+        "Could not reach the content network. Check your connection and try again.",
+        { rpcMethod: method },
+        { cause: e }
+      );
+    }
+    if (!res.ok)
+      throw new DigSdkError("RPC_ERROR", `dig RPC ${method} failed (${res.status})`, {
+        rpcMethod: method,
+        httpStatus: res.status
+      });
+    const json = await res.json();
+    if (json && json.error)
+      throw new DigSdkError(
+        "RPC_ERROR",
+        `dig RPC ${method}: ${json.error.message ?? "error"}`,
+        { rpcMethod: method, rpcCode: json.error.code }
+      );
+    return json ? json.result ?? null : null;
+  }
+};
+function decryptResourceChunks(wasm, keyHex, ciphertext, chunkLens) {
+  const lens = chunkLens && chunkLens.length ? chunkLens : [ciphertext.length];
+  const total = lens.reduce((a, n) => a + n, 0);
+  if (total !== ciphertext.length) {
+    throw new DigSdkError(
+      "RPC_MALFORMED_RESPONSE",
+      "served ciphertext length does not match chunk lengths",
+      { rpcMethod: "dig.getContent", expected: String(total), actual: String(ciphertext.length) }
+    );
+  }
+  if (lens.length === 1) return wasm.decryptChunk(keyHex, ciphertext);
+  const parts = [];
+  let p = 0;
+  for (const len of lens) {
+    parts.push(wasm.decryptChunk(keyHex, ciphertext.subarray(p, p + len)));
+    p += len;
+  }
+  const out = new Uint8Array(parts.reduce((a, x) => a + x.length, 0));
+  let q = 0;
+  for (const part of parts) {
+    out.set(part, q);
+    q += part.length;
+  }
+  return out;
+}
+function undefinedFetch() {
+  return (() => {
+    throw new DigSdkError(
+      "INVALID_ARGUMENT",
+      "No global fetch available. Pass { fetch } to DigClient (Node < 18 needs a fetch polyfill)."
+    );
+  });
+}
+
+// src/capabilities.ts
+var SDK_VERSION = "0.2.0" ;
+var MODULES = Object.freeze([
+  {
+    name: "ChiaProvider",
+    summary: "Unified Chia wallet surface \u2014 prefers the injected DIG Browser wallet, falls back to WalletConnect\u2192Sage.",
+    entry: "@dignetwork/dig-sdk"
+  },
+  {
+    name: "DigClient",
+    summary: "Read-crypto: derive URN keys, verify inclusion against an on-chain root, and decrypt content from the dig RPC.",
+    entry: "@dignetwork/dig-sdk"
+  },
+  {
+    name: "Paywall",
+    summary: "Pay-to-unlock helper composing ChiaProvider with the canonical chip35 monetization spends (payment / receipt / NFT+collection gating).",
+    entry: "@dignetwork/dig-sdk"
+  },
+  {
+    name: "spend",
+    summary: "The canonical CHIP-0035 spend builder (@dignetwork/chip35-dl-coin-wasm), re-exported verbatim.",
+    entry: "@dignetwork/dig-sdk/spend"
+  },
+  {
+    name: "adapters",
+    summary: "Framework deploy glue (Vite + Next): dev window.chia shim and `digstore deploy` runner.",
+    entry: "@dignetwork/dig-sdk/adapters"
+  }
+]);
+function capabilities() {
+  return {
+    name: "@dignetwork/dig-sdk",
+    version: SDK_VERSION,
+    modules: MODULES,
+    walletMethods: [...WALLET_METHODS],
+    signMethods: [...SIGN_METHODS],
+    transports: ["injected", "walletconnect"],
+    chains: [DEFAULT_CHAIN],
+    defaultRpc: DEFAULT_RPC,
+    readCryptoWasmSha256: DIG_CLIENT_WASM_SHA256,
+    errorCodes: Object.values(DIG_SDK_ERROR_CODES)
+  };
+}
+var describe = capabilities;
+
+exports.ChiaProvider = ChiaProvider;
+exports.DEFAULT_CHAIN = DEFAULT_CHAIN;
+exports.DEFAULT_RPC = DEFAULT_RPC;
+exports.DIG_CLIENT_WASM_SHA256 = DIG_CLIENT_WASM_SHA256;
+exports.DIG_SDK_ERROR_CODES = DIG_SDK_ERROR_CODES;
+exports.DigClient = DigClient;
+exports.DigSdkError = DigSdkError;
+exports.INJECTED_TOPIC = INJECTED_TOPIC;
+exports.InjectedTransport = InjectedTransport;
+exports.Paywall = Paywall;
+exports.SDK_VERSION = SDK_VERSION;
+exports.SIGN_METHODS = SIGN_METHODS;
+exports.WALLET_METHODS = WALLET_METHODS;
+exports.WalletConnectTransport = WalletConnectTransport;
+exports.capabilities = capabilities;
+exports.configureWasm = configureWasm;
+exports.connectWallet = connectWallet;
+exports.describe = describe;
+exports.getInjectedProvider = getInjectedProvider;
+exports.isDigSdkError = isDigSdkError;
+exports.isInjectedAvailable = isInjectedAvailable;
+exports.isTransientPublishError = isTransientPublishError;
+exports.isUrn = isUrn;
+exports.loadDigClientWasm = loadDigClientWasm;
+exports.parseUrn = parseUrn;
+exports.reconstructUrn = reconstructUrn;
+exports.reconstructUrnWithRoot = reconstructUrnWithRoot;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map