@unlink-xyz/multisig 0.1.4 → 0.1.6

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);
@@ -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) {
@@ -28728,7 +28852,7 @@ var FrostCoordinator = class {
     );
   }
   // === Signing ===
-  async createSigningSession(participants, message, groupId) {
+  async createSigningSession(participants, message, groupId, metadata) {
     const body = {
       participants,
       message: serializeBigint(message)
@@ -28736,7 +28860,10 @@ var FrostCoordinator = class {
     if (groupId !== void 0) {
       body.group_id = groupId;
     }
-    const resp = await fetch(`${this.baseUrl}/sign/sessions`, {
+    if (metadata !== void 0) {
+      body.metadata = metadata;
+    }
+    const resp = await this.fetchWithRetry(`${this.baseUrl}/sign/sessions`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
@@ -28746,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",
@@ -28766,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) {
@@ -28783,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);
@@ -28812,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();
   }
@@ -28846,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}`);
   }
 };
@@ -28861,16 +29021,20 @@ function deserializeSessionInfo(raw) {
     message: deserializeBigint(raw.message),
     participants: raw.participants,
     status: raw.status,
-    groupId: raw.group_id ?? void 0
+    groupId: raw.group_id ?? void 0,
+    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);
@@ -28884,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,
@@ -28905,6 +29069,7 @@ function buildMultisigAccount(result, viewingKeyPair, groupId, config3, particip
     nullifyingKey,
     masterPublicKey,
     gatewayUrl,
+    ...frostUrl !== void 0 ? { frostUrl } : {},
     address
   };
 }
@@ -28925,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,
@@ -28959,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 };
@@ -28995,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
@@ -29038,13 +29208,18 @@ 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,
         message,
-        params.account.groupId
+        params.account.groupId,
+        params.metadata
       );
+      params.onSessionCreated?.(code);
       return signMultisig({
         account: params.account,
         message,
@@ -29056,10 +29231,10 @@ function createFrostSigner(params) {
 
 // src/frost/listener.ts
 async function runSigningListener(params) {
-  const { account, signal, onSession, onError } = 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();
@@ -29074,9 +29249,21 @@ async function runSigningListener(params) {
           seen.add(session.code);
           continue;
         }
+        const info = {
+          code: session.code,
+          message: session.message,
+          metadata: session.metadata
+        };
+        try {
+          onSession?.(info);
+        } catch (err) {
+          seen.add(session.code);
+          const shouldContinue = onError?.(err, info) ?? true;
+          if (!shouldContinue) return;
+          continue;
+        }
+        if (approve && !await approve(info)) continue;
         seen.add(session.code);
-        const info = { code: session.code, message: session.message };
-        onSession?.(info);
         try {
           await signMultisig({
             account,
@@ -29098,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
       });
     },
@@ -29112,6 +29300,7 @@ function createMultisigWallet(config3) {
       return joinMultisig({
         code: params.code,
         gatewayUrl,
+        frostUrl,
         viewingKeyPair: params.viewingKeyPair
       });
     },
@@ -29126,17 +29315,20 @@ function createMultisigWallet(config3) {
     createSigner(params) {
       return createFrostSigner({
         account: params.account,
-        participants: params.participants
+        participants: params.participants,
+        metadata: params.metadata,
+        onSessionCreated: params.onSessionCreated
       });
     },
     async createSigningSession(params) {
       const coordinator = new FrostCoordinator({
-        baseUrl: `${gatewayUrl.replace(/\/$/, "")}/frost`
+        baseUrl: frostUrl ?? `${gatewayUrl.replace(/\/$/, "")}/frost`
       });
       return coordinator.createSigningSession(
         params.participants,
         params.message,
-        params.groupId
+        params.groupId,
+        params.metadata
       );
     }
   };