@cofhe/sdk 1.0.0-alpha.0 → 1.1.0-alpha.0

package/dist/web.cjs

@@ -43,6 +43,100 @@ function toBigInt(value) {
   }
 }
 
+// core/error.ts
+var CofheError = class _CofheError extends Error {
+  code;
+  cause;
+  hint;
+  context;
+  apiErrorCode;
+  constructor({ code, message, cause, hint, context, apiErrorCode }) {
+    const fullMessage = cause ? `${message} | Caused by: ${cause.message}` : message;
+    super(fullMessage);
+    this.name = "CofheError";
+    this.code = code;
+    this.cause = cause;
+    this.hint = hint;
+    this.context = context;
+    this.apiErrorCode = apiErrorCode;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _CofheError);
+    }
+  }
+  /**
+   * Creates a CofheError from an unknown error
+   * If the error is a CofheError, it is returned unchanged, else a new CofheError is created
+   * If a wrapperError is provided, it is used to create the new CofheError, else a default is used
+   */
+  static fromError(error, wrapperError) {
+    if (isCofheError(error))
+      return error;
+    const cause = error instanceof Error ? error : new Error(`${error}`);
+    return new _CofheError({
+      code: wrapperError?.code ?? "INTERNAL_ERROR" /* InternalError */,
+      message: wrapperError?.message ?? "An internal error occurred",
+      hint: wrapperError?.hint,
+      context: wrapperError?.context,
+      apiErrorCode: wrapperError?.apiErrorCode,
+      cause
+    });
+  }
+  /**
+   * Serializes the error to JSON string with proper handling of Error objects
+   */
+  serialize() {
+    return bigintSafeJsonStringify({
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      hint: this.hint,
+      context: this.context,
+      apiErrorCode: this.apiErrorCode,
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message,
+        stack: this.cause.stack
+      } : void 0,
+      stack: this.stack
+    });
+  }
+  /**
+   * Returns a human-readable string representation of the error
+   */
+  toString() {
+    const codeSuffix = this.apiErrorCode ? ` (api: ${this.apiErrorCode})` : "";
+    const parts = [`${this.name} [${this.code}]${codeSuffix}: ${this.message}`];
+    if (this.hint) {
+      parts.push(`Hint: ${this.hint}`);
+    }
+    if (this.context && Object.keys(this.context).length > 0) {
+      parts.push(`Context: ${bigintSafeJsonStringify(this.context)}`);
+    }
+    if (this.stack) {
+      parts.push(`
+Stack trace:`);
+      parts.push(this.stack);
+    }
+    if (this.cause) {
+      parts.push(`
+Caused by: ${this.cause.name}: ${this.cause.message}`);
+      if (this.cause.stack) {
+        parts.push(this.cause.stack);
+      }
+    }
+    return parts.join("\n");
+  }
+};
+var bigintSafeJsonStringify = (value) => {
+  return JSON.stringify(value, (key, value2) => {
+    if (typeof value2 === "bigint") {
+      return `${value2}n`;
+    }
+    return value2;
+  });
+};
+var isCofheError = (error) => error instanceof CofheError;
+
 // acps/sealing.ts
 var KEY_HEX_LENGTH = 64;
 var GenerateSealingKey = () => {
@@ -57,9 +151,25 @@ var unsealWithPrivateKey = (privateKey, parsedData) => {
   const nonce = parsedData.nonce instanceof Uint8Array ? parsedData.nonce : new Uint8Array(parsedData.nonce);
   const ephemPublicKey = parsedData.public_key instanceof Uint8Array ? parsedData.public_key : new Uint8Array(parsedData.public_key);
   const dataToDecrypt = parsedData.data instanceof Uint8Array ? parsedData.data : new Uint8Array(parsedData.data);
-  const decryptedMessage = nacl__default.default.box.open(dataToDecrypt, nonce, ephemPublicKey, fromHexString(privateKey));
+  let decryptedMessage;
+  let cause;
+  try {
+    decryptedMessage = nacl__default.default.box.open(dataToDecrypt, nonce, ephemPublicKey, fromHexString(privateKey));
+  } catch (e) {
+    decryptedMessage = null;
+    cause = e instanceof Error ? e : void 0;
+  }
   if (!decryptedMessage) {
-    throw new Error("Failed to decrypt message");
+    throw new CofheError({
+      code: "SEAL_OUTPUT_FAILED" /* SealOutputFailed */,
+      message: "Failed to unseal decrypt response",
+      cause,
+      context: {
+        dataLength: dataToDecrypt.length,
+        nonceLength: nonce.length,
+        publicKeyLength: ephemPublicKey.length
+      }
+    });
   }
   return toBigInt(decryptedMessage);
 };
@@ -377,100 +487,6 @@ var TFHE_RS_ZK_MAX_BITS = 2048;
 var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
 var TFHE_RS_KEY_VERSION = 2;
 
-// core/error.ts
-var CofheError = class _CofheError extends Error {
-  code;
-  cause;
-  hint;
-  context;
-  apiErrorCode;
-  constructor({ code, message, cause, hint, context, apiErrorCode }) {
-    const fullMessage = cause ? `${message} | Caused by: ${cause.message}` : message;
-    super(fullMessage);
-    this.name = "CofheError";
-    this.code = code;
-    this.cause = cause;
-    this.hint = hint;
-    this.context = context;
-    this.apiErrorCode = apiErrorCode;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _CofheError);
-    }
-  }
-  /**
-   * Creates a CofheError from an unknown error
-   * If the error is a CofheError, it is returned unchanged, else a new CofheError is created
-   * If a wrapperError is provided, it is used to create the new CofheError, else a default is used
-   */
-  static fromError(error, wrapperError) {
-    if (isCofheError(error))
-      return error;
-    const cause = error instanceof Error ? error : new Error(`${error}`);
-    return new _CofheError({
-      code: wrapperError?.code ?? "INTERNAL_ERROR" /* InternalError */,
-      message: wrapperError?.message ?? "An internal error occurred",
-      hint: wrapperError?.hint,
-      context: wrapperError?.context,
-      apiErrorCode: wrapperError?.apiErrorCode,
-      cause
-    });
-  }
-  /**
-   * Serializes the error to JSON string with proper handling of Error objects
-   */
-  serialize() {
-    return bigintSafeJsonStringify({
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      hint: this.hint,
-      context: this.context,
-      apiErrorCode: this.apiErrorCode,
-      cause: this.cause ? {
-        name: this.cause.name,
-        message: this.cause.message,
-        stack: this.cause.stack
-      } : void 0,
-      stack: this.stack
-    });
-  }
-  /**
-   * Returns a human-readable string representation of the error
-   */
-  toString() {
-    const codeSuffix = this.apiErrorCode ? ` (api: ${this.apiErrorCode})` : "";
-    const parts = [`${this.name} [${this.code}]${codeSuffix}: ${this.message}`];
-    if (this.hint) {
-      parts.push(`Hint: ${this.hint}`);
-    }
-    if (this.context && Object.keys(this.context).length > 0) {
-      parts.push(`Context: ${bigintSafeJsonStringify(this.context)}`);
-    }
-    if (this.stack) {
-      parts.push(`
-Stack trace:`);
-      parts.push(this.stack);
-    }
-    if (this.cause) {
-      parts.push(`
-Caused by: ${this.cause.name}: ${this.cause.message}`);
-      if (this.cause.stack) {
-        parts.push(this.cause.stack);
-      }
-    }
-    return parts.join("\n");
-  }
-};
-var bigintSafeJsonStringify = (value) => {
-  return JSON.stringify(value, (key, value2) => {
-    if (typeof value2 === "bigint") {
-      return `${value2}n`;
-    }
-    return value2;
-  });
-};
-var isCofheError = (error) => error instanceof CofheError;
-
 // core/taskManager.ts
 var ADDRESS_BOOK_ABI = viem.parseAbi([
   "function getTm(uint256 id) view returns (address)",
@@ -778,15 +794,22 @@ var getAclServedAddresses = async (publicClient, chainId) => {
   } catch {
     return {};
   }
+  let transient = false;
+  const readServedAddress = (functionName) => publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName }).catch((err) => {
+    if (revertErrorName(err, ACL_SERVED_ADDRESSES_ABI) === void 0)
+      transient = true;
+    return void 0;
+  });
   const [defaultRevoker, shareRegistry] = await Promise.all([
-    publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: "defaultRevokerContract" }).catch(() => void 0),
-    publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: "shareRegistry" }).catch(() => void 0)
+    readServedAddress("defaultRevokerContract"),
+    readServedAddress("shareRegistry")
   ]);
   const resolved = {
     defaultRevoker: defaultRevoker != null && defaultRevoker !== viem.zeroAddress ? defaultRevoker : void 0,
     shareRegistry: shareRegistry != null && shareRegistry !== viem.zeroAddress ? shareRegistry : void 0
   };
-  aclServedAddressesCache.set(chainId, resolved);
+  if (!transient)
+    aclServedAddressesCache.set(chainId, resolved);
   return resolved;
 };
 
@@ -3269,23 +3292,25 @@ var getBlockRevokerData = async (publicClient) => {
   }
   return revokerData;
 };
-var revokeACP = async (acp, walletClient) => {
+var prepareRevokeACP = (acp) => {
   if (acp.revokerContract === viem.zeroAddress || acp.revokerData === 0) {
     throw new Error("ACP is not revocable: it has no revoker (revokerContract/revokerData unset)");
   }
+  return {
+    address: acp.revokerContract,
+    abi: ACP_REVOKER_ABI,
+    functionName: "revokeSingle",
+    args: [BigInt(acp.revokerData)]
+  };
+};
+var revokeACP = async (acp, walletClient) => {
+  const write = prepareRevokeACP(acp);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the acp issuer can revoke it");
   }
-  return walletClient.writeContract({
-    address: acp.revokerContract,
-    abi: ACP_REVOKER_ABI,
-    functionName: "revokeSingle",
-    args: [BigInt(acp.revokerData)],
-    account: walletClient.account,
-    chain: walletClient.chain
-  });
+  return walletClient.writeContract({ ...write, account: walletClient.account, chain: walletClient.chain });
 };
 var revokeAllACPs = async (walletClient, publicClient, revokerContract) => {
   if (walletClient.account == null)
@@ -3336,28 +3361,36 @@ var metadataOf = (acp, { labels, metadata, appKey }) => {
   }
   return encodeShareMetadata(labels, { issuer: acp.issuer, appKey });
 };
-var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+var prepareShareOnChain = (acp, registry, options = {}) => {
   if (acp.type !== "sharing") {
     throw new Error(`Cannot share a '${acp.type}' ACP on-chain \u2014 only 'sharing' ACPs are shareable.`);
   }
   if (acp.issuerSignature === "0x") {
     throw new Error("Cannot share an unsigned sharing ACP \u2014 sign it first.");
   }
+  return {
+    write: {
+      address: registry,
+      abi: ACP_SHARE_REGISTRY_ABI,
+      functionName: "share",
+      args: [toChainShare(acp), metadataOf(acp, options)]
+    },
+    shareId: computeShareId(acp)
+  };
+};
+var shareOnChain = async (acp, walletClient, registry, options = {}) => {
+  const { write, shareId } = prepareShareOnChain(acp, registry, options);
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   if (walletClient.account.address.toLowerCase() !== acp.issuer.toLowerCase()) {
     throw new Error("Only the ACP issuer can share it on-chain");
   }
-  const metadata = metadataOf(acp, options);
   const txHash = await walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "share",
-    args: [toChainShare(acp), metadata],
+    ...write,
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
-  return { txHash, shareId: computeShareId(acp) };
+  return { txHash, shareId };
 };
 var toIncomingShare = ({ shareId, share: s, metadata }) => ({
   shareId,
@@ -3392,14 +3425,17 @@ var importFromChain = async (share, publicClient, walletClient, importOptions =
   const { shareId: _shareId, appKey: _appKey, ...options } = share;
   return importShared({ ...options, type: "sharing" }, publicClient, walletClient, importOptions);
 };
+var prepareRemoveShare = (shareId, registry) => ({
+  address: registry,
+  abi: ACP_SHARE_REGISTRY_ABI,
+  functionName: "removeShare",
+  args: [shareId]
+});
 var removeShareOnChain = async (shareId, walletClient, registry) => {
   if (walletClient.account == null)
     throw new Error("Missing walletClient account");
   return walletClient.writeContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "removeShare",
-    args: [shareId],
+    ...prepareRemoveShare(shareId, registry),
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
@@ -3426,14 +3462,17 @@ var acps = {
   selectActiveACP,
   removeActiveACP,
   revokeACP,
+  prepareRevokeACP,
   revokeAllACPs,
   isACPRevoked,
   checkAccess,
   shareOnChain,
+  prepareShareOnChain,
   getIncomingShares,
   getShareFromChain,
   importFromChain,
   removeShareOnChain,
+  prepareRemoveShare,
   computeShareId,
   applyACPDefaultsFromChain,
   getAclServedAddresses,
@@ -5209,6 +5248,12 @@ function createCofheClientBase(opts) {
       });
     }
   };
+  const _requireIssuer = (acp, what) => {
+    const sender = connectStore.getState().walletClient?.account?.address;
+    if (sender == null || sender.toLowerCase() !== acp.issuer.toLowerCase()) {
+      throw new Error(`Only the acp issuer can ${what}`);
+    }
+  };
   async function connect(publicClient, walletClient) {
     const state = connectStore.getState();
     if (state.connected && state.publicClient === publicClient && state.walletClient === walletClient)
@@ -5376,6 +5421,11 @@ function createCofheClientBase(opts) {
       const { walletClient } = connectStore.getState();
       return acps.revokeACP(acp, walletClient);
     },
+    prepareRevokeACP: (acp) => {
+      _requireConnected();
+      _requireIssuer(acp, "revoke it");
+      return acps.prepareRevokeACP(acp);
+    },
     revokeAllACPs: async (revokerContract) => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();
@@ -5399,6 +5449,21 @@ function createCofheClientBase(opts) {
       const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
       return acps.shareOnChain(acp, walletClient, sharingRegistry, { ...withAppKey(), ...options });
     },
+    prepareShareOnChain: async (acp, options) => {
+      _requireConnected();
+      _requireIssuer(acp, "share it on-chain");
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareShareOnChain(acp, sharingRegistry, { ...withAppKey(), ...options });
+    },
+    prepareRemoveShare: async (shareId) => {
+      _requireConnected();
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.prepareRemoveShare(shareId, sharingRegistry);
+    },
     getIncomingShares: async () => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();

package/dist/web.d.cts

@@ -1,8 +1,8 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-C0A9ji5O.cjs';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-RXwLVWou.cjs';
 import 'viem';
 import './types-C07FK-cL.cjs';
 import 'zod';
-import './onchain-utils-D9Z33IP7.cjs';
+import './onchain-utils-Ns56cBm0.cjs';
 import 'zustand/vanilla';
 
 declare function createSsrStorage(): IStorage;

package/dist/web.d.ts

@@ -1,8 +1,8 @@
-import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-CcU5WvdV.js';
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-CnslFzxB.js';
 import 'viem';
 import './types-C07FK-cL.js';
 import 'zod';
-import './onchain-utils-D9Z33IP7.js';
+import './onchain-utils-Ns56cBm0.js';
 import 'zustand/vanilla';
 
 declare function createSsrStorage(): IStorage;

package/dist/web.js

@@ -1,9 +1,9 @@
-import { createCofheConfigBase, createCofheClientBase } from './chunk-OL3DZN7A.js';
+import { createCofheConfigBase, createCofheClientBase } from './chunk-2EO4JSR7.js';
 import './chunk-UKQAJK4N.js';
-import './chunk-BQWHPIYU.js';
+import './chunk-3L2IVPMI.js';
 import { initTfheThreadPool } from './chunk-KSOV5B4B.js';
-import { fheTypeToString, fromHexString } from './chunk-6ZW76ZKB.js';
-import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-XQ32JG3T.js';
+import { fheTypeToString, fromHexString } from './chunk-WJGTPW7K.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-J23FYAI2.js';
 import { constructClient } from 'iframe-shared-storage';
 
 // web/const.ts

package/dist/zkProve.worker.js

@@ -1,6 +1,6 @@
 import { initTfheThreadPool } from './chunk-KSOV5B4B.js';
-import { fromHexString } from './chunk-6ZW76ZKB.js';
-import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-XQ32JG3T.js';
+import { fromHexString } from './chunk-WJGTPW7K.js';
+import { TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT } from './chunk-J23FYAI2.js';
 
 // web/zkProve.worker.ts
 var tfheModule = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cofhe/sdk",
-  "version": "1.0.0-alpha.0",
+  "version": "1.1.0-alpha.0",
   "type": "module",
   "description": "SDK for Fhenix COFHE coprocessor interaction",
   "main": "./dist/core.cjs",

package/dist/{chunk-XQ32JG3T.js → chunk-J23FYAI2.js}

@@ -1,16 +1,3 @@
-// core/consts.ts
-var COFHE_ADDRESS_BOOK_ADDRESS = "0xC0F4e00E531a2B086492Ae3DCC1515038307196b";
-var TASK_MANAGER_ID = 1n;
-var MOCKS_TASK_MANAGER_ADDRESS = "0x0000000000000000000000000000000000005000";
-var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
-var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
-var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
-var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
-var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
-var TFHE_RS_ZK_MAX_BITS = 2048;
-var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
-var TFHE_RS_KEY_VERSION = 2;
-
 // core/error.ts
 var CofheErrorCode = /* @__PURE__ */ ((CofheErrorCode2) => {
   CofheErrorCode2["InternalError"] = "INTERNAL_ERROR";
@@ -171,4 +158,17 @@ var bigintSafeJsonStringify = (value) => {
 };
 var isCofheError = (error) => error instanceof CofheError;
 
+// core/consts.ts
+var COFHE_ADDRESS_BOOK_ADDRESS = "0xC0F4e00E531a2B086492Ae3DCC1515038307196b";
+var TASK_MANAGER_ID = 1n;
+var MOCKS_TASK_MANAGER_ADDRESS = "0x0000000000000000000000000000000000005000";
+var MOCKS_ZK_VERIFIER_ADDRESS = "0x0000000000000000000000000000000000005001";
+var MOCKS_THRESHOLD_NETWORK_ADDRESS = "0x0000000000000000000000000000000000005002";
+var MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY = "0x6C8D7F768A6BB4AAFE85E8A2F5A9680355239C7E14646ED62B044E39DE154512";
+var MOCKS_ZK_VERIFIER_SIGNER_ADDRESS = "0x6E12D8C87503D4287c294f2Fdef96ACd9DFf6bd2";
+var MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
+var TFHE_RS_ZK_MAX_BITS = 2048;
+var TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT = BigInt(1 << 30);
+var TFHE_RS_KEY_VERSION = 2;
+
 export { COFHE_ADDRESS_BOOK_ADDRESS, CofheError, CofheErrorCode, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_TASK_MANAGER_ADDRESS, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_ZK_VERIFIER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_ADDRESS, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, TASK_MANAGER_ID, TFHE_RS_KEY_VERSION, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, TFHE_RS_ZK_MAX_BITS, isCofheError };