@cofhe/sdk 1.0.0-alpha.0 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # @cofhe/sdk Changelog
 
+## 1.0.0
+
+### Major Changes
+
+- d711ce2: 1.0.0, the first stable release. Breaking changes since 0.8, detailed in their own entries below:
+
+  - The on-chain share registry has a new layout (`share(acp, metadata)`, header-only `sharesFor` / `getShare`), and shared ACPs no longer carry a `name`.
+  - The mocks need Solidity 0.8.25 or later and `@openzeppelin/contracts-upgradeable`.
+  - `CofheProvider` takes either `config` or `cofheClient`, not both.
+
+### Minor Changes
+
+- 6dcfb7d: ACPs sharing SNAPSHOTs (ctHashes rather than live data) can use the new on-chain ACP Sharing Registry `metadata` field to cite the origin of the snapshotted data (contract address + view-function / event), and the recipient can verify it on-chain. [Docs](https://cofhesdk.fhenix.io/sdk/acp#labelling-a-snapshot-share)
+
+  **@cofhe/sdk**
+
+  - `createSharing({ labels })`, `shareOnChain(acp, { labels | metadata })`; labels travel in `export()` / `importShared` as `SharedACP.metadata`.
+  - New `client.acp.verifyShareLabels`, `client.acp.getShareFromChain`, and `describeShareMetadata`. `IncomingShare` gains `metadata` and `appKey`.
+  - New `acp.app` config option: shares are tagged with the app's key and `getIncomingShares` lists only that app's shares ([docs](https://cofhesdk.fhenix.io/sdk/acp#mark-shares-for-your-app)).
+  - `@cofhe/sdk/acps` exports the metadata codec, label builders (`viewFunctionLabel`, `eventLogLabel`, `UNLABELLED`), verifiers, registry readers, `shareAppKey` and `ERC7984_ABI`.
+
+  **@cofhe/react**
+
+  - New `useCofheShareLabels`. `useCofheShareOnChain` accepts `{ acp, labels | metadata }`.
+  - The inbox shows each share's labels and their verification. [Docs](https://cofhesdk.fhenix.io/react/acp#share-labels)
+
+  **Mocks and plugins**
+
+  - `ACPShareRegistry`, `ACPTimestampRevoker` and `Permissioned` are copied verbatim from a pinned cofhe-contracts commit (`pnpm update:cofhe-contracts <commit>`). The share registry is deployed behind `MockERC1967Proxy`.
+  - Mocks now need Solidity ≥0.8.25 and `@openzeppelin/contracts-upgradeable` (new Hardhat plugin peer dependency; Foundry users add its remapping).
+
+### Patch Changes
+
+- d711ce2: The mocks now behave like the real TaskManager and TFHE-rs in more places. Tests that relied on the old mock behaviour may start failing, as they would on a real network.
+
+  - `FHE.asE*` (trivial encrypt) reverts with `InvalidInputForFunction` when the value does not fit the type (e.g. `FHE.asEuint8(256)`), and with `InvalidSecurityZone` for an out of range zone, instead of storing the value masked.
+  - `encryptInputs` against the mocks rejects out-of-range values with the same error as the production path, instead of passing them on to be masked (e.g. `Encryptable.uint8(256n)` became `0`).
+  - `FHE.not` on encrypted integers is a bitwise NOT (`not(euint8(2))` is 253, not 0), and `FHE.rol` / `FHE.ror` rotate within the type's width, with the amount taken modulo the width, instead of shifting.
+  - `FHE.rem(x, 0)` returns `x` instead of reverting.
+  - `FHE.random*` handles carry their type and security zone and can be allowed and computed on.
+  - `MockTaskManager.isPubliclyAllowed` returns whether a handle was made public with `FHE.allowGlobal` / `FHE.allowPublic`, instead of reverting with `NotImplemented`.
+  - Handles in a negative security zone go through the ACL like any other handle. Previously any contract could use them and `FHE.allow*` did nothing.
+  - `publishDecryptResultBatch` emits `DecryptionResult` with the caller as `requestor`, and the batch decrypt result functions revert with `LengthMismatch` when the arrays differ in length.
+  - `setSecurityZones` rejects an inverted range (`min > max`) with `InvalidSecurityZone`.
+
+- 5a192ee: Node storage now creates ~/.cofhesdk with mode 0700 and files with 0600, and tightens permissions on existing ones.
+- 757e448: Use the latest chain block timestamp for injected ACP revoker data while preserving explicit revoker configuration precedence.
+- 73d5297: `seal` and `unsealWithPrivateKey` now throw when the sealing key contains non-hex characters. Previously a 64-character key with invalid characters passed the length check and those characters decoded to zero bytes, so `seal` silently encrypted to the wrong key (an entirely invalid key became the all-zero key, which offers no confidentiality), and `unsealWithPrivateKey` failed later with `Failed to decrypt message`.
+- 8fad647: `unsealWithPrivateKey` throws a `CofheError` with code `SealOutputFailed` when a decrypt response can't be unsealed, instead of a plain `Error`. `useCofheDecrypt` no longer retries these failures.
+- a4fcea7: `verifyDecryptResult` now returns `false` when the chain's TaskManager has no `decryptResultSigner` set (zero address). It used to return `true` for any signature in that case. The on-chain `verifyDecryptResult` still skips the check when no signer is set.
+
 ## 0.8.0
 
 ### Minor Changes

package/acps/onchain-utils.ts

@@ -345,9 +345,9 @@ export const clearAclServedAddresses = () => aclServedAddressesCache.clear();
  * TaskManager -> acl() -> getters). Zero addresses and pre-upgrade ACLs (getters absent -> revert)
  * resolve to `undefined` — callers fall back to `acp.*` config.
  *
- * Resolutions are cached per chainId. A failure to reach the TaskManager (network
- * error, no CoFHE deployment) is NOT cached, so a transient outage does not pin
- * an empty result for the whole session.
+ * Resolutions are cached per chainId. A failure to reach the TaskManager or the ACL
+ * getters (network error, no CoFHE deployment) is NOT cached, so a transient outage
+ * does not pin an empty result for the whole session.
  */
 export const getAclServedAddresses = async (
   publicClient: PublicClient,
@@ -367,19 +367,24 @@ export const getAclServedAddresses = async (
     return {};
   }
 
+  // A revert means the getter is missing (pre-upgrade ACL) and is safe to cache. Any other
+  // error (rate limit, timeout) is transient: return what we have but don't cache it.
+  let transient = false;
+  const readServedAddress = (functionName: 'defaultRevokerContract' | 'shareRegistry') =>
+    publicClient.readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName }).catch((err) => {
+      if (revertErrorName(err, ACL_SERVED_ADDRESSES_ABI) === undefined) transient = true;
+      return undefined;
+    });
+
   const [defaultRevoker, shareRegistry] = await Promise.all([
-    publicClient
-      .readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: 'defaultRevokerContract' })
-      .catch(() => undefined),
-    publicClient
-      .readContract({ address: aclAddress, abi: ACL_SERVED_ADDRESSES_ABI, functionName: 'shareRegistry' })
-      .catch(() => undefined),
+    readServedAddress('defaultRevokerContract'),
+    readServedAddress('shareRegistry'),
   ]);
 
   const resolved: AclServedAddresses = {
     defaultRevoker: defaultRevoker != null && defaultRevoker !== zeroAddress ? defaultRevoker : undefined,
     shareRegistry: shareRegistry != null && shareRegistry !== zeroAddress ? shareRegistry : undefined,
   };
-  aclServedAddressesCache.set(chainId, resolved);
+  if (!transient) aclServedAddressesCache.set(chainId, resolved);
   return resolved;
 };

package/acps/sealing.ts

@@ -1,6 +1,7 @@
 import nacl from 'tweetnacl';
 import { type Hex } from 'viem';
 import { fromHexString, toBeArray, toBigInt, toHexString, isBigIntOrNumber, isString } from './utils.js';
+import { CofheError, CofheErrorCode } from '../core/error.js';
 
 /** 32-byte X25519 keys as bare hex (no 0x prefix) */
 const KEY_HEX_LENGTH = 64;
@@ -74,9 +75,28 @@ export const unsealWithPrivateKey = (privateKey: string, parsedData: EthEncrypte
     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.box.open(dataToDecrypt, nonce, ephemPublicKey, fromHexString(privateKey));
+  // nacl returns null for a wrong key or tampered payload and throws on malformed inputs. Either way it
+  // is a CofheError, so callers that stop retrying on those (e.g. `useCofheDecrypt`) do not re-request.
+  let decryptedMessage: Uint8Array | null;
+  let cause: Error | undefined;
+  try {
+    decryptedMessage = nacl.box.open(dataToDecrypt, nonce, ephemPublicKey, fromHexString(privateKey));
+  } catch (e) {
+    decryptedMessage = null;
+    cause = e instanceof Error ? e : undefined;
+  }
   if (!decryptedMessage) {
-    throw new Error('Failed to decrypt message');
+    // Lengths only: the context must not carry the private key or any sealing material.
+    throw new CofheError({
+      code: CofheErrorCode.SealOutputFailed,
+      message: 'Failed to unseal decrypt response',
+      cause,
+      context: {
+        dataLength: dataToDecrypt.length,
+        nonceLength: nonce.length,
+        publicKeyLength: ephemPublicKey.length,
+      },
+    });
   }
 
   return toBigInt(decryptedMessage);

package/acps/test/aclServedAddresses.test.ts

@@ -0,0 +1,65 @@
+import { ContractFunctionRevertedError, HttpRequestError, parseAbi } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { clearTaskManagerAddressCache } from '../../core/taskManager.js';
+import { clearAclServedAddresses, getAclServedAddresses } from '../onchain-utils.js';
+
+const CHAIN_ID = 421614;
+const TASK_MANAGER = '0x0000000000000000000000000000000000005000';
+const ACL = '0x00000000000000000000000000000000000000dd';
+const REVOKER = '0x00000000000000000000000000000000000000cc';
+const REGISTRY = '0x00000000000000000000000000000000000000ee';
+
+const GETTERS_ABI = parseAbi([
+  'function defaultRevokerContract() view returns (address)',
+  'function shareRegistry() view returns (address)',
+]);
+
+function clientWithGetters(getter: (functionName: string) => Promise<unknown>) {
+  return {
+    readContract: vi.fn(async ({ functionName }: { functionName: string }) => {
+      if (functionName === 'getTm') return TASK_MANAGER;
+      if (functionName === 'acl') return ACL;
+      return getter(functionName);
+    }),
+  } as any;
+}
+
+describe('getAclServedAddresses', () => {
+  beforeEach(() => {
+    clearAclServedAddresses();
+    clearTaskManagerAddressCache();
+  });
+
+  it('does not cache a transient failure of the ACL getters', async () => {
+    let down = true;
+    const publicClient = clientWithGetters(async (functionName) => {
+      if (down) throw new HttpRequestError({ url: 'http://rpc', status: 429 });
+      return functionName === 'defaultRevokerContract' ? REVOKER : REGISTRY;
+    });
+
+    expect(await getAclServedAddresses(publicClient, CHAIN_ID)).toEqual({
+      defaultRevoker: undefined,
+      shareRegistry: undefined,
+    });
+
+    down = false;
+    expect(await getAclServedAddresses(publicClient, CHAIN_ID)).toEqual({
+      defaultRevoker: REVOKER,
+      shareRegistry: REGISTRY,
+    });
+  });
+
+  it('caches a pre-upgrade ACL whose getters revert', async () => {
+    const publicClient = clientWithGetters(async (functionName) => {
+      throw new ContractFunctionRevertedError({ abi: GETTERS_ABI, functionName, data: '0x' });
+    });
+
+    const expected = { defaultRevoker: undefined, shareRegistry: undefined };
+    expect(await getAclServedAddresses(publicClient, CHAIN_ID)).toEqual(expected);
+    const calls = publicClient.readContract.mock.calls.length;
+
+    expect(await getAclServedAddresses(publicClient, CHAIN_ID)).toEqual(expected);
+    expect(publicClient.readContract.mock.calls.length).toBe(calls);
+  });
+});

package/acps/test/sealing.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { GenerateSealingKey, seal, unsealWithPrivateKey } from '../index.js';
+import { CofheError, CofheErrorCode } from '../../core/error.js';
 
 describe('seal / unsealWithPrivateKey', () => {
   it('should seal data into EthEncryptedData shape', () => {
@@ -80,6 +81,56 @@ describe('seal / unsealWithPrivateKey', () => {
       seal('not a number', publicKey);
     }).toThrow('Value not a number is not a number or bigint: string');
   });
+
+  describe('unseal failures are CofheErrors', () => {
+    const expectUnsealFailed = (fn: () => unknown, secrets: string[] = []) => {
+      let thrown: unknown;
+      try {
+        fn();
+      } catch (e) {
+        thrown = e;
+      }
+      expect(thrown).toBeInstanceOf(CofheError);
+      expect((thrown as CofheError).code).toBe(CofheErrorCode.SealOutputFailed);
+      const serialized = (thrown as CofheError).serialize();
+      for (const secret of secrets) expect(serialized).not.toContain(secret.replace(/^0x/, ''));
+    };
+
+    it('throws SealOutputFailed when unsealing with the wrong private key', () => {
+      const pair = GenerateSealingKey();
+      const other = GenerateSealingKey();
+      const sealed = seal(BigInt(42), pair.publicKey);
+
+      expectUnsealFailed(() => unsealWithPrivateKey(other.privateKey, sealed), [other.privateKey, pair.privateKey]);
+    });
+
+    it('throws SealOutputFailed when the sealed payload is corrupted', () => {
+      const pair = GenerateSealingKey();
+      const sealed = seal(BigInt(42), pair.publicKey);
+      const corrupted = { ...sealed, data: Uint8Array.from(sealed.data) };
+      corrupted.data[0] ^= 0xff;
+
+      expectUnsealFailed(() => unsealWithPrivateKey(pair.privateKey, corrupted), [pair.privateKey]);
+    });
+
+    it('throws SealOutputFailed, keeping the cause, when nacl rejects malformed inputs', () => {
+      const pair = GenerateSealingKey();
+      const sealed = seal(BigInt(42), pair.publicKey);
+      const shortNonce = { ...sealed, nonce: sealed.nonce.slice(0, 4) };
+
+      expectUnsealFailed(() => unsealWithPrivateKey(pair.privateKey, shortNonce), [pair.privateKey]);
+      try {
+        unsealWithPrivateKey(pair.privateKey, shortNonce);
+      } catch (e) {
+        expect((e as CofheError).cause).toBeInstanceOf(Error);
+      }
+    });
+
+    it('still reports a malformed sealing key as a plain key error, not a seal failure', () => {
+      const sealed = seal(BigInt(1), GenerateSealingKey().publicKey);
+      expect(() => unsealWithPrivateKey('deadbeef', sealed)).toThrow('Private key must be of length 64');
+    });
+  });
 });
 
 describe('GenerateSealingKey', () => {

package/dist/acps.cjs

@@ -66,6 +66,100 @@ function isBigIntOrNumber(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 = () => {
@@ -93,9 +187,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);
 };
@@ -412,100 +522,6 @@ var COFHE_ADDRESS_BOOK_ADDRESS = "0xC0F4e00E531a2B086492Ae3DCC1515038307196b";
 var TASK_MANAGER_ID = 1n;
 BigInt(1 << 30);
 
-// 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)",
@@ -813,15 +829,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;
 };
 

package/dist/acps.d.cts

@@ -1,5 +1,5 @@
-import { A as ACP, S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-D9Z33IP7.cjs';
-export { O as ACPAccessStatus, P as ACPHashFields, h as ACPMetadata, H as ACPOf, D as ACPPrivate, M as ACPScope, N as ACPScopeOptions, F as ACPType, l as ACPUtils, p as AclServedAddresses, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, B as EIP712Type, r as EthEncryptedData, Q as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, v as LabelVerification, R as RecipientACP, q as SealingKeyPair, J as SelfACP, C as SelfACPOptions, x as ShareLabelCheck, t as ShareLabelReadArg, w as ShareLabelVerifyMode, i as SharedACP, K as SharingACP, g as SharingACPOptions, U as UnlabelledLabel, o as clearAclServedAddresses, m as getAclAddress, n as getAclServedAddresses, s as seal, u as unsealWithPrivateKey, y as verifyShareLabel, z as verifyShareLabels } from './onchain-utils-D9Z33IP7.cjs';
+import { A as ACP, S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-CgOslubH.cjs';
+export { O as ACPAccessStatus, P as ACPHashFields, h as ACPMetadata, H as ACPOf, D as ACPPrivate, M as ACPScope, N as ACPScopeOptions, F as ACPType, l as ACPUtils, p as AclServedAddresses, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, B as EIP712Type, r as EthEncryptedData, Q as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, v as LabelVerification, R as RecipientACP, q as SealingKeyPair, J as SelfACP, C as SelfACPOptions, x as ShareLabelCheck, t as ShareLabelReadArg, w as ShareLabelVerifyMode, i as SharedACP, K as SharingACP, g as SharingACPOptions, U as UnlabelledLabel, o as clearAclServedAddresses, m as getAclAddress, n as getAclServedAddresses, s as seal, u as unsealWithPrivateKey, y as verifyShareLabel, z as verifyShareLabels } from './onchain-utils-CgOslubH.cjs';
 import { Hex, AbiParameterToPrimitiveType, Address, PublicClient, Abi, ContractFunctionName, ContractFunctionArgs, Log } from 'viem';
 import { z } from 'zod';
 import * as zustand_middleware from 'zustand/middleware';

package/dist/acps.d.ts

@@ -1,5 +1,5 @@
-import { A as ACP, S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-D9Z33IP7.js';
-export { O as ACPAccessStatus, P as ACPHashFields, h as ACPMetadata, H as ACPOf, D as ACPPrivate, M as ACPScope, N as ACPScopeOptions, F as ACPType, l as ACPUtils, p as AclServedAddresses, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, B as EIP712Type, r as EthEncryptedData, Q as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, v as LabelVerification, R as RecipientACP, q as SealingKeyPair, J as SelfACP, C as SelfACPOptions, x as ShareLabelCheck, t as ShareLabelReadArg, w as ShareLabelVerifyMode, i as SharedACP, K as SharingACP, g as SharingACPOptions, U as UnlabelledLabel, o as clearAclServedAddresses, m as getAclAddress, n as getAclServedAddresses, s as seal, u as unsealWithPrivateKey, y as verifyShareLabel, z as verifyShareLabels } from './onchain-utils-D9Z33IP7.js';
+import { A as ACP, S as ShareLabel, a as StoredValueLabel, E as EventValueLabel, L as LabelledShare, V as ValidationResult, b as ACPPublic, c as ACPSignaturePrimaryType, d as EIP712Types, e as EIP712Message, f as SerializedACP } from './onchain-utils-CgOslubH.js';
+export { O as ACPAccessStatus, P as ACPHashFields, h as ACPMetadata, H as ACPOf, D as ACPPrivate, M as ACPScope, N as ACPScopeOptions, F as ACPType, l as ACPUtils, p as AclServedAddresses, C as CreateSelfACPOptions, g as CreateSharingACPOptions, k as EIP712Domain, B as EIP712Type, r as EthEncryptedData, Q as Expand, G as GenerateSealingKey, I as ImportACPOptions, I as ImportSharedACPOptions, j as IncomingShare, v as LabelVerification, R as RecipientACP, q as SealingKeyPair, J as SelfACP, C as SelfACPOptions, x as ShareLabelCheck, t as ShareLabelReadArg, w as ShareLabelVerifyMode, i as SharedACP, K as SharingACP, g as SharingACPOptions, U as UnlabelledLabel, o as clearAclServedAddresses, m as getAclAddress, n as getAclServedAddresses, s as seal, u as unsealWithPrivateKey, y as verifyShareLabel, z as verifyShareLabels } from './onchain-utils-CgOslubH.js';
 import { Hex, AbiParameterToPrimitiveType, Address, PublicClient, Abi, ContractFunctionName, ContractFunctionArgs, Log } from 'viem';
 import { z } from 'zod';
 import * as zustand_middleware from 'zustand/middleware';

package/dist/acps.js

@@ -1,2 +1,2 @@
-export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-BQWHPIYU.js';
-import './chunk-XQ32JG3T.js';
+export { ACPScope, ACPUtils, ACP_REVOKER_ABI, ACP_SHARE_REGISTRY_ABI, ACP_SHARE_TUPLE_ABI, ACP_STORE_DEFAULTS, ERC7984_ABI, GenerateSealingKey, ImportACPOptionsValidator, ImportACPValidator, LAYOUT_VERSION as SHARE_METADATA_VERSION, SelfACPOptionsValidator, SelfACPValidator, SharingACPOptionsValidator, SharingACPValidator, SignatureTypes, SignatureUtils, UNLABELLED, ValidationUtils, _acpStore, acpStore, addressNotZeroSchema, addressSchema, bytesNotEmptySchema, bytesSchema, clearAclServedAddresses, clearStaleStore, computeShareId, contractsSchema, decodeShareAppKey, decodeShareMetadata, decodeShareMetadataFull, describeShareLabels, describeShareMetadata, encodeShareMetadata, eventLogLabel, getACP, getACPs, getAclAddress, getAclServedAddresses, getActiveACP, getActiveACPHash, getSignatureTypesAndMessage, handlesSchema, readPostedShares, readShare, readSharesFor, removeACP, removeActiveACPHash, resetStore, seal, setACP, setActiveACPHash, shareAppKey, shareIdOfChainShare, toChainShare, unsealWithPrivateKey, validateImportACP, validateImportACPOptions, validateSelfACP, validateSelfACPOptions, validateSharingACP, validateSharingACPOptions, verifyShareLabel, verifyShareLabels, viewFunctionLabel } from './chunk-3L2IVPMI.js';
+import './chunk-J23FYAI2.js';

package/dist/{chunk-BQWHPIYU.js → chunk-3L2IVPMI.js}

@@ -1,4 +1,4 @@
-import { TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS, CofheError } from './chunk-XQ32JG3T.js';
+import { CofheError, TASK_MANAGER_ID, COFHE_ADDRESS_BOOK_ADDRESS } from './chunk-J23FYAI2.js';
 import { isAddress, getAddress, zeroAddress, isHex, parseAbi, keccak256, padHex, numberToHex, concatHex, toFunctionSelector, size, sliceHex, toHex, encodeAbiParameters, hexToBigInt, stringToHex, hexToNumber, toEventSignature, toFunctionSignature, decodeErrorResult, toEventSelector, decodeAbiParameters } from 'viem';
 import nacl from 'tweetnacl';
 import { z } from 'zod';
@@ -86,9 +86,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.box.open(dataToDecrypt, nonce, ephemPublicKey, fromHexString(privateKey));
+  let decryptedMessage;
+  let cause;
+  try {
+    decryptedMessage = nacl.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);
 };
@@ -705,15 +721,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 !== zeroAddress ? defaultRevoker : void 0,
     shareRegistry: shareRegistry != null && shareRegistry !== zeroAddress ? shareRegistry : void 0
   };
-  aclServedAddressesCache.set(chainId, resolved);
+  if (!transient)
+    aclServedAddressesCache.set(chainId, resolved);
   return resolved;
 };
 

package/dist/{chunk-OL3DZN7A.js → chunk-O2ITEUEU.js}

@@ -1,7 +1,7 @@
 import { hardhat as hardhat$1 } from './chunk-UKQAJK4N.js';
-import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, ACP_SHARE_REGISTRY_ABI, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-BQWHPIYU.js';
-import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-6ZW76ZKB.js';
-import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-XQ32JG3T.js';
+import { acpStore, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACPUtils, getTaskManagerAddress, verifyShareLabels, decodeShareMetadata, shareAppKey, ACP_SHARE_REGISTRY_ABI, readShare, readSharesFor, toChainShare, ACP_REVOKER_ABI, decodeShareAppKey, encodeShareMetadata } from './chunk-3L2IVPMI.js';
+import { sleep, getPublicClientChainID, getWalletClientAccount, validateBigIntInRange, toBigIntOrThrow, hexToBytes, toHexString, FheUintUTypes } from './chunk-WJGTPW7K.js';
+import { TFHE_RS_KEY_VERSION, CofheError, TFHE_RS_ZK_MAX_BITS, TFHE_RS_SAFE_SERIALIZATION_SIZE_LIMIT, MOCKS_THRESHOLD_NETWORK_ADDRESS, MOCKS_DECRYPT_RESULT_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_SIGNER_PRIVATE_KEY, MOCKS_ZK_VERIFIER_ADDRESS } from './chunk-J23FYAI2.js';
 import { createStore } from 'zustand/vanilla';
 import { parseAbi, isAddressEqual, zeroAddress, recoverAddress, encodePacked, keccak256, createWalletClient, http, getAddress, parseSignature, serializeSignature } from 'viem';
 import { hardhat } from 'viem/chains';

package/dist/{chunk-6ZW76ZKB.js → chunk-WJGTPW7K.js}

@@ -1,4 +1,4 @@
-import { CofheError } from './chunk-XQ32JG3T.js';
+import { CofheError } from './chunk-J23FYAI2.js';
 import 'viem';
 
 // core/types.ts

package/dist/{clientTypes-C0A9ji5O.d.cts → clientTypes-IO6b5Um8.d.cts}

@@ -1,7 +1,7 @@
 import { WalletClient, PublicClient, Hex } from 'viem';
 import { C as CofheChain } from './types-C07FK-cL.cjs';
 import { z } from 'zod';
-import { A as ACP, k as EIP712Domain, C as CreateSelfACPOptions, J as SelfACP, g as CreateSharingACPOptions, K as SharingACP, I as ImportSharedACPOptions, R as RecipientACP, P as ACPHashFields, f as SerializedACP, O as ACPAccessStatus, S as ShareLabel, j as IncomingShare, p as AclServedAddresses, L as LabelledShare, w as ShareLabelVerifyMode, x as ShareLabelCheck, l as ACPUtils } from './onchain-utils-D9Z33IP7.cjs';
+import { A as ACP, k as EIP712Domain, C as CreateSelfACPOptions, J as SelfACP, g as CreateSharingACPOptions, K as SharingACP, I as ImportSharedACPOptions, R as RecipientACP, P as ACPHashFields, f as SerializedACP, O as ACPAccessStatus, S as ShareLabel, j as IncomingShare, p as AclServedAddresses, L as LabelledShare, w as ShareLabelVerifyMode, x as ShareLabelCheck, l as ACPUtils } from './onchain-utils-CgOslubH.cjs';
 import { StoreApi } from 'zustand/vanilla';
 
 type TfheInitializer = () => Promise<boolean>;