@donezone/client 0.1.50 → 0.1.55

package/dist/index.js

@@ -1,6 +1,1219 @@
-export { DoneBackendClient } from "./client";
-export { Done, DoneContractClient } from "./done";
-export { DoneRequest } from "./done";
-export { createPasskeyEnvelopeBuilder, createSessionEnvelopeBuilder, } from "./auth";
-export { CURRENT_ENVELOPE_VERSION, buildEnvelope, createDevEnvelopeBuilder, decodeSignature, encodeSignature, signDocBytes, signDocDigest, toSignDoc, } from "./envelope";
-export { buildQueryMessage, buildTransactionMessage } from "./messages";
+// src/envelope-builder.ts
+var CURRENT_ENVELOPE_VERSION = 1;
+function normalizeMetadata(metadata) {
+  if (!metadata) return void 0;
+  const normalized = {};
+  if (metadata.trace_id) normalized.trace_id = metadata.trace_id;
+  if (metadata.memo) normalized.memo = metadata.memo;
+  if (typeof metadata.gas_limit === "number") normalized.gas_limit = metadata.gas_limit;
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function toSignDoc(envelope) {
+  const metadata = normalizeMetadata(envelope.metadata);
+  return {
+    version: envelope.version ?? CURRENT_ENVELOPE_VERSION,
+    user_id: envelope.user_id,
+    session_id: envelope.session_id,
+    msgs: envelope.msgs.map((msg) => cloneMsg(msg)),
+    nonce: envelope.nonce,
+    expires_at: envelope.expires_at,
+    role: envelope.role,
+    agent: envelope.agent,
+    forwarder: envelope.forwarder,
+    metadata
+  };
+}
+function buildEnvelope(draft) {
+  if (!Array.isArray(draft.msgs) || draft.msgs.length === 0) {
+    throw new Error("envelope requires at least one message");
+  }
+  const version = draft.version ?? CURRENT_ENVELOPE_VERSION;
+  const metadata = normalizeMetadata(draft.metadata);
+  return {
+    version,
+    user_id: draft.user_id,
+    session_id: draft.session_id,
+    msgs: draft.msgs.map((msg) => cloneMsg(msg)),
+    nonce: draft.nonce,
+    expires_at: draft.expires_at,
+    role: draft.role,
+    agent: draft.agent,
+    forwarder: draft.forwarder,
+    signatures: draft.signatures ? { ...draft.signatures } : {},
+    metadata
+  };
+}
+function signDocBytes(signDoc) {
+  const json = canonicalStringify(signDoc);
+  return new TextEncoder().encode(json);
+}
+function cloneMsg(msg) {
+  return structuredClone(msg);
+}
+function canonicalStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (val instanceof Map) {
+      return Object.fromEntries(Array.from(val.entries()).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+    }
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const entries = Object.entries(val).sort(
+        ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+      );
+      return entries.reduce((acc, [key, entry]) => {
+        acc[key] = entry;
+        return acc;
+      }, {});
+    }
+    return val;
+  });
+}
+function createDevEnvelopeBuilder(options = {}) {
+  const userId = options.userId ?? "dev";
+  const ttlSeconds = options.ttlSeconds ?? 300;
+  return (ctx) => {
+    const envelope = buildEnvelope({
+      user_id: userId,
+      msgs: [ctx.msg],
+      nonce: Date.now(),
+      expires_at: Math.floor(Date.now() / 1e3) + ttlSeconds,
+      role: "Passkey",
+      signatures: {}
+    });
+    return { envelope };
+  };
+}
+
+// src/messages.ts
+function buildTransactionMessage(contractAddr, call, options = {}) {
+  const payload = normalizeCall(call);
+  const msg = { msg: payload };
+  const funds = normalizeFunds(options.funds);
+  return {
+    wasm: {
+      execute: {
+        contract_addr: contractAddr,
+        msg,
+        funds: funds && funds.length > 0 ? funds : void 0
+      }
+    }
+  };
+}
+function buildQueryMessage(call) {
+  return { msg: normalizeCall(call) };
+}
+function normalizeCall(call) {
+  if (!call.path || !call.path.startsWith("/")) {
+    throw new Error("contract call path must start with '/'");
+  }
+  const payload = { path: call.path };
+  if (call.query instanceof URLSearchParams) {
+    payload.query = Object.fromEntries(Array.from(call.query));
+  } else if (call.query) {
+    payload.query = call.query;
+  }
+  if (call.body !== void 0) {
+    payload.body = call.body;
+  }
+  return payload;
+}
+function normalizeFunds(funds) {
+  if (!funds) return void 0;
+  if (Array.isArray(funds)) {
+    if (funds.length === 0) return void 0;
+    return funds.map((coin) => ({ denom: coin.denom, amount: coin.amount }));
+  }
+  const entries = Object.entries(funds);
+  if (entries.length === 0) return void 0;
+  return entries.map(([denom, amount]) => ({ denom, amount: String(amount) }));
+}
+
+// src/client.ts
+var DoneBackendClient = class {
+  baseUrl;
+  fetchImpl;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    const candidate = config.fetch ?? fetch;
+    if (typeof candidate !== "function") {
+      throw new Error("fetch implementation is not available; configure Done with a fetch implementation via Done.config");
+    }
+    this.fetchImpl = candidate.bind(globalThis);
+  }
+  contract(address) {
+    return new DoneContractHandle(this, address);
+  }
+  buildEnvelope(draft) {
+    return buildEnvelope(draft);
+  }
+  async executeEnvelope(envelope, options = {}, init = {}) {
+    const body = {
+      envelope,
+      passkey: options.passkey,
+      memo: options.memo ?? envelope.metadata?.memo
+    };
+    const { headers: initHeaders, signal: initSignal, method: initMethod, body: _ignoredBody, ...rest } = init;
+    const headers = new Headers(initHeaders ?? {});
+    headers.set("content-type", "application/json");
+    const res = await this.fetchImpl(`${this.baseUrl}/tx`, {
+      ...rest,
+      method: initMethod ?? "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: initSignal ?? options.signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`tx failed with ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  async publishCode(request, init = {}) {
+    const { contract, script, msg } = request;
+    const { headers: initHeaders, method: initMethod, body: _ignoredBody, ...rest } = init;
+    const headers = new Headers(initHeaders ?? {});
+    headers.set("content-type", "application/json");
+    const payload = { script };
+    if (Object.prototype.hasOwnProperty.call(request, "msg")) {
+      payload.msg = msg;
+    }
+    const res = await this.fetchImpl(`${this.baseUrl}/contracts/${contract}/publish`, {
+      ...rest,
+      method: initMethod ?? "POST",
+      headers,
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`publish failed with ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  async queryContractRaw(address, call, init = {}) {
+    const message = buildQueryMessage(call);
+    const params = new URLSearchParams();
+    params.set("msg", JSON.stringify(message));
+    const { method: initMethod, ...rest } = init;
+    return this.fetchImpl(`${this.baseUrl}/query/${address}?${params}`, {
+      method: initMethod ?? "GET",
+      ...rest
+    });
+  }
+  async queryContract(address, call, init = {}) {
+    const res = await this.queryContractRaw(address, call, init);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`query failed with ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  async getAgentQuota(userId, agent) {
+    const res = await this.fetchImpl(`${this.baseUrl}/quota/agent/${userId}/${agent}`);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`agent quota failed with ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+  async getForwarderQuota(address) {
+    const res = await this.fetchImpl(`${this.baseUrl}/quota/forwarder/${address}`);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`forwarder quota failed with ${res.status}: ${text}`);
+    }
+    return res.json();
+  }
+};
+var DoneContractHandle = class {
+  constructor(backend, address) {
+    this.backend = backend;
+    this.address = address;
+  }
+  transaction(path, options = {}) {
+    const call = {
+      path,
+      query: options.query,
+      body: options.body
+    };
+    const msg = buildTransactionMessage(this.address, call, options);
+    const metadata = metadataFromOptions(options);
+    return { msg, metadata };
+  }
+  async query(path, options = {}) {
+    const call = {
+      path,
+      query: options.query,
+      body: options.body
+    };
+    return this.backend.queryContract(this.address, call);
+  }
+  publishCode(request, init = {}) {
+    return this.backend.publishCode(
+      {
+        contract: this.address,
+        script: request.script,
+        msg: request.msg
+      },
+      init
+    );
+  }
+};
+function metadataFromOptions(options) {
+  const metadata = {};
+  if (options.traceId) metadata.trace_id = options.traceId;
+  if (options.memo) metadata.memo = options.memo;
+  if (typeof options.gasLimit === "number") metadata.gas_limit = options.gasLimit;
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+
+// ../../node_modules/@noble/hashes/esm/_assert.js
+function bytes(b, ...lengths) {
+  if (!(b instanceof Uint8Array))
+    throw new Error("Expected Uint8Array");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+function exists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function output(out, instance) {
+  bytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+  }
+}
+
+// ../../node_modules/@noble/hashes/esm/utils.js
+var u8a = (a) => a instanceof Uint8Array;
+var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var rotr = (word, shift) => word << 32 - shift | word >>> shift;
+var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!isLE)
+  throw new Error("Non little-endian hardware is not supported");
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  if (!u8a(data))
+    throw new Error(`expected Uint8Array, got ${typeof data}`);
+  return data;
+}
+var Hash = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+var toStr = {}.toString;
+function wrapConstructor(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/@noble/hashes/esm/_sha2.js
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
+}
+var SHA2 = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    super();
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    exists(this);
+    const { view, buffer, blockLen } = this;
+    data = toBytes(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    exists(this);
+    output(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    this.buffer.subarray(pos).fill(0);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor());
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.length = length;
+    to.pos = pos;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+};
+
+// ../../node_modules/@noble/hashes/esm/sha256.js
+var Chi = (a, b, c) => a & b ^ ~a & c;
+var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
+var SHA256_K = /* @__PURE__ */ new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var IV = /* @__PURE__ */ new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+var SHA256 = class extends SHA2 {
+  constructor() {
+    super(64, 32, 8, false);
+    this.A = IV[0] | 0;
+    this.B = IV[1] | 0;
+    this.C = IV[2] | 0;
+    this.D = IV[3] | 0;
+    this.E = IV[4] | 0;
+    this.F = IV[5] | 0;
+    this.G = IV[6] | 0;
+    this.H = IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  // prettier-ignore
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0; i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    SHA256_W.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    this.buffer.fill(0);
+  }
+};
+var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
+// src/envelope-crypto.ts
+function signDocDigest(signDoc) {
+  const bytes2 = signDocBytes(signDoc);
+  return sha256(bytes2);
+}
+function encodeSignature(signature) {
+  const nodeBuffer = globalThis.Buffer;
+  if (nodeBuffer) {
+    return nodeBuffer.from(signature).toString("base64");
+  }
+  let result = "";
+  for (const byte of signature) {
+    result += String.fromCharCode(byte);
+  }
+  return btoa(result);
+}
+function decodeSignature(signature) {
+  const nodeBuffer = globalThis.Buffer;
+  if (nodeBuffer) {
+    return nodeBuffer.from(signature, "base64");
+  }
+  const binary = atob(signature);
+  const bytes2 = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes2[i] = binary.charCodeAt(i);
+  }
+  return bytes2;
+}
+
+// src/done.ts
+var DoneContractClient = class {
+  backend;
+  address;
+  buildEnvelopeFn;
+  eventSourceFactory;
+  eventsPath;
+  defaultMetadata;
+  constructor(config) {
+    this.backend = new DoneBackendClient({ baseUrl: config.baseUrl, fetch: config.fetch });
+    this.address = config.address;
+    this.buildEnvelopeFn = config.buildEnvelope;
+    this.eventSourceFactory = config.eventSource;
+    this.eventsPath = config.eventsPath ?? "/events";
+    this.defaultMetadata = config.defaultMetadata;
+  }
+  get(path, request = {}, init = {}) {
+    const promise = this.fetchQuery(path, request, init);
+    return new DoneRequest(promise);
+  }
+  async query(path, request = {}, init = {}) {
+    const response = await this.fetchQuery(path, request, init);
+    return response.json();
+  }
+  async post(path, request = {}, init = {}) {
+    return this.execute(path, request, init);
+  }
+  async run(path, request = {}, init = {}) {
+    return this.execute(path, request, init);
+  }
+  async execute(path, request = {}, init = {}) {
+    if (!this.buildEnvelopeFn) {
+      throw new Error("execute requires a buildEnvelope function in contract config");
+    }
+    const normalizedCall = {
+      path,
+      query: request.query,
+      body: request.body
+    };
+    const transactionMsg = buildTransactionMessage(
+      this.address,
+      normalizedCall,
+      request
+    );
+    const metadata = mergeMetadata(this.defaultMetadata, request.metadata, { trace_id: request.traceId, memo: request.memo, gas_limit: request.gasLimit });
+    const buildContext = {
+      msg: transactionMsg,
+      metadata,
+      path,
+      request
+    };
+    const buildResult = await this.buildEnvelopeFn(buildContext);
+    if (metadata) {
+      buildResult.envelope.metadata = buildResult.envelope.metadata ?? metadata;
+    }
+    const executeOptions = mergeExecuteOptions(buildResult.options, {
+      memo: request.memo,
+      passkey: request.passkey,
+      signal: request.signal
+    });
+    return this.backend.executeEnvelope(buildResult.envelope, executeOptions, init);
+  }
+  transaction(path, request = {}) {
+    const normalizedCall = {
+      path,
+      query: request.query,
+      body: request.body
+    };
+    const msg = buildTransactionMessage(this.address, normalizedCall, request);
+    const metadata = mergeMetadata(this.defaultMetadata, request.metadata, {
+      trace_id: request.traceId,
+      memo: request.memo,
+      gas_limit: request.gasLimit
+    });
+    return { msg, metadata };
+  }
+  subscribe(topic, handler, options = {}) {
+    const factory = this.eventSourceFactory ?? defaultEventSourceFactory;
+    const eventsBase = buildEventsUrl(this.backend.baseUrl, this.eventsPath);
+    const encodedTopic = Array.isArray(topic) ? JSON.stringify(topic) : topic;
+    const url = `${eventsBase}?topic=${encodeURIComponent(encodedTopic)}`;
+    const source = factory(url);
+    const messageListener = (event) => {
+      if (options.rawEvent) {
+        handler(event);
+        return;
+      }
+      const data = event.data;
+      try {
+        handler(JSON.parse(data));
+      } catch {
+        handler(data);
+      }
+    };
+    if (typeof source.addEventListener === "function") {
+      source.addEventListener("message", messageListener);
+    } else {
+      source.onmessage = messageListener;
+    }
+    if (options.onError) {
+      if (typeof source.addEventListener === "function") {
+        source.addEventListener("error", options.onError);
+      } else {
+        source.onerror = options.onError;
+      }
+    }
+    const cleanup = () => {
+      if (typeof source.removeEventListener === "function") {
+        source.removeEventListener("message", messageListener);
+        if (options.onError) {
+          source.removeEventListener("error", options.onError);
+        }
+      }
+      source.close();
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        cleanup();
+      } else {
+        options.signal.addEventListener("abort", cleanup, { once: true });
+      }
+    }
+    return cleanup;
+  }
+  publishCode(request, init = {}) {
+    return this.backend.publishCode(
+      {
+        contract: this.address,
+        script: request.script,
+        msg: request.msg
+      },
+      init
+    );
+  }
+  buildEnvelope(draft) {
+    return buildEnvelope(draft);
+  }
+  signDocDigest(envelope) {
+    return signDocDigest(toSignDoc(envelope));
+  }
+  get baseUrl() {
+    return this.backend.baseUrl;
+  }
+  async fetchQuery(path, request, init = {}) {
+    const call = { path, query: request.query, body: request.body };
+    return this.backend.queryContractRaw(this.address, call, init);
+  }
+};
+var DoneRequest = class {
+  constructor(promise) {
+    this.promise = promise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.promise.finally(onfinally);
+  }
+  json() {
+    return this.promise.then((response) => response.json());
+  }
+  text() {
+    return this.promise.then((response) => response.text());
+  }
+  arrayBuffer() {
+    return this.promise.then((response) => response.arrayBuffer());
+  }
+};
+function mergeMetadata(...entries) {
+  const merged = {};
+  for (const entry of entries) {
+    if (!entry) continue;
+    if (entry.trace_id) merged.trace_id = entry.trace_id;
+    if (entry.memo) merged.memo = entry.memo;
+    if (typeof entry.gas_limit === "number") merged.gas_limit = entry.gas_limit;
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeExecuteOptions(base, overrides) {
+  if (!base && !overrides.memo && !overrides.passkey && !overrides.signal) {
+    return void 0;
+  }
+  return {
+    memo: overrides.memo ?? base?.memo,
+    passkey: overrides.passkey ?? base?.passkey,
+    signal: overrides.signal ?? base?.signal
+  };
+}
+function defaultEventSourceFactory(url) {
+  if (typeof EventSource === "undefined") {
+    throw new Error("EventSource is not available in this environment");
+  }
+  return new EventSource(url);
+}
+function buildEventsUrl(baseUrl, eventsPath) {
+  const normalized = eventsPath.startsWith("/") ? eventsPath : `/${eventsPath}`;
+  return `${baseUrl.replace(/\/$/, "")}${normalized}`;
+}
+function resolveFetch(fn) {
+  if (fn) {
+    return typeof fn === "function" ? fn : (() => {
+      throw new Error("provided fetch implementation is not a function");
+    })();
+  }
+  if (typeof fetch === "function") {
+    return fetch.bind(globalThis);
+  }
+  throw new Error("global fetch is not available; configure Done with a fetch implementation via Done.config");
+}
+function resolveEventSource(factory) {
+  if (factory) return factory;
+  if (typeof EventSource === "function") {
+    return (url) => new EventSource(url);
+  }
+  return void 0;
+}
+function normalizeConfig(input = {}, base) {
+  const previous = base ?? {
+    doneHttp: "https://doneHttp.done.zone",
+    doneEvents: "https://doneEvents.done.zone",
+    fetch: resolveFetch(),
+    eventSource: resolveEventSource(),
+    envelopeBuilder: void 0
+  };
+  return {
+    doneHttp: input.doneHttp ?? previous.doneHttp,
+    doneEvents: input.doneEvents ?? previous.doneEvents,
+    fetch: resolveFetch(input.fetch ?? previous.fetch),
+    eventSource: resolveEventSource(input.eventSource ?? previous.eventSource),
+    envelopeBuilder: input.envelopeBuilder ?? input.signer ?? previous.envelopeBuilder
+  };
+}
+function resolveRoute(raw, base, extraSearch) {
+  const url = new URL(raw, base);
+  if (extraSearch) {
+    for (const [key, value] of Object.entries(extraSearch)) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  const pathSegments = url.pathname.replace(/^\/+/, "").split("/");
+  const contract = pathSegments.shift();
+  if (!contract) {
+    throw new Error("route must include contract address as first path segment");
+  }
+  const path = pathSegments.length > 0 ? `/${pathSegments.join("/")}` : "/";
+  const queryRecord = searchParamsToRecord(url.searchParams);
+  return {
+    url,
+    contract,
+    path,
+    query: Object.keys(queryRecord).length > 0 ? queryRecord : void 0
+  };
+}
+function searchParamsToRecord(params) {
+  const record = {};
+  for (const [key, value] of params) {
+    const existing = record[key];
+    if (existing === void 0) {
+      record[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      record[key] = [existing, value];
+    }
+  }
+  return record;
+}
+function normalizeContractBody(body) {
+  if (body === void 0 || body === null) {
+    return body;
+  }
+  if (isPlainObject(body) || Array.isArray(body)) {
+    return body;
+  }
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch (err) {
+      throw new Error("string bodies must contain JSON payloads when invoking Done.run/query");
+    }
+  }
+  if (body instanceof URLSearchParams) {
+    return Object.fromEntries(Array.from(body));
+  }
+  throw new Error("unsupported body type for Done.run/query; provide a JSON-serialisable value");
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function normalizeContractSegment(value) {
+  if (!value) {
+    throw new Error("contract identifier cannot be empty");
+  }
+  return value.replace(/^\/+/u, "").replace(/\/+$/u, "");
+}
+var DoneInstance = class _DoneInstance {
+  settings;
+  backend;
+  CURRENT_ENVELOPE_VERSION = CURRENT_ENVELOPE_VERSION;
+  buildEnvelope = buildEnvelope;
+  signDocDigest = signDocDigest;
+  toSignDoc = toSignDoc;
+  constructor(input) {
+    this.settings = normalizeConfig(input);
+    this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
+  }
+  async run(url, init = {}) {
+    const {
+      body: rawBody,
+      funds,
+      memo,
+      traceId,
+      gasLimit,
+      passkey,
+      metadata,
+      search,
+      ...rest
+    } = init;
+    const fetchInit = { ...rest };
+    const resolved = resolveRoute(url, this.settings.doneHttp, search);
+    const contractBody = normalizeContractBody(rawBody);
+    const call = {
+      path: resolved.path,
+      query: resolved.query,
+      body: contractBody
+    };
+    const msg = buildTransactionMessage(resolved.contract, call, { funds });
+    const mergedMetadata = mergeMetadata(metadata, {
+      trace_id: traceId,
+      memo,
+      gas_limit: gasLimit
+    });
+    const builder = this.requireEnvelopeBuilder();
+    const request = {
+      body: contractBody,
+      query: resolved.query,
+      funds,
+      memo,
+      traceId,
+      gasLimit,
+      metadata: mergedMetadata,
+      passkey,
+      signal: fetchInit.signal
+    };
+    const result = await Promise.resolve(
+      builder({
+        msg,
+        metadata: mergedMetadata,
+        path: resolved.path,
+        request
+      })
+    );
+    if (mergedMetadata) {
+      result.envelope.metadata = result.envelope.metadata ?? mergedMetadata;
+    }
+    const executeOptions = mergeExecuteOptions(result.options, {
+      memo,
+      passkey,
+      signal: fetchInit.signal
+    });
+    return this.backend.executeEnvelope(result.envelope, executeOptions ?? {}, fetchInit);
+  }
+  async query(url, init = {}) {
+    const { body: rawBody, search, ...rest } = init;
+    const fetchInit = { ...rest };
+    const resolved = resolveRoute(url, this.settings.doneHttp, search);
+    const contractBody = normalizeContractBody(rawBody);
+    const call = {
+      path: resolved.path,
+      query: resolved.query,
+      body: contractBody
+    };
+    return this.backend.queryContract(resolved.contract, call, fetchInit);
+  }
+  subscribe(eventsUrl, topic, handler, options = {}) {
+    const factory = this.settings.eventSource ?? defaultEventSourceFactory;
+    if (!factory) {
+      throw new Error("EventSource is not available; configure Done with an eventSource factory");
+    }
+    const url = new URL(eventsUrl, this.settings.doneEvents);
+    const topicValue = Array.isArray(topic) ? JSON.stringify(topic) : topic;
+    url.searchParams.set("topic", topicValue);
+    const source = factory(url.toString());
+    const messageListener = (event) => {
+      if (options.rawEvent) {
+        handler(event);
+        return;
+      }
+      try {
+        handler(JSON.parse(event.data));
+      } catch {
+        handler(event.data);
+      }
+    };
+    if (typeof source.addEventListener === "function") {
+      source.addEventListener("message", messageListener);
+    } else {
+      source.onmessage = messageListener;
+    }
+    if (options.onError) {
+      if (typeof source.addEventListener === "function") {
+        source.addEventListener("error", options.onError);
+      } else {
+        source.onerror = options.onError;
+      }
+    }
+    const cleanup = () => {
+      if (typeof source.removeEventListener === "function") {
+        source.removeEventListener("message", messageListener);
+        if (options.onError) {
+          source.removeEventListener("error", options.onError);
+        }
+      }
+      source.close();
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        cleanup();
+      } else {
+        options.signal.addEventListener("abort", cleanup, { once: true });
+      }
+    }
+    return cleanup;
+  }
+  config(update) {
+    this.settings = normalizeConfig(update, this.settings);
+    this.backend = new DoneBackendClient({ baseUrl: this.settings.doneHttp, fetch: this.settings.fetch });
+  }
+  create(update = {}) {
+    const merged = normalizeConfig(update, this.settings);
+    return new _DoneInstance({
+      doneHttp: merged.doneHttp,
+      doneEvents: merged.doneEvents,
+      fetch: merged.fetch,
+      eventSource: merged.eventSource,
+      envelopeBuilder: merged.envelopeBuilder
+    });
+  }
+  contract(config, maybeConfig) {
+    if (typeof config === "string") {
+      if (!maybeConfig) {
+        return this.buildContractHandle(config);
+      }
+      return new DoneContractClient({
+        baseUrl: config,
+        ...maybeConfig,
+        buildEnvelope: maybeConfig.buildEnvelope ?? this.settings.envelopeBuilder,
+        fetch: maybeConfig.fetch ?? this.settings.fetch,
+        eventSource: maybeConfig.eventSource ?? this.settings.eventSource
+      });
+    }
+    return new DoneContractClient({
+      ...config,
+      baseUrl: config.baseUrl,
+      buildEnvelope: config.buildEnvelope ?? this.settings.envelopeBuilder,
+      fetch: config.fetch ?? this.settings.fetch,
+      eventSource: config.eventSource ?? this.settings.eventSource
+    });
+  }
+  requireEnvelopeBuilder() {
+    if (!this.settings.envelopeBuilder) {
+      throw new Error("Done.run requires an envelope builder; configure Done.config({ signer: ... }) first");
+    }
+    return this.settings.envelopeBuilder;
+  }
+  buildContractHandle(contract) {
+    const address = normalizeContractSegment(contract);
+    const client = new DoneContractClient({
+      baseUrl: this.settings.doneHttp,
+      address,
+      buildEnvelope: this.settings.envelopeBuilder,
+      fetch: this.settings.fetch,
+      eventSource: this.settings.eventSource
+    });
+    return client;
+  }
+};
+var Done = new DoneInstance();
+
+// src/auth.ts
+function createPasskeyEnvelopeBuilder(options) {
+  return async (ctx) => {
+    const [userId, nonce, expiresAt, publicKey, agent, forwarder, metadata] = await Promise.all([
+      resolve(options.userId, ctx),
+      resolve(options.nonce, ctx),
+      resolve(options.expiresAt, ctx),
+      resolve(options.publicKey, ctx),
+      resolve(options.agent, ctx),
+      resolve(options.forwarder, ctx),
+      resolve(options.metadata, ctx)
+    ]);
+    assertDefined(userId, "userId");
+    assertDefined(nonce, "nonce");
+    assertDefined(expiresAt, "expiresAt");
+    assertDefined(publicKey, "publicKey");
+    const mergedMetadata = combineMetadata(ctx.metadata, metadata);
+    const draft = {
+      user_id: userId,
+      msgs: [ctx.msg],
+      nonce,
+      expires_at: expiresAt,
+      role: options.role ?? "Passkey",
+      agent: agent ?? void 0,
+      forwarder: forwarder ?? void 0,
+      metadata: mergedMetadata,
+      signatures: {}
+    };
+    const signDoc = toSignDoc(draft);
+    const signature = await options.sign(signDoc, ctx);
+    draft.signatures = {
+      passkey: normalizeSignature(signature)
+    };
+    const envelope = buildEnvelope(draft);
+    envelope.metadata = envelope.metadata ?? mergedMetadata;
+    const passkeyOption = { publicKey };
+    const executeOptions = { passkey: passkeyOption };
+    return makeResult(envelope, executeOptions);
+  };
+}
+function createSessionEnvelopeBuilder(options) {
+  return async (ctx) => {
+    const [userId, sessionId, nonce, expiresAt, agent, forwarder, metadata] = await Promise.all([
+      resolve(options.userId, ctx),
+      resolve(options.sessionId, ctx),
+      resolve(options.nonce, ctx),
+      resolve(options.expiresAt, ctx),
+      resolve(options.agent, ctx),
+      resolve(options.forwarder, ctx),
+      resolve(options.metadata, ctx)
+    ]);
+    assertDefined(userId, "userId");
+    assertDefined(sessionId, "sessionId");
+    assertDefined(nonce, "nonce");
+    assertDefined(expiresAt, "expiresAt");
+    const mergedMetadata = combineMetadata(ctx.metadata, metadata);
+    const draft = {
+      user_id: userId,
+      session_id: sessionId,
+      msgs: [ctx.msg],
+      nonce,
+      expires_at: expiresAt,
+      role: options.role ?? "Session",
+      agent: agent ?? void 0,
+      forwarder: forwarder ?? void 0,
+      metadata: mergedMetadata,
+      signatures: {}
+    };
+    const signDoc = toSignDoc(draft);
+    const signature = await options.sign(signDoc, ctx);
+    draft.signatures = {
+      session: normalizeSignature(signature)
+    };
+    const envelope = buildEnvelope(draft);
+    envelope.metadata = envelope.metadata ?? mergedMetadata;
+    return makeResult(envelope, void 0);
+  };
+}
+function normalizeSignature(signature) {
+  if (typeof signature === "string") {
+    return signature;
+  }
+  return encodeSignature(signature);
+}
+function combineMetadata(base, override) {
+  const merged = {};
+  for (const entry of [base, override]) {
+    if (!entry) continue;
+    if (entry.trace_id) merged.trace_id = entry.trace_id;
+    if (entry.memo) merged.memo = entry.memo;
+    if (typeof entry.gas_limit === "number") merged.gas_limit = entry.gas_limit;
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function makeResult(envelope, options) {
+  return options ? { envelope, options } : { envelope };
+}
+function resolve(value, ctx) {
+  if (typeof value === "function") {
+    return Promise.resolve(value(ctx));
+  }
+  return Promise.resolve(value);
+}
+function assertDefined(value, name) {
+  if (value === void 0 || value === null) {
+    throw new Error(`${name} must be provided for envelope builder`);
+  }
+}
+export {
+  CURRENT_ENVELOPE_VERSION,
+  Done,
+  DoneBackendClient,
+  DoneContractClient,
+  DoneRequest,
+  buildEnvelope,
+  buildQueryMessage,
+  buildTransactionMessage,
+  createDevEnvelopeBuilder,
+  createPasskeyEnvelopeBuilder,
+  createSessionEnvelopeBuilder,
+  decodeSignature,
+  encodeSignature,
+  signDocBytes,
+  signDocDigest,
+  toSignDoc
+};
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/