@cofhe/sdk 0.8.0 → 1.0.0

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

@@ -1,6 +1,7 @@
 import { hardhat as hardhat$1 } from './chunk-UKQAJK4N.js';
-import { acpStore, CofheError, clearAclServedAddresses, getAclServedAddresses, computeShareId, ACPUtils, getTaskManagerAddress, ACP_SHARE_REGISTRY_ABI, shareIdOfChainShare, toChainShare, ACP_REVOKER_ABI } from './chunk-UJYOBHYA.js';
-import { TFHE_RS_KEY_VERSION, 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-NMKMCAI3.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';
@@ -9,224 +10,6 @@ import { z } from 'zod';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import { produce } from 'immer';
 
-// core/types.ts
-var FheTypes = /* @__PURE__ */ ((FheTypes2) => {
-  FheTypes2[FheTypes2["Bool"] = 0] = "Bool";
-  FheTypes2[FheTypes2["Uint4"] = 1] = "Uint4";
-  FheTypes2[FheTypes2["Uint8"] = 2] = "Uint8";
-  FheTypes2[FheTypes2["Uint16"] = 3] = "Uint16";
-  FheTypes2[FheTypes2["Uint32"] = 4] = "Uint32";
-  FheTypes2[FheTypes2["Uint64"] = 5] = "Uint64";
-  FheTypes2[FheTypes2["Uint128"] = 6] = "Uint128";
-  FheTypes2[FheTypes2["Uint160"] = 7] = "Uint160";
-  FheTypes2[FheTypes2["Uint256"] = 8] = "Uint256";
-  FheTypes2[FheTypes2["Uint512"] = 9] = "Uint512";
-  FheTypes2[FheTypes2["Uint1024"] = 10] = "Uint1024";
-  FheTypes2[FheTypes2["Uint2048"] = 11] = "Uint2048";
-  FheTypes2[FheTypes2["Uint2"] = 12] = "Uint2";
-  FheTypes2[FheTypes2["Uint6"] = 13] = "Uint6";
-  FheTypes2[FheTypes2["Uint10"] = 14] = "Uint10";
-  FheTypes2[FheTypes2["Uint12"] = 15] = "Uint12";
-  FheTypes2[FheTypes2["Uint14"] = 16] = "Uint14";
-  FheTypes2[FheTypes2["Int2"] = 17] = "Int2";
-  FheTypes2[FheTypes2["Int4"] = 18] = "Int4";
-  FheTypes2[FheTypes2["Int6"] = 19] = "Int6";
-  FheTypes2[FheTypes2["Int8"] = 20] = "Int8";
-  FheTypes2[FheTypes2["Int10"] = 21] = "Int10";
-  FheTypes2[FheTypes2["Int12"] = 22] = "Int12";
-  FheTypes2[FheTypes2["Int14"] = 23] = "Int14";
-  FheTypes2[FheTypes2["Int16"] = 24] = "Int16";
-  FheTypes2[FheTypes2["Int32"] = 25] = "Int32";
-  FheTypes2[FheTypes2["Int64"] = 26] = "Int64";
-  FheTypes2[FheTypes2["Int128"] = 27] = "Int128";
-  FheTypes2[FheTypes2["Int160"] = 28] = "Int160";
-  FheTypes2[FheTypes2["Int256"] = 29] = "Int256";
-  return FheTypes2;
-})(FheTypes || {});
-var FheUintUTypes = [
-  2 /* Uint8 */,
-  3 /* Uint16 */,
-  4 /* Uint32 */,
-  5 /* Uint64 */,
-  6 /* Uint128 */
-  // [U256-DISABLED]
-  // FheTypes.Uint256,
-];
-var FheAllUTypes = [
-  0 /* Bool */,
-  2 /* Uint8 */,
-  3 /* Uint16 */,
-  4 /* Uint32 */,
-  5 /* Uint64 */,
-  6 /* Uint128 */,
-  // [U256-DISABLED]
-  // FheTypes.Uint256,
-  7 /* Uint160 */
-];
-var EncryptableFactoriesImpl = {
-  bool: (data, securityZone = 0) => ({ data, securityZone, utype: 0 /* Bool */ }),
-  address: (data, securityZone = 0) => ({ data, securityZone, utype: 7 /* Uint160 */ }),
-  uint8: (data, securityZone = 0) => ({ data, securityZone, utype: 2 /* Uint8 */ }),
-  uint16: (data, securityZone = 0) => ({ data, securityZone, utype: 3 /* Uint16 */ }),
-  uint32: (data, securityZone = 0) => ({ data, securityZone, utype: 4 /* Uint32 */ }),
-  uint64: (data, securityZone = 0) => ({ data, securityZone, utype: 5 /* Uint64 */ }),
-  uint128: (data, securityZone = 0) => ({ data, securityZone, utype: 6 /* Uint128 */ })
-  // [U256-DISABLED]
-  // uint256: (data: EncryptableUint256['data'], securityZone = 0) =>
-  //   ({ data, securityZone, utype: FheTypes.Uint256 }) as EncryptableUint256,
-};
-function createEncryptableByLiteral(type, data, securityZone = 0) {
-  switch (type) {
-    case "bool": {
-      if (typeof data !== "boolean")
-        throw new Error("Bool encryptable data must be boolean");
-      return EncryptableFactoriesImpl.bool(data, securityZone);
-    }
-    case "address":
-    case "uint8":
-    case "uint16":
-    case "uint32":
-    case "uint64":
-    case "uint128": {
-      if (typeof data === "boolean")
-        throw new Error("Uint encryptable data must be string or bigint");
-      return EncryptableFactoriesImpl[type](data, securityZone);
-    }
-    default: {
-      const _exhaustive = type;
-      throw new Error(`Unsupported encryptable type: ${_exhaustive}`);
-    }
-  }
-}
-var Encryptable = {
-  ...EncryptableFactoriesImpl,
-  create: createEncryptableByLiteral
-};
-function isEncryptableItem(value) {
-  return (
-    // Is object and exists
-    typeof value === "object" && value !== null && // Has securityZone
-    "securityZone" in value && typeof value.securityZone === "number" && // Has utype
-    "utype" in value && FheAllUTypes.includes(value.utype) && // Has data
-    "data" in value && ["string", "number", "bigint", "boolean"].includes(typeof value.data)
-  );
-}
-var EncryptStep = /* @__PURE__ */ ((EncryptStep2) => {
-  EncryptStep2["InitTfhe"] = "initTfhe";
-  EncryptStep2["FetchKeys"] = "fetchKeys";
-  EncryptStep2["Pack"] = "pack";
-  EncryptStep2["Prove"] = "prove";
-  EncryptStep2["Verify"] = "verify";
-  return EncryptStep2;
-})(EncryptStep || {});
-function isLastEncryptionStep(step) {
-  return step === "verify" /* Verify */;
-}
-var toHexString = (bytes) => bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
-var toBigIntOrThrow = (value) => {
-  if (typeof value === "bigint") {
-    return value;
-  }
-  try {
-    return BigInt(value);
-  } catch (error) {
-    throw new Error("Invalid input: Unable to convert to bigint");
-  }
-};
-var validateBigIntInRange = (value, max, min = 0n) => {
-  if (typeof value !== "bigint") {
-    throw new Error("Value must be of type bigint");
-  }
-  if (value > max || value < min) {
-    throw new Error(`Value out of range: ${max} - ${min}, try a different uint type`);
-  }
-};
-var hexToBytes = (hex) => {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return bytes;
-};
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function getPublicClientChainID(publicClient) {
-  let chainId = null;
-  try {
-    chainId = publicClient.chain?.id ?? await publicClient.getChainId();
-  } catch (e) {
-    throw new CofheError({
-      code: "PUBLIC_WALLET_GET_CHAIN_ID_FAILED" /* PublicWalletGetChainIdFailed */,
-      message: "getting chain ID from public client failed",
-      cause: e instanceof Error ? e : void 0
-    });
-  }
-  if (chainId === null) {
-    throw new CofheError({
-      code: "PUBLIC_WALLET_GET_CHAIN_ID_FAILED" /* PublicWalletGetChainIdFailed */,
-      message: "chain ID from public client is null"
-    });
-  }
-  return chainId;
-}
-async function getWalletClientAccount(walletClient) {
-  let address;
-  try {
-    address = walletClient.account?.address;
-    if (!address) {
-      address = (await walletClient.getAddresses())?.[0];
-    }
-  } catch (e) {
-    throw new CofheError({
-      code: "PUBLIC_WALLET_GET_ADDRESSES_FAILED" /* PublicWalletGetAddressesFailed */,
-      message: "getting address from wallet client failed",
-      cause: e instanceof Error ? e : void 0
-    });
-  }
-  if (!address) {
-    throw new CofheError({
-      code: "PUBLIC_WALLET_GET_ADDRESSES_FAILED" /* PublicWalletGetAddressesFailed */,
-      message: "address from wallet client is null"
-    });
-  }
-  return address;
-}
-function fheTypeToString(utype) {
-  switch (utype) {
-    case 0 /* Bool */:
-      return "bool";
-    case 1 /* Uint4 */:
-      return "uint4";
-    case 2 /* Uint8 */:
-      return "uint8";
-    case 3 /* Uint16 */:
-      return "uint16";
-    case 4 /* Uint32 */:
-      return "uint32";
-    case 5 /* Uint64 */:
-      return "uint64";
-    case 6 /* Uint128 */:
-      return "uint128";
-    case 7 /* Uint160 */:
-      return "uint160";
-    case 8 /* Uint256 */:
-      return "uint256";
-    case 9 /* Uint512 */:
-      return "uint512";
-    case 10 /* Uint1024 */:
-      return "uint1024";
-    case 11 /* Uint2048 */:
-      return "uint2048";
-    case 12 /* Uint2 */:
-      return "uint2";
-    case 13 /* Uint6 */:
-      return "uint6";
-    case 14 /* Uint10 */:
-      return "uint10";
-    default:
-      throw new Error(`Unknown FheType: ${utype}`);
-  }
-}
-
 // core/encrypt/zkPackProveVerify.ts
 var MAX_UINT8 = 255n;
 var MAX_UINT16 = 65535n;
@@ -515,26 +298,32 @@ async function cofheMocksCheckEncryptableBits(items) {
         break;
       }
       case 2 /* Uint8 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT8);
         totalBits += 8;
         break;
       }
       case 3 /* Uint16 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT16);
         totalBits += 16;
         break;
       }
       case 4 /* Uint32 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT32);
         totalBits += 32;
         break;
       }
       case 5 /* Uint64 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT64);
         totalBits += 64;
         break;
       }
       case 6 /* Uint128 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT128);
         totalBits += 128;
         break;
       }
       case 7 /* Uint160 */: {
+        validateBigIntInRange(toBigIntOrThrow(item.data), MAX_UINT160);
         totalBits += 160;
         break;
       }
@@ -709,7 +498,8 @@ var CofheConfigSchema = z.object({
   acp: z.object({
     defaultRevoker: z.custom().optional(),
     defaultContractScopes: z.custom().optional(),
-    sharingRegistry: z.custom().optional()
+    sharingRegistry: z.custom().optional(),
+    app: z.string().min(1).optional()
   }).optional().default({}),
   /** Mocks configs */
   mocks: z.object({
@@ -1538,8 +1328,14 @@ var createSelf = async (options, publicClient, walletClient) => {
 var createSharing = async (options, publicClient, walletClient) => {
   return createACPWithSign(options, publicClient, walletClient, ACPUtils.createSharingAndSign, false);
 };
-var importShared = async (options, publicClient, walletClient, { activate = true } = {}) => {
-  return createACPWithSign(options, publicClient, walletClient, ACPUtils.importSharedAndSign, activate);
+var importShared = async (options, publicClient, walletClient, { activate = true, name } = {}) => {
+  return createACPWithSign(
+    options,
+    publicClient,
+    walletClient,
+    (o, pc, wc) => ACPUtils.importSharedAndSign(o, pc, wc, { name }),
+    activate
+  );
 };
 var getHash = (acp) => {
   return ACPUtils.getHash(acp);
@@ -1586,13 +1382,15 @@ var getOrCreateSharingACP = async (publicClient, walletClient, options, chainId,
   }
   return createSharing(options, publicClient, walletClient);
 };
-var applyACPDefaults = (options, acpConfig, chainId) => {
+var applyACPDefaultsFromChain = async (options, acpConfig, publicClient, chainId) => {
   const result = { ...options };
-  const defaultRevoker = acpConfig?.defaultRevoker?.[chainId];
-  const hasValidatorOptions = options.revokerData != null || options.revokerContract != null;
-  if (defaultRevoker != null && !hasValidatorOptions) {
-    result.revokerContract = defaultRevoker;
-    result.revokerData = Math.round(Date.now() / 1e3) - 60;
+  const hasRevokerOptions = options.revokerData != null || options.revokerContract != null;
+  if (!hasRevokerOptions) {
+    const defaultRevoker = acpConfig?.defaultRevoker?.[chainId] ?? (await getAclServedAddresses(publicClient, chainId)).defaultRevoker;
+    if (defaultRevoker != null) {
+      result.revokerContract = defaultRevoker;
+      result.revokerData = await getBlockRevokerData(publicClient);
+    }
   }
   const defaultContracts = acpConfig?.defaultContractScopes?.[chainId];
   const hasScopeOptions = options.scope != null || options.contracts != null || options.handles != null;
@@ -1601,13 +1399,15 @@ var applyACPDefaults = (options, acpConfig, chainId) => {
   }
   return result;
 };
-var applyACPDefaultsFromChain = async (options, acpConfig, publicClient, chainId) => {
-  const hasExplicitRevoker = acpConfig?.defaultRevoker?.[chainId] != null || options.revokerData != null || options.revokerContract != null;
-  if (hasExplicitRevoker)
-    return applyACPDefaults(options, acpConfig, chainId);
-  const served = await getAclServedAddresses(publicClient, chainId);
-  const effectiveConfig = served.defaultRevoker != null ? { ...acpConfig, defaultRevoker: { ...acpConfig?.defaultRevoker, [chainId]: served.defaultRevoker } } : acpConfig;
-  return applyACPDefaults(options, effectiveConfig, chainId);
+var getBlockRevokerData = async (publicClient) => {
+  const block = await publicClient.getBlock();
+  const revokerData = Number(block.timestamp);
+  if (!Number.isSafeInteger(revokerData)) {
+    throw new Error(
+      `ACP revokerData cannot represent the chain block timestamp ${block.timestamp.toString()} as a safe integer`
+    );
+  }
+  return revokerData;
 };
 var revokeACP = async (acp, walletClient) => {
   if (acp.revokerContract === zeroAddress || acp.revokerData === 0) {
@@ -1666,7 +1466,17 @@ var isACPRevoked = async (acp, publicClient) => {
     args: [acp.issuer, BigInt(acp.revokerData)]
   });
 };
-var shareOnChain = async (acp, walletClient, registry) => {
+var metadataOf = (acp, { labels, metadata, appKey }) => {
+  if (labels != null && metadata != null)
+    throw new Error("Pass either labels or metadata, not both");
+  if (labels == null)
+    return metadata ?? acp.metadata ?? "0x";
+  if (labels.length !== acp.handles.length) {
+    throw new Error(`Cannot label a share of ${acp.handles.length} handles with ${labels.length} labels`);
+  }
+  return encodeShareMetadata(labels, { issuer: acp.issuer, appKey });
+};
+var shareOnChain = async (acp, walletClient, registry, options = {}) => {
   if (acp.type !== "sharing") {
     throw new Error(`Cannot share a '${acp.type}' ACP on-chain \u2014 only 'sharing' ACPs are shareable.`);
   }
@@ -1678,38 +1488,48 @@ var shareOnChain = async (acp, walletClient, registry) => {
   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)],
+    args: [toChainShare(acp), metadata],
     account: walletClient.account,
     chain: walletClient.chain ?? null
   });
   return { txHash, shareId: computeShareId(acp) };
 };
-var getIncomingShares = async (publicClient, registry, recipient) => {
-  const raw = await publicClient.readContract({
-    address: registry,
-    abi: ACP_SHARE_REGISTRY_ABI,
-    functionName: "sharesFor",
-    args: [recipient]
-  });
-  return raw.map((s) => ({
-    shareId: shareIdOfChainShare(s),
-    issuer: s.issuer,
-    expiration: Number(s.expiration),
-    recipient: s.recipient,
-    revokerData: Number(s.revokerData),
-    revokerContract: s.revokerContract,
-    scope: Number(s.scope),
-    contracts: [...s.contracts],
-    handles: [...s.handles],
-    issuerSignature: s.issuerSignature
-  }));
+var toIncomingShare = ({ shareId, share: s, metadata }) => ({
+  shareId,
+  issuer: s.issuer,
+  expiration: Number(s.expiration),
+  recipient: s.recipient,
+  revokerData: Number(s.revokerData),
+  revokerContract: s.revokerContract,
+  scope: Number(s.scope),
+  contracts: [...s.contracts],
+  handles: [...s.handles],
+  issuerSignature: s.issuerSignature,
+  metadata,
+  ...appKeyOf(metadata, s.handles) && { appKey: appKeyOf(metadata, s.handles) }
+});
+var appKeyOf = (metadata, handles) => {
+  try {
+    return decodeShareAppKey(metadata, handles);
+  } catch {
+    return void 0;
+  }
+};
+var getIncomingShares = async (publicClient, registry, recipient, { appKey } = {}) => {
+  const shares = (await readSharesFor(publicClient, registry, recipient)).posted.map(toIncomingShare);
+  return appKey == null ? shares : shares.filter((share) => share.appKey === appKey);
+};
+var getShareFromChain = async (publicClient, registry, shareId) => {
+  const posted = await readShare(publicClient, registry, shareId);
+  return posted && toIncomingShare(posted);
 };
 var importFromChain = async (share, publicClient, walletClient, importOptions = {}) => {
-  const { shareId: _shareId, ...options } = share;
+  const { shareId: _shareId, appKey: _appKey, ...options } = share;
   return importShared({ ...options, type: "sharing" }, publicClient, walletClient, importOptions);
 };
 var removeShareOnChain = async (shareId, walletClient, registry) => {
@@ -1751,10 +1571,10 @@ var acps = {
   checkAccess,
   shareOnChain,
   getIncomingShares,
+  getShareFromChain,
   importFromChain,
   removeShareOnChain,
   computeShareId,
-  applyACPDefaults,
   applyACPDefaultsFromChain,
   getAclServedAddresses,
   clearAclServedAddresses
@@ -2061,7 +1881,7 @@ var BACKEND_ERROR_CODE_TO_COFHE_ERROR_CODE = {
   seal_failed: "SEAL_FAILED" /* SealFailed */
 };
 function isBackendApiErrorCode(value) {
-  return value in BACKEND_ERROR_CODE_TO_COFHE_ERROR_CODE;
+  return Object.prototype.hasOwnProperty.call(BACKEND_ERROR_CODE_TO_COFHE_ERROR_CODE, value);
 }
 async function parseApiErrorResponseBody(response) {
   let errorMessage = `HTTP ${response.status}`;
@@ -3474,7 +3294,7 @@ async function verifyDecryptResult(handle, cleartext, signature, publicClient) {
     args: []
   });
   if (isAddressEqual(expectedSigner, zeroAddress))
-    return true;
+    return false;
   const ctHash = BigInt(handle);
   const messageHash = buildDecryptResultHash(ctHash, cleartext, chainId);
   try {
@@ -3502,6 +3322,7 @@ function createCofheClientBase(opts) {
   const updateConnectState = (partial) => {
     connectStore.setState((state) => ({ ...state, ...partial }));
   };
+  const withAppKey = () => opts.config.acp?.app == null ? {} : { appKey: shareAppKey(opts.config.acp.app) };
   const _resolveSharingRegistry = async (publicClient, chainId) => {
     const configured = opts.config.acp?.sharingRegistry?.[chainId];
     if (configured != null)
@@ -3660,16 +3481,16 @@ function createCofheClientBase(opts) {
       const { publicClient, walletClient } = clients ?? connectStore.getState();
       const chainId = await publicClient.getChainId();
       return acps.createSharing(
-        await acps.applyACPDefaultsFromChain(options, opts.config.acp, publicClient, chainId),
+        await acps.applyACPDefaultsFromChain({ ...withAppKey(), ...options }, opts.config.acp, publicClient, chainId),
         publicClient,
         walletClient
       );
     },
     importShared: async (options, importOptions = {}) => {
       _requireConnected();
-      const { activate, ...clients } = importOptions;
+      const { activate, name, ...clients } = importOptions;
       const { publicClient, walletClient } = clients.publicClient ? clients : connectStore.getState();
-      return acps.importShared(options, publicClient, walletClient, { activate });
+      return acps.importShared(options, publicClient, walletClient, { activate, name });
     },
     // Get or create methods (require connection)
     getOrCreateSelfACP: async (chainId, account, options) => {
@@ -3691,7 +3512,7 @@ function createCofheClientBase(opts) {
       return acps.getOrCreateSharingACP(
         publicClient,
         walletClient,
-        await acps.applyACPDefaultsFromChain(options, opts.config.acp, publicClient, _chainId),
+        await acps.applyACPDefaultsFromChain({ ...withAppKey(), ...options }, opts.config.acp, publicClient, _chainId),
         _chainId,
         _account
       );
@@ -3718,12 +3539,12 @@ function createCofheClientBase(opts) {
       return acps.checkAccess(acp, publicClient, handle);
     },
     // On-chain sharing (require connection + config.acp.sharingRegistry)
-    shareOnChain: async (acp) => {
+    shareOnChain: async (acp, options) => {
       _requireConnected();
       const { publicClient, walletClient } = connectStore.getState();
       const chainId = await publicClient.getChainId();
       const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
-      return acps.shareOnChain(acp, walletClient, sharingRegistry);
+      return acps.shareOnChain(acp, walletClient, sharingRegistry, { ...withAppKey(), ...options });
     },
     getIncomingShares: async () => {
       _requireConnected();
@@ -3731,7 +3552,27 @@ function createCofheClientBase(opts) {
       const chainId = await publicClient.getChainId();
       const account = walletClient.account.address;
       const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
-      return acps.getIncomingShares(publicClient, sharingRegistry, account);
+      return acps.getIncomingShares(publicClient, sharingRegistry, account, withAppKey());
+    },
+    getShareFromChain: async (shareId) => {
+      _requireConnected();
+      const { publicClient } = connectStore.getState();
+      const chainId = await publicClient.getChainId();
+      const sharingRegistry = await _resolveSharingRegistry(publicClient, chainId);
+      return acps.getShareFromChain(publicClient, sharingRegistry, shareId);
+    },
+    verifyShareLabels: async (share, options) => {
+      _requireConnected();
+      const { publicClient } = connectStore.getState();
+      if (share.metadata == null || share.metadata === "0x")
+        return null;
+      return verifyShareLabels({
+        labels: decodeShareMetadata(share.metadata, share.handles),
+        handles: share.handles,
+        issuer: share.issuer,
+        publicClient,
+        verify: options?.verify
+      });
     },
     importFromChain: async (share, options) => {
       _requireConnected();
@@ -3824,4 +3665,4 @@ function createCofheClientBase(opts) {
   };
 }
 
-export { DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, EncryptStep, Encryptable, FheAllUTypes, FheTypes, FheUintUTypes, InitialConnectStore, assertNoRenamedConfigKeys, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, fheTypeToString, getCofheConfigItem, getCofheDebugInterceptors, isEncryptableItem, isLastEncryptionStep, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker };
+export { DecryptForTxBuilder, DecryptForViewBuilder, EncryptInputsBuilder, InitialConnectStore, assertNoRenamedConfigKeys, cofheFetch, createCofheClientBase, createCofheConfigBase, createKeysStore, fetchKeys, getCofheConfigItem, getCofheDebugInterceptors, setCofheDebugInterceptors, verifyDecryptResult, zkProveWithWorker };