@unlink-xyz/multisig 0.1.5 → 0.1.7-canary.252b8ea

package/dist/browser/index.js

@@ -11320,9 +11320,9 @@ function genBech32(encoding) {
 }
 var bech32m = /* @__PURE__ */ genBech32("bech32m");
 var VERSION = 1;
-var LIMIT = 127;
+var LIMIT = 130;
 var ALL_CHAINS = "ffffffffffffffff";
-var PREFIX = "0zk";
+var PREFIX = "unlink";
 var SALT = new TextEncoder().encode("unlink");
 function xorWithSalt(hex2) {
   const bytes2 = Hex.toBytes(hex2);
@@ -23744,8 +23744,8 @@ var ContractUnknownEventPayload = class extends EventPayload {
   /**
    *  @_event:
    */
-  constructor(contract, listener, filter, log) {
-    super(contract, listener, filter);
+  constructor(contract2, listener, filter, log) {
+    super(contract2, listener, filter);
     defineProperties(this, { log });
   }
   /**
@@ -23771,9 +23771,9 @@ var ContractEventPayload = class extends ContractUnknownEventPayload {
   /**
    *  @_ignore:
    */
-  constructor(contract, listener, filter, fragment, _log) {
-    super(contract, listener, filter, new EventLog(_log, contract.interface, fragment));
-    const args = contract.interface.decodeEventLog(fragment, this.log.data, this.log.topics);
+  constructor(contract2, listener, filter, fragment, _log) {
+    super(contract2, listener, filter, new EventLog(_log, contract2.interface, fragment));
+    const args = contract2.interface.decodeEventLog(fragment, this.log.data, this.log.topics);
     defineProperties(this, { args, fragment });
   }
   /**
@@ -23816,12 +23816,12 @@ function getResolver(value) {
 var PreparedTopicFilter = class {
   #filter;
   fragment;
-  constructor(contract, fragment, args) {
+  constructor(contract2, fragment, args) {
     defineProperties(this, { fragment });
     if (fragment.inputs.length < args.length) {
       throw new Error("too many arguments");
     }
-    const runner = getRunner(contract.runner, "resolveName");
+    const runner = getRunner(contract2.runner, "resolveName");
     const resolver = canResolve(runner) ? runner : null;
     this.#filter = (async function() {
       const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => {
@@ -23839,7 +23839,7 @@ var PreparedTopicFilter = class {
           return value;
         });
       }));
-      return contract.interface.encodeFilterTopics(fragment, resolvedArgs);
+      return contract2.interface.encodeFilterTopics(fragment, resolvedArgs);
     })();
   }
   getTopicFilter() {
@@ -23888,14 +23888,14 @@ async function resolveArgs(_runner, inputs, args) {
     });
   }));
 }
-function buildWrappedFallback(contract) {
+function buildWrappedFallback(contract2) {
   const populateTransaction = async function(overrides) {
     const tx2 = await copyOverrides(overrides, ["data"]);
-    tx2.to = await contract.getAddress();
+    tx2.to = await contract2.getAddress();
     if (tx2.from) {
-      tx2.from = await resolveAddress(tx2.from, getResolver(contract.runner));
+      tx2.from = await resolveAddress(tx2.from, getResolver(contract2.runner));
     }
-    const iface = contract.interface;
+    const iface = contract2.interface;
     const noValue = getBigInt(tx2.value || BN_09, "overrides.value") === BN_09;
     const noData = (tx2.data || "0x") === "0x";
     if (iface.fallback && !iface.fallback.payable && iface.receive && !noData && !noValue) {
@@ -23908,27 +23908,27 @@ function buildWrappedFallback(contract) {
     return tx2;
   };
   const staticCall = async function(overrides) {
-    const runner = getRunner(contract.runner, "call");
+    const runner = getRunner(contract2.runner, "call");
     assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
     const tx2 = await populateTransaction(overrides);
     try {
       return await runner.call(tx2);
     } catch (error) {
       if (isCallException(error) && error.data) {
-        throw contract.interface.makeError(error.data, tx2);
+        throw contract2.interface.makeError(error.data, tx2);
       }
       throw error;
     }
   };
   const send = async function(overrides) {
-    const runner = contract.runner;
+    const runner = contract2.runner;
     assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
     const tx2 = await runner.sendTransaction(await populateTransaction(overrides));
-    const provider = getProvider(contract.runner);
-    return new ContractTransactionResponse(contract.interface, provider, tx2);
+    const provider = getProvider(contract2.runner);
+    return new ContractTransactionResponse(contract2.interface, provider, tx2);
   };
   const estimateGas = async function(overrides) {
-    const runner = getRunner(contract.runner, "estimateGas");
+    const runner = getRunner(contract2.runner, "estimateGas");
     assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
     return await runner.estimateGas(await populateTransaction(overrides));
   };
@@ -23936,7 +23936,7 @@ function buildWrappedFallback(contract) {
     return await send(overrides);
   };
   defineProperties(method, {
-    _contract: contract,
+    _contract: contract2,
     estimateGas,
     populateTransaction,
     send,
@@ -23944,9 +23944,9 @@ function buildWrappedFallback(contract) {
   });
   return method;
 }
-function buildWrappedMethod(contract, key) {
+function buildWrappedMethod(contract2, key) {
   const getFragment = function(...args) {
-    const fragment = contract.interface.getFunction(key, args);
+    const fragment = contract2.interface.getFunction(key, args);
     assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
       operation: "fragment",
       info: { key, args }
@@ -23959,16 +23959,16 @@ function buildWrappedMethod(contract, key) {
     if (fragment.inputs.length + 1 === args.length) {
       overrides = await copyOverrides(args.pop());
       if (overrides.from) {
-        overrides.from = await resolveAddress(overrides.from, getResolver(contract.runner));
+        overrides.from = await resolveAddress(overrides.from, getResolver(contract2.runner));
       }
     }
     if (fragment.inputs.length !== args.length) {
       throw new Error("internal error: fragment inputs doesn't match arguments; should not happen");
     }
-    const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);
+    const resolvedArgs = await resolveArgs(contract2.runner, fragment.inputs, args);
     return Object.assign({}, overrides, await resolveProperties({
-      to: contract.getAddress(),
-      data: contract.interface.encodeFunctionData(fragment, resolvedArgs)
+      to: contract2.getAddress(),
+      data: contract2.interface.encodeFunctionData(fragment, resolvedArgs)
     }));
   };
   const staticCall = async function(...args) {
@@ -23979,19 +23979,19 @@ function buildWrappedMethod(contract, key) {
     return result;
   };
   const send = async function(...args) {
-    const runner = contract.runner;
+    const runner = contract2.runner;
     assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
     const tx2 = await runner.sendTransaction(await populateTransaction(...args));
-    const provider = getProvider(contract.runner);
-    return new ContractTransactionResponse(contract.interface, provider, tx2);
+    const provider = getProvider(contract2.runner);
+    return new ContractTransactionResponse(contract2.interface, provider, tx2);
   };
   const estimateGas = async function(...args) {
-    const runner = getRunner(contract.runner, "estimateGas");
+    const runner = getRunner(contract2.runner, "estimateGas");
     assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
     return await runner.estimateGas(await populateTransaction(...args));
   };
   const staticCallResult = async function(...args) {
-    const runner = getRunner(contract.runner, "call");
+    const runner = getRunner(contract2.runner, "call");
     assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
     const tx2 = await populateTransaction(...args);
     let result = "0x";
@@ -23999,12 +23999,12 @@ function buildWrappedMethod(contract, key) {
       result = await runner.call(tx2);
     } catch (error) {
       if (isCallException(error) && error.data) {
-        throw contract.interface.makeError(error.data, tx2);
+        throw contract2.interface.makeError(error.data, tx2);
       }
       throw error;
     }
     const fragment = getFragment(...args);
-    return contract.interface.decodeFunctionResult(fragment, result);
+    return contract2.interface.decodeFunctionResult(fragment, result);
   };
   const method = async (...args) => {
     const fragment = getFragment(...args);
@@ -24014,8 +24014,8 @@ function buildWrappedMethod(contract, key) {
     return await send(...args);
   };
   defineProperties(method, {
-    name: contract.interface.getFunctionName(key),
-    _contract: contract,
+    name: contract2.interface.getFunctionName(key),
+    _contract: contract2,
     _key: key,
     getFragment,
     estimateGas,
@@ -24028,7 +24028,7 @@ function buildWrappedMethod(contract, key) {
     configurable: false,
     enumerable: true,
     get: () => {
-      const fragment = contract.interface.getFunction(key);
+      const fragment = contract2.interface.getFunction(key);
       assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
         operation: "fragment",
         info: { key }
@@ -24038,9 +24038,9 @@ function buildWrappedMethod(contract, key) {
   });
   return method;
 }
-function buildWrappedEvent(contract, key) {
+function buildWrappedEvent(contract2, key) {
   const getFragment = function(...args) {
-    const fragment = contract.interface.getEvent(key, args);
+    const fragment = contract2.interface.getEvent(key, args);
     assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
       operation: "fragment",
       info: { key, args }
@@ -24048,11 +24048,11 @@ function buildWrappedEvent(contract, key) {
     return fragment;
   };
   const method = function(...args) {
-    return new PreparedTopicFilter(contract, getFragment(...args), args);
+    return new PreparedTopicFilter(contract2, getFragment(...args), args);
   };
   defineProperties(method, {
-    name: contract.interface.getEventName(key),
-    _contract: contract,
+    name: contract2.interface.getEventName(key),
+    _contract: contract2,
     _key: key,
     getFragment
   });
@@ -24060,7 +24060,7 @@ function buildWrappedEvent(contract, key) {
     configurable: false,
     enumerable: true,
     get: () => {
-      const fragment = contract.interface.getEvent(key);
+      const fragment = contract2.interface.getEvent(key);
       assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
         operation: "fragment",
         info: { key }
@@ -24072,16 +24072,16 @@ function buildWrappedEvent(contract, key) {
 }
 var internal2 = /* @__PURE__ */ Symbol.for("_ethersInternal_contract");
 var internalValues = /* @__PURE__ */ new WeakMap();
-function setInternal(contract, values) {
-  internalValues.set(contract[internal2], values);
+function setInternal(contract2, values) {
+  internalValues.set(contract2[internal2], values);
 }
-function getInternal(contract) {
-  return internalValues.get(contract[internal2]);
+function getInternal(contract2) {
+  return internalValues.get(contract2[internal2]);
 }
 function isDeferred(value) {
   return value && typeof value === "object" && "getTopicFilter" in value && typeof value.getTopicFilter === "function" && value.fragment;
 }
-async function getSubInfo(contract, event) {
+async function getSubInfo(contract2, event) {
   let topics;
   let fragment = null;
   if (Array.isArray(event)) {
@@ -24089,7 +24089,7 @@ async function getSubInfo(contract, event) {
       if (isHexString(name, 32)) {
         return name;
       }
-      const fragment2 = contract.interface.getEvent(name);
+      const fragment2 = contract2.interface.getEvent(name);
       assertArgument(fragment2, "unknown fragment", "name", name);
       return fragment2.topicHash;
     };
@@ -24108,7 +24108,7 @@ async function getSubInfo(contract, event) {
     if (isHexString(event, 32)) {
       topics = [event];
     } else {
-      fragment = contract.interface.getEvent(event);
+      fragment = contract2.interface.getEvent(event);
       assertArgument(fragment, "unknown fragment", "event", event);
       topics = [fragment.topicHash];
     }
@@ -24145,36 +24145,36 @@ async function getSubInfo(contract, event) {
   }).join("&");
   return { fragment, tag, topics };
 }
-async function hasSub(contract, event) {
-  const { subs } = getInternal(contract);
-  return subs.get((await getSubInfo(contract, event)).tag) || null;
+async function hasSub(contract2, event) {
+  const { subs } = getInternal(contract2);
+  return subs.get((await getSubInfo(contract2, event)).tag) || null;
 }
-async function getSub(contract, operation, event) {
-  const provider = getProvider(contract.runner);
+async function getSub(contract2, operation, event) {
+  const provider = getProvider(contract2.runner);
   assert(provider, "contract runner does not support subscribing", "UNSUPPORTED_OPERATION", { operation });
-  const { fragment, tag, topics } = await getSubInfo(contract, event);
-  const { addr, subs } = getInternal(contract);
+  const { fragment, tag, topics } = await getSubInfo(contract2, event);
+  const { addr, subs } = getInternal(contract2);
   let sub2 = subs.get(tag);
   if (!sub2) {
-    const address = addr ? addr : contract;
+    const address = addr ? addr : contract2;
     const filter = { address, topics };
     const listener = (log) => {
       let foundFragment = fragment;
       if (foundFragment == null) {
         try {
-          foundFragment = contract.interface.getEvent(log.topics[0]);
+          foundFragment = contract2.interface.getEvent(log.topics[0]);
         } catch (error) {
         }
       }
       if (foundFragment) {
         const _foundFragment = foundFragment;
-        const args = fragment ? contract.interface.decodeEventLog(fragment, log.data, log.topics) : [];
-        emit22(contract, event, args, (listener2) => {
-          return new ContractEventPayload(contract, listener2, event, _foundFragment, log);
+        const args = fragment ? contract2.interface.decodeEventLog(fragment, log.data, log.topics) : [];
+        emit22(contract2, event, args, (listener2) => {
+          return new ContractEventPayload(contract2, listener2, event, _foundFragment, log);
         });
       } else {
-        emit22(contract, event, [], (listener2) => {
-          return new ContractUnknownEventPayload(contract, listener2, event, log);
+        emit22(contract2, event, [], (listener2) => {
+          return new ContractUnknownEventPayload(contract2, listener2, event, log);
         });
       }
     };
@@ -24200,9 +24200,9 @@ async function getSub(contract, operation, event) {
   return sub2;
 }
 var lastEmit = Promise.resolve();
-async function _emit(contract, event, args, payloadFunc) {
+async function _emit(contract2, event, args, payloadFunc) {
   await lastEmit;
-  const sub2 = await hasSub(contract, event);
+  const sub2 = await hasSub(contract2, event);
   if (!sub2) {
     return false;
   }
@@ -24213,23 +24213,23 @@ async function _emit(contract, event, args, payloadFunc) {
       passArgs.push(payloadFunc(once22 ? null : listener));
     }
     try {
-      listener.call(contract, ...passArgs);
+      listener.call(contract2, ...passArgs);
     } catch (error) {
     }
     return !once22;
   });
   if (sub2.listeners.length === 0) {
     sub2.stop();
-    getInternal(contract).subs.delete(sub2.tag);
+    getInternal(contract2).subs.delete(sub2.tag);
   }
   return count > 0;
 }
-async function emit22(contract, event, args, payloadFunc) {
+async function emit22(contract2, event, args, payloadFunc) {
   try {
     await lastEmit;
   } catch (error) {
   }
-  const resultPromise = _emit(contract, event, args, payloadFunc);
+  const resultPromise = _emit(contract2, event, args, payloadFunc);
   lastEmit = resultPromise;
   return await resultPromise;
 }
@@ -24655,8 +24655,8 @@ var BaseContract = class _BaseContract {
     if (runner == null) {
       runner = null;
     }
-    const contract = new this(target, abi, runner);
-    return contract;
+    const contract2 = new this(target, abi, runner);
+    return contract2;
   }
 };
 function _ContractBase() {
@@ -27982,6 +27982,114 @@ var circuits_default = {
     template: "JoinSplit",
     pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
     params: [5, 2, 16]
+  },
+  joinsplit_1x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [1, 3, 16]
+  },
+  joinsplit_4x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [4, 3, 16]
+  },
+  joinsplit_5x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [5, 3, 16]
+  },
+  joinsplit_6x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 1, 16]
+  },
+  joinsplit_6x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 2, 16]
+  },
+  joinsplit_6x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 3, 16]
+  },
+  joinsplit_7x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 1, 16]
+  },
+  joinsplit_7x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 2, 16]
+  },
+  joinsplit_7x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 3, 16]
+  },
+  joinsplit_8x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 1, 16]
+  },
+  joinsplit_8x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 2, 16]
+  },
+  joinsplit_8x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 3, 16]
+  },
+  joinsplit_9x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 1, 16]
+  },
+  joinsplit_9x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 2, 16]
+  },
+  joinsplit_9x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 3, 16]
+  },
+  joinsplit_10x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 1, 16]
+  },
+  joinsplit_10x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 2, 16]
+  },
+  joinsplit_10x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 3, 16]
   }
 };
 var registry = {};
@@ -28605,7 +28713,7 @@ function serializeMultisigAccount(account) {
   for (const [idx, points] of account.coefficientCommitments) {
     coeffEntries.push([idx, points.map(serializePoint)]);
   }
-  return {
+  const result = {
     version: MULTISIG_ACCOUNT_VERSION,
     groupId: account.groupId,
     config: account.config,
@@ -28626,6 +28734,10 @@ function serializeMultisigAccount(account) {
     gatewayUrl: account.gatewayUrl,
     address: account.address
   };
+  if (account.name !== void 0) {
+    result.name = account.name;
+  }
+  return result;
 }
 function deserializeMultisigAccount(data) {
   if (data.version !== MULTISIG_ACCOUNT_VERSION) {
@@ -28636,6 +28748,7 @@ function deserializeMultisigAccount(data) {
     coefficientCommitments.set(idx, serializedPoints.map(deserializePoint));
   }
   return {
+    ...data.name !== void 0 ? { name: data.name } : {},
     groupId: data.groupId,
     config: data.config,
     participantIndex: data.participantIndex,
@@ -28662,14 +28775,18 @@ var FrostCoordinator = class {
   baseUrl;
   pollIntervalMs;
   timeoutMs;
+  maxRetries;
+  retryDelayMs;
   constructor(config3) {
     this.baseUrl = config3.baseUrl.replace(/\/$/, "");
-    this.pollIntervalMs = config3.pollIntervalMs ?? 1e3;
+    this.pollIntervalMs = config3.pollIntervalMs ?? 3e3;
     this.timeoutMs = config3.timeoutMs ?? 12e4;
+    this.maxRetries = config3.maxRetries ?? 3;
+    this.retryDelayMs = config3.retryDelayMs ?? 500;
   }
   // === DKG ===
   async createDkgSession(threshold, totalParticipants) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups`, {
+    const resp = await this.fetchWithRetry(`${this.baseUrl}/dkg/groups`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -28682,9 +28799,10 @@ var FrostCoordinator = class {
     return { code: body.code };
   }
   async joinDkgSession(code) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups/${code}/join`, {
-      method: "POST"
-    });
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/dkg/groups/${code}/join`,
+      { method: "POST" }
+    );
     if (!resp.ok) throw await this.toError(resp);
     const body = await resp.json();
     return {
@@ -28694,14 +28812,17 @@ var FrostCoordinator = class {
     };
   }
   async submitRound1(code, pkg) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups/${code}/round1`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        participant_index: pkg.participantIndex,
-        data: serializeDkgRound1Package(pkg)
-      })
-    });
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/dkg/groups/${code}/round1`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          participant_index: pkg.participantIndex,
+          data: serializeDkgRound1Package(pkg)
+        })
+      }
+    );
     if (!resp.ok) throw await this.toError(resp);
   }
   async waitForRound1(code) {
@@ -28711,14 +28832,17 @@ var FrostCoordinator = class {
     );
   }
   async submitRound2(code, pkg) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups/${code}/round2`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        participant_index: pkg.participantIndex,
-        data: serializeDkgRound2Package(pkg)
-      })
-    });
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/dkg/groups/${code}/round2`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          participant_index: pkg.participantIndex,
+          data: serializeDkgRound2Package(pkg)
+        })
+      }
+    );
     if (!resp.ok) throw await this.toError(resp);
   }
   async waitForRound2(code) {
@@ -28739,7 +28863,7 @@ var FrostCoordinator = class {
     if (metadata !== void 0) {
       body.metadata = metadata;
     }
-    const resp = await fetch(`${this.baseUrl}/sign/sessions`, {
+    const resp = await this.fetchWithRetry(`${this.baseUrl}/sign/sessions`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -28749,7 +28873,7 @@ var FrostCoordinator = class {
     return { code: result.code };
   }
   async submitCommitment(code, c) {
-    const resp = await fetch(
+    const resp = await this.fetchWithRetry(
       `${this.baseUrl}/sign/sessions/${code}/commitments`,
       {
         method: "POST",
@@ -28769,14 +28893,17 @@ var FrostCoordinator = class {
     );
   }
   async submitShare(code, share) {
-    const resp = await fetch(`${this.baseUrl}/sign/sessions/${code}/shares`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        participant_index: share.participantIndex,
-        data: serializeSignatureShare(share)
-      })
-    });
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/sign/sessions/${code}/shares`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          participant_index: share.participantIndex,
+          data: serializeSignatureShare(share)
+        })
+      }
+    );
     if (!resp.ok) throw await this.toError(resp);
   }
   async waitForShares(code) {
@@ -28786,19 +28913,23 @@ var FrostCoordinator = class {
     );
   }
   async getSigningSessionStatus(code) {
-    const resp = await fetch(`${this.baseUrl}/sign/sessions/${code}/status`);
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/sign/sessions/${code}/status`
+    );
     if (!resp.ok) throw await this.toError(resp);
     const body = await resp.json();
     return { ...body, message: deserializeBigint(body.message) };
   }
   async getSigningSession(code) {
-    const resp = await fetch(`${this.baseUrl}/sign/sessions/${code}`);
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/sign/sessions/${code}`
+    );
     if (!resp.ok) throw await this.toError(resp);
     const body = await resp.json();
     return deserializeSessionInfo(body);
   }
   async listSigningSessions(groupId) {
-    const resp = await fetch(
+    const resp = await this.fetchWithRetry(
       `${this.baseUrl}/sign/sessions?group_id=${encodeURIComponent(groupId)}`
     );
     if (!resp.ok) throw await this.toError(resp);
@@ -28815,30 +28946,36 @@ var FrostCoordinator = class {
       if (sessions.length > 0) {
         return sessions[0];
       }
-      await sleep(this.pollIntervalMs);
+      await sleep(this.pollIntervalMs * (0.8 + Math.random() * 0.4));
     }
     throw new Error("Coordinator polling timeout");
   }
   // === Internal ===
   async pollRound1(code) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups/${code}/round1`);
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/dkg/groups/${code}/round1`
+    );
     if (!resp.ok) throw await this.toError(resp);
     return await resp.json();
   }
   async pollRound2(code) {
-    const resp = await fetch(`${this.baseUrl}/dkg/groups/${code}/round2`);
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/dkg/groups/${code}/round2`
+    );
     if (!resp.ok) throw await this.toError(resp);
     return await resp.json();
   }
   async pollCommitments(code) {
-    const resp = await fetch(
+    const resp = await this.fetchWithRetry(
       `${this.baseUrl}/sign/sessions/${code}/commitments`
     );
     if (!resp.ok) throw await this.toError(resp);
     return await resp.json();
   }
   async pollShares(code) {
-    const resp = await fetch(`${this.baseUrl}/sign/sessions/${code}/shares`);
+    const resp = await this.fetchWithRetry(
+      `${this.baseUrl}/sign/sessions/${code}/shares`
+    );
     if (!resp.ok) throw await this.toError(resp);
     return await resp.json();
   }
@@ -28849,12 +28986,32 @@ var FrostCoordinator = class {
       if (result.complete) {
         return result.packages.map((p) => deserializeFn(p));
       }
-      await sleep(this.pollIntervalMs);
+      await sleep(this.pollIntervalMs * (0.8 + Math.random() * 0.4));
     }
     throw new Error("Coordinator polling timeout");
   }
+  async fetchWithRetry(url, init4) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        await sleep(this.retryDelayMs * 2 ** (attempt - 1));
+      }
+      const resp = await fetch(url, init4);
+      if (resp.ok || !isTransientError(resp.status)) {
+        return resp;
+      }
+      lastError = await this.toError(resp);
+    }
+    throw lastError;
+  }
   async toError(resp) {
     const body = await resp.text();
+    const isHtml = body.trimStart().startsWith("<") || resp.headers.get("content-type")?.includes("text/html");
+    if (isHtml) {
+      return new Error(
+        `Coordinator unavailable (HTTP ${resp.status}). The service may be temporarily overloaded \u2014 try again shortly.`
+      );
+    }
     return new Error(`Coordinator error ${resp.status}: ${body}`);
   }
 };
@@ -28868,13 +29025,16 @@ function deserializeSessionInfo(raw) {
     metadata: raw.metadata
   };
 }
+function isTransientError(status) {
+  return status === 502 || status === 503 || status === 504;
+}
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/frost/account.ts
-function frostUrl(gatewayUrl) {
-  return `${gatewayUrl.replace(/\/$/, "")}/frost`;
+function resolveFrostUrl(gatewayUrl, explicitFrostUrl) {
+  return explicitFrostUrl ?? `${gatewayUrl.replace(/\/$/, "")}/frost`;
 }
 function deriveVerificationShare(participantIndex, coefficientCommitments) {
   const idx = BigInt(participantIndex);
@@ -28888,7 +29048,7 @@ function deriveVerificationShare(participantIndex, coefficientCommitments) {
   }
   return result;
 }
-function buildMultisigAccount(result, viewingKeyPair, groupId, config3, participantIndex, gatewayUrl) {
+function buildMultisigAccount(result, viewingKeyPair, groupId, config3, participantIndex, gatewayUrl, frostUrl) {
   const nullifyingKey = computeNullifyingKey(viewingKeyPair.privateKey);
   const masterPublicKey = computeMasterPublicKey(
     result.groupPublicKey,
@@ -28909,6 +29069,7 @@ function buildMultisigAccount(result, viewingKeyPair, groupId, config3, particip
     nullifyingKey,
     masterPublicKey,
     gatewayUrl,
+    ...frostUrl !== void 0 ? { frostUrl } : {},
     address
   };
 }
@@ -28929,7 +29090,7 @@ async function createMultisig(params) {
     totalShares: params.totalShares
   };
   const coordinator = new FrostCoordinator({
-    baseUrl: frostUrl(params.gatewayUrl)
+    baseUrl: resolveFrostUrl(params.gatewayUrl, params.frostUrl)
   });
   const { code } = await coordinator.createDkgSession(
     config3.threshold,
@@ -28963,14 +29124,15 @@ async function createMultisig(params) {
         code,
         config3,
         1,
-        params.gatewayUrl
+        params.gatewayUrl,
+        params.frostUrl
       );
     }
   };
 }
 async function joinMultisig(params) {
   const coordinator = new FrostCoordinator({
-    baseUrl: frostUrl(params.gatewayUrl)
+    baseUrl: resolveFrostUrl(params.gatewayUrl, params.frostUrl)
   });
   const { participantIndex, threshold, totalParticipants } = await coordinator.joinDkgSession(params.code);
   const config3 = { threshold, totalShares: totalParticipants };
@@ -28999,12 +29161,16 @@ async function joinMultisig(params) {
     params.code,
     config3,
     participantIndex,
-    params.gatewayUrl
+    params.gatewayUrl,
+    params.frostUrl
   );
 }
 async function signMultisig(params) {
   const coordinator = new FrostCoordinator({
-    baseUrl: frostUrl(params.account.gatewayUrl)
+    baseUrl: resolveFrostUrl(
+      params.account.gatewayUrl,
+      params.account.frostUrl
+    )
   });
   const { nonces, commitment } = generateCommitment(
     params.account.participantIndex
@@ -29042,7 +29208,10 @@ function createFrostSigner(params) {
     publicKey: params.account.groupPublicKey,
     sign: async (message) => {
       const coordinator = new FrostCoordinator({
-        baseUrl: frostUrl(params.account.gatewayUrl)
+        baseUrl: resolveFrostUrl(
+          params.account.gatewayUrl,
+          params.account.frostUrl
+        )
       });
       const { code } = await coordinator.createSigningSession(
         params.participants,
@@ -29065,7 +29234,7 @@ async function runSigningListener(params) {
   const { account, signal, onSession, approve, onError } = params;
   const pollIntervalMs = params.pollIntervalMs ?? 1e3;
   const coordinator = new FrostCoordinator({
-    baseUrl: `${account.gatewayUrl.replace(/\/$/, "")}/frost`,
+    baseUrl: account.frostUrl ?? `${account.gatewayUrl.replace(/\/$/, "")}/frost`,
     pollIntervalMs
   });
   const seen = /* @__PURE__ */ new Set();
@@ -29116,13 +29285,14 @@ async function runSigningListener(params) {
 
 // src/wallet/wallet.ts
 function createMultisigWallet(config3) {
-  const { gatewayUrl } = config3;
+  const { gatewayUrl, frostUrl } = config3;
   return {
     create(params) {
       return createMultisig({
         threshold: params.threshold,
         totalShares: params.totalShares,
         gatewayUrl,
+        frostUrl,
         viewingKeyPair: params.viewingKeyPair
       });
     },
@@ -29130,6 +29300,7 @@ function createMultisigWallet(config3) {
       return joinMultisig({
         code: params.code,
         gatewayUrl,
+        frostUrl,
         viewingKeyPair: params.viewingKeyPair
       });
     },
@@ -29151,7 +29322,7 @@ function createMultisigWallet(config3) {
     },
     async createSigningSession(params) {
       const coordinator = new FrostCoordinator({
-        baseUrl: `${gatewayUrl.replace(/\/$/, "")}/frost`
+        baseUrl: frostUrl ?? `${gatewayUrl.replace(/\/$/, "")}/frost`
       });
       return coordinator.createSigningSession(
         params.participants,