@cofhe/sdk 0.3.2 → 0.4.0

package/dist/node.cjs

@@ -2474,13 +2474,13 @@ var serialize = (permit) => {
 var deserialize = (serialized) => {
   return PermitUtils.deserialize(serialized);
 };
-var getPermit2 = async (chainId, account, hash) => {
+var getPermit2 = (chainId, account, hash) => {
   return permitStore.getPermit(chainId, account, hash);
 };
-var getPermits2 = async (chainId, account) => {
+var getPermits2 = (chainId, account) => {
   return permitStore.getPermits(chainId, account);
 };
-var getActivePermit2 = async (chainId, account) => {
+var getActivePermit2 = (chainId, account) => {
   return permitStore.getActivePermit(chainId, account);
 };
 var getActivePermitHash2 = (chainId, account) => {
@@ -3249,7 +3249,7 @@ async function cofheMocksDecryptForTx(ctHash, utype, permit, publicClient) {
     signature
   };
 }
-function normalizeSignature(signature) {
+function normalizeTnSignature(signature) {
   if (typeof signature !== "string") {
     throw new CofheError({
       code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
@@ -3305,57 +3305,77 @@ function parseDecryptedBytesToBigInt(decrypted) {
   }
   return BigInt(`0x${hex}`);
 }
-function assertTnDecryptResponse(value) {
+
+// core/decrypt/tnDecryptV2.ts
+var POLL_INTERVAL_MS2 = 1e3;
+var POLL_TIMEOUT_MS2 = 5 * 60 * 1e3;
+function assertDecryptSubmitResponseV2(value) {
   if (value == null || typeof value !== "object") {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response must be a JSON object",
+      message: "decrypt submit response must be a JSON object",
       context: {
         value
       }
     });
   }
   const v = value;
-  const decrypted = v.decrypted;
-  const signature = v.signature;
-  const encryptionType = v.encryption_type;
-  const errorMessage = v.error_message;
-  if (!Array.isArray(decrypted)) {
+  if (typeof v.request_id !== "string" || v.request_id.trim().length === 0) {
     throw new CofheError({
-      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
-      message: "decrypt response missing <decrypted> byte array",
-      context: { decryptResponse: value }
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt submit response missing request_id",
+      context: {
+        value
+      }
     });
   }
-  if (typeof signature !== "string") {
+  return { request_id: v.request_id };
+}
+function assertDecryptStatusResponseV2(value) {
+  if (value == null || typeof value !== "object") {
     throw new CofheError({
-      code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
-      message: "decrypt response missing <signature> string",
-      context: { decryptResponse: value }
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt status response must be a JSON object",
+      context: {
+        value
+      }
+    });
+  }
+  const v = value;
+  const requestId = v.request_id;
+  const status = v.status;
+  const submittedAt = v.submitted_at;
+  if (typeof requestId !== "string" || requestId.trim().length === 0) {
+    throw new CofheError({
+      code: "DECRYPT_FAILED" /* DecryptFailed */,
+      message: "decrypt status response missing request_id",
+      context: {
+        value
+      }
     });
   }
-  if (typeof encryptionType !== "number") {
+  if (status !== "PROCESSING" && status !== "COMPLETED") {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response missing <encryption_type> number",
-      context: { decryptResponse: value }
+      message: "decrypt status response has invalid status",
+      context: {
+        value,
+        status
+      }
     });
   }
-  if (!(typeof errorMessage === "string" || errorMessage === null)) {
+  if (typeof submittedAt !== "string" || submittedAt.trim().length === 0) {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: "decrypt response field <error_message> must be string or null",
-      context: { decryptResponse: value }
+      message: "decrypt status response missing submitted_at",
+      context: {
+        value
+      }
     });
   }
-  return {
-    decrypted,
-    signature,
-    encryption_type: encryptionType,
-    error_message: errorMessage
-  };
+  return value;
 }
-async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
+async function submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission) {
   const body = {
     ct_tempkey: BigInt(ctHash).toString(16).padStart(64, "0"),
     host_chain_id: chainId
@@ -3365,7 +3385,7 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
   }
   let response;
   try {
-    response = await fetch(`${thresholdNetworkUrl}/decrypt`, {
+    response = await fetch(`${thresholdNetworkUrl}/v2/decrypt`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -3384,18 +3404,15 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
       }
     });
   }
-  const responseText = await response.text();
   if (!response.ok) {
-    let errorMessage = response.statusText || `HTTP ${response.status}`;
+    let errorMessage = `HTTP ${response.status}`;
     try {
-      const errorBody = JSON.parse(responseText);
+      const errorBody = await response.json();
       const maybeMessage = errorBody.error_message || errorBody.message;
       if (typeof maybeMessage === "string" && maybeMessage.length > 0)
         errorMessage = maybeMessage;
     } catch {
-      const trimmed = responseText.trim();
-      if (trimmed.length > 0)
-        errorMessage = trimmed;
+      errorMessage = response.statusText || errorMessage;
     }
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
@@ -3405,41 +3422,163 @@ async function tnDecrypt(ctHash, chainId, permission, thresholdNetworkUrl) {
         thresholdNetworkUrl,
         status: response.status,
         statusText: response.statusText,
-        body,
-        responseText
+        body
       }
     });
   }
   let rawJson;
   try {
-    rawJson = JSON.parse(responseText);
+    rawJson = await response.json();
   } catch (e) {
     throw new CofheError({
       code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: `Failed to parse decrypt response`,
+      message: `Failed to parse decrypt submit response`,
       cause: e instanceof Error ? e : void 0,
       context: {
         thresholdNetworkUrl,
-        body,
-        responseText
+        body
       }
     });
   }
-  const decryptResponse = assertTnDecryptResponse(rawJson);
-  if (decryptResponse.error_message) {
-    throw new CofheError({
-      code: "DECRYPT_FAILED" /* DecryptFailed */,
-      message: `decrypt request failed: ${decryptResponse.error_message}`,
-      context: {
-        thresholdNetworkUrl,
-        body,
-        decryptResponse
+  const submitResponse = assertDecryptSubmitResponseV2(rawJson);
+  return submitResponse.request_id;
+}
+async function pollDecryptStatusV2(thresholdNetworkUrl, requestId) {
+  const startTime = Date.now();
+  let completed = false;
+  while (!completed) {
+    if (Date.now() - startTime > POLL_TIMEOUT_MS2) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt polling timed out after ${POLL_TIMEOUT_MS2}ms`,
+        hint: "The request may still be processing. Try again later.",
+        context: {
+          thresholdNetworkUrl,
+          requestId,
+          timeoutMs: POLL_TIMEOUT_MS2
+        }
+      });
+    }
+    let response;
+    try {
+      response = await fetch(`${thresholdNetworkUrl}/v2/decrypt/${requestId}`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+    } catch (e) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt status poll failed`,
+        hint: "Ensure the threshold network URL is valid and reachable.",
+        cause: e instanceof Error ? e : void 0,
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    if (response.status === 404) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt request not found: ${requestId}`,
+        hint: "The request may have expired or been invalid.",
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}`;
+      try {
+        const errorBody = await response.json();
+        const maybeMessage = errorBody.error_message || errorBody.message;
+        if (typeof maybeMessage === "string" && maybeMessage.length > 0)
+          errorMessage = maybeMessage;
+      } catch {
+        errorMessage = response.statusText || errorMessage;
       }
-    });
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `decrypt status poll failed: ${errorMessage}`,
+        context: {
+          thresholdNetworkUrl,
+          requestId,
+          status: response.status,
+          statusText: response.statusText
+        }
+      });
+    }
+    let rawJson;
+    try {
+      rawJson = await response.json();
+    } catch (e) {
+      throw new CofheError({
+        code: "DECRYPT_FAILED" /* DecryptFailed */,
+        message: `Failed to parse decrypt status response`,
+        cause: e instanceof Error ? e : void 0,
+        context: {
+          thresholdNetworkUrl,
+          requestId
+        }
+      });
+    }
+    const statusResponse = assertDecryptStatusResponseV2(rawJson);
+    if (statusResponse.status === "COMPLETED") {
+      if (statusResponse.is_succeed === false) {
+        const errorMessage = statusResponse.error_message || "Unknown error";
+        throw new CofheError({
+          code: "DECRYPT_FAILED" /* DecryptFailed */,
+          message: `decrypt request failed: ${errorMessage}`,
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      if (statusResponse.error_message) {
+        throw new CofheError({
+          code: "DECRYPT_FAILED" /* DecryptFailed */,
+          message: `decrypt request failed: ${statusResponse.error_message}`,
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      if (!Array.isArray(statusResponse.decrypted)) {
+        throw new CofheError({
+          code: "DECRYPT_RETURNED_NULL" /* DecryptReturnedNull */,
+          message: "decrypt completed but response missing <decrypted> byte array",
+          context: {
+            thresholdNetworkUrl,
+            requestId,
+            statusResponse
+          }
+        });
+      }
+      const decryptedValue = parseDecryptedBytesToBigInt(statusResponse.decrypted);
+      const signature = normalizeTnSignature(statusResponse.signature);
+      return { decryptedValue, signature };
+    }
+    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS2));
   }
-  const decryptedValue = parseDecryptedBytesToBigInt(decryptResponse.decrypted);
-  const signature = normalizeSignature(decryptResponse.signature);
-  return { decryptedValue, signature };
+  throw new CofheError({
+    code: "DECRYPT_FAILED" /* DecryptFailed */,
+    message: "Polling loop exited unexpectedly",
+    context: {
+      thresholdNetworkUrl,
+      requestId
+    }
+  });
+}
+async function tnDecryptV2(ctHash, chainId, permission, thresholdNetworkUrl) {
+  const requestId = await submitDecryptRequestV2(thresholdNetworkUrl, ctHash, chainId, permission);
+  return await pollDecryptStatusV2(thresholdNetworkUrl, requestId);
 }
 
 // core/decrypt/decryptForTxBuilder.ts
@@ -3600,7 +3739,7 @@ var DecryptForTxBuilder = class extends BaseBuilder {
     this.assertPublicClient();
     const thresholdNetworkUrl = await this.getThresholdNetworkUrl();
     const permission = permit ? PermitUtils.getPermission(permit, true) : null;
-    const { decryptedValue, signature } = await tnDecrypt(this.ctHash, this.chainId, permission, thresholdNetworkUrl);
+    const { decryptedValue, signature } = await tnDecryptV2(this.ctHash, this.chainId, permission, thresholdNetworkUrl);
     return {
       ctHash: this.ctHash,
       decryptedValue,
@@ -3808,19 +3947,19 @@ function createCofheClientBase(opts) {
       return permits.getOrCreateSharingPermit(publicClient, walletClient, options, _chainId, _account);
     },
     // Retrieval methods (auto-fill chainId/account)
-    getPermit: async (hash, chainId, account) => {
+    getPermit: (hash, chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getPermit(_chainId, _account, hash);
     },
-    getPermits: async (chainId, account) => {
+    getPermits: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getPermits(_chainId, _account);
     },
-    getActivePermit: async (chainId, account) => {
+    getActivePermit: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getActivePermit(_chainId, _account);
     },
-    getActivePermitHash: async (chainId, account) => {
+    getActivePermitHash: (chainId, account) => {
       const { chainId: _chainId, account: _account } = _getChainIdAndAccount(chainId, account);
       return permits.getActivePermitHash(_chainId, _account);
     },

package/dist/node.d.cts

@@ -1,4 +1,4 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-Y43CKbOz.cjs';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-ACVWbrXL.cjs';
 import 'viem';
 import './types-YiAC4gig.cjs';
 import 'zod';

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-PQha8zes.js';
+import { C as CofheInputConfig, a as CofheConfig, b as CofheClient } from './clientTypes-kkrRdawm.js';
 import 'viem';
 import './types-YiAC4gig.js';
 import 'zod';

package/dist/node.js

@@ -1,4 +1,4 @@
-import { createCofheConfigBase, createCofheClientBase } from './chunk-LWMRB6SD.js';
+import { createCofheConfigBase, createCofheClientBase } from './chunk-MXND5SVN.js';
 import './chunk-TBLR7NNE.js';
 import './chunk-NWDKXBIP.js';
 import { promises } from 'fs';