@tokenops/sdk 1.0.0

package/dist/chunk-JFLEEXKP.js

@@ -0,0 +1,325 @@
+import { TokenOpsSdkError, ContractRevertError, InvalidArgumentError, InvalidSignatureError, FheHandleNotAllowedError, TransferFailedError, FeatureDisabledError, BatchTooLargeError, InsufficientBalanceError, InsufficientFeeError, ReentrancyError, AlreadyInitializedError, AccessDeniedError, PausedError, UnknownWriteFailureError, WalletRejectedError, WalletChainMismatchError, InsufficientGasFundsError, NetworkError } from './chunk-IVE3QEGD.js';
+import { decodeErrorResult, BaseError, ContractFunctionRevertedError, UserRejectedRequestError, TransactionRejectedRpcError, ChainMismatchError, InsufficientFundsError, HttpRequestError, TimeoutError } from 'viem';
+
+// src/core/version.ts
+var SDK_VERSION = "1.0.0";
+function mapContractRevert(error, args) {
+  if (error instanceof TokenOpsSdkError) return error;
+  const ctx = {
+    method: args.method,
+    contractAddress: args.contractAddress,
+    productContext: args.productContext
+  };
+  const reverted = findRevertedError(error);
+  if (!reverted) {
+    return classifyNonRevert(error, args);
+  }
+  let revertName = reverted.data?.errorName;
+  let revertArgs = reverted.data?.args;
+  let revertSelector;
+  const rawRevertData = reverted.raw;
+  const revertReason = reverted.reason;
+  if (revertName === void 0 && rawRevertData !== void 0 && rawRevertData.length >= 10) {
+    revertSelector = rawRevertData.slice(0, 10);
+    try {
+      const decoded = decodeErrorResult({ abi: args.abi, data: rawRevertData });
+      revertName = decoded.errorName;
+      revertArgs = decoded.args;
+    } catch {
+    }
+  } else if (revertSelector === void 0 && rawRevertData !== void 0) {
+    revertSelector = rawRevertData.slice(0, 10);
+  }
+  if (revertName !== void 0) {
+    const fromProduct = args.productMapper?.(revertName, revertArgs, ctx);
+    if (fromProduct) return attachCause(fromProduct, error);
+    const fromDefault = defaultRevertNameMapper(revertName, revertArgs, ctx, args.account);
+    if (fromDefault) return attachCause(fromDefault, error);
+  }
+  return new ContractRevertError({
+    method: args.method,
+    contractAddress: args.contractAddress,
+    revertName,
+    revertSelector,
+    revertArgs,
+    revertReason,
+    rawRevertData,
+    cause: error
+  });
+}
+function attachCause(err, cause) {
+  if (err.cause === void 0) {
+    Object.defineProperty(err, "cause", {
+      value: cause,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  return err;
+}
+function defaultRevertNameMapper(name, errArgs, ctx, account) {
+  switch (name) {
+    // OpenZeppelin / cross-product structural errors.
+    case "EnforcedPause":
+    case "PausableUpgradeable__Paused":
+    case "ClaimsPaused":
+      return new PausedError(ctx);
+    case "AccessControlUnauthorizedAccount": {
+      const acct = errArgs?.[0] ?? account;
+      const role = errArgs?.[1];
+      return new AccessDeniedError({ ...ctx, account: acct, role });
+    }
+    case "AccessControlBadConfirmation":
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: "callerConfirmation",
+        reason: "must equal msg.sender for renounceRole"
+      });
+    case "InvalidInitialization":
+    case "Initializable_InvalidInitialization":
+      return new AlreadyInitializedError(ctx);
+    case "ReentrancyGuardReentrantCall":
+    case "ReentrancyGuardTransient":
+      return new ReentrancyError(ctx);
+    // Cross-product custom errors with stable, unambiguous meaning.
+    case "InsufficientFee":
+    case "InsufficientGasFee":
+      return new InsufficientFeeError({ ...ctx, feeKind: "gas" });
+    case "InsufficientAmount": {
+      const provided = errArgs?.[0];
+      const required = errArgs?.[1];
+      return new InsufficientFeeError({ ...ctx, feeKind: "gas", required, provided });
+    }
+    case "ZeroBalance":
+    case "InsufficientBalance":
+      return new InsufficientBalanceError({ ...ctx, balanceKind: "eth" });
+    case "BatchTooLarge": {
+      const requested = Number(errArgs?.[0] ?? 0);
+      const max = errArgs?.[1] ?? 0n;
+      return new BatchTooLargeError({ ...ctx, requested, max });
+    }
+    case "SplitDisabled":
+      return new FeatureDisabledError({ ...ctx, feature: "split" });
+    case "PausableDisabled":
+      return new FeatureDisabledError({ ...ctx, feature: "pause" });
+    case "ExtensionNotAllowed":
+      return new FeatureDisabledError({ ...ctx, feature: "extendClaimWindow" });
+    case "TransferFailed":
+      return new TransferFailedError({ ...ctx, asset: "eth" });
+    case "HandleNotAllowed":
+      return new FheHandleNotAllowedError({ ...ctx, account });
+    case "SenderNotAllowedToUseHandle": {
+      const handle = errArgs?.[0];
+      const sender = errArgs?.[1] ?? account;
+      return new FheHandleNotAllowedError({ ...ctx, handle, account: sender });
+    }
+    case "SenderNotAllowed": {
+      const sender = errArgs?.[0] ?? account;
+      return new FheHandleNotAllowedError({ ...ctx, account: sender });
+    }
+    case "InvalidSignature":
+      return new InvalidSignatureError(ctx);
+    // Range / arg-validation reverts the SDK should already have caught in
+    // preflight or input validation. If they slip through, surface them as
+    // structural `InvalidArgumentError` so consumers see `TOKENOPS_INVALID_ARGUMENT`
+    // rather than a generic contract-revert message.
+    case "InvalidAddress":
+    case "InvalidAdmin":
+    case "InvalidFeeCollector":
+    case "InvalidRecipient":
+    case "InvalidToken":
+    case "InvalidParty":
+    case "InvalidStartTime":
+    case "EndTimeInPast":
+    case "InvalidDuration":
+    case "InvalidTimestamps":
+    case "InvalidBps":
+    case "InvalidFeeBps":
+    case "TokenFeeTooHigh":
+    case "CliffExceedsDuration":
+    case "TimelockOverflow":
+    case "InvalidTransferDuration":
+    case "InvalidSplitDenominator":
+    case "InvalidMaxBatchSize":
+    case "InvalidWalletIndex":
+    case "CannotTransferToSelf":
+    case "CannotTransferToZero":
+    case "SameToken":
+    case "UnexpectedETH":
+    case "EmptyBatch":
+    case "EmptyRecipients":
+    case "ZeroAddressRecipient":
+    case "ArrayLengthMismatch":
+    case "VestingIdsNotStrictlyAsc":
+    case "CustomFeeNotSet":
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: invalidArgumentLabelFor(name),
+        reason: `the contract reverted with \`${name}\`. If you did not pass an invalid value, this may be an SDK bug \u2014 please file an issue.`
+      });
+    default:
+      return void 0;
+  }
+}
+function invalidArgumentLabelFor(revertName) {
+  switch (revertName) {
+    case "InvalidAddress":
+      return "address";
+    case "InvalidAdmin":
+      return "admin";
+    case "InvalidFeeCollector":
+      return "feeCollector";
+    case "InvalidRecipient":
+    case "ZeroAddressRecipient":
+      return "recipient";
+    case "InvalidToken":
+    case "SameToken":
+      return "token";
+    case "InvalidParty":
+      return "party";
+    case "InvalidStartTime":
+      return "startTime";
+    case "EndTimeInPast":
+      return "endTime";
+    case "InvalidDuration":
+    case "InvalidTransferDuration":
+      return "duration";
+    case "InvalidTimestamps":
+      return "timestamps";
+    case "InvalidBps":
+    case "InvalidFeeBps":
+    case "TokenFeeTooHigh":
+      return "feeBps";
+    case "CliffExceedsDuration":
+      return "cliff";
+    case "TimelockOverflow":
+      return "timelock";
+    case "InvalidSplitDenominator":
+      return "splitDenominator";
+    case "InvalidMaxBatchSize":
+      return "maxBatchSize";
+    case "InvalidWalletIndex":
+      return "walletIndex";
+    case "CannotTransferToSelf":
+    case "CannotTransferToZero":
+      return "to";
+    case "UnexpectedETH":
+      return "msg.value";
+    case "EmptyBatch":
+    case "EmptyRecipients":
+      return "recipients";
+    case "ArrayLengthMismatch":
+      return "arguments";
+    case "VestingIdsNotStrictlyAsc":
+      return "vestingIds";
+    case "CustomFeeNotSet":
+      return "user";
+    default:
+      return "input";
+  }
+}
+function isContractRevert(error) {
+  if (!(error instanceof BaseError)) return false;
+  const frame = error.walk((e) => e instanceof ContractFunctionRevertedError);
+  return frame instanceof ContractFunctionRevertedError;
+}
+function classifyNonRevert(error, args) {
+  if (!(error instanceof BaseError)) {
+    return new UnknownWriteFailureError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  const walk = (predicate) => {
+    const frame = error.walk((f) => predicate(f));
+    return predicate(frame) ? frame : void 0;
+  };
+  if (walk((e) => e instanceof UserRejectedRequestError) || walk((e) => e instanceof TransactionRejectedRpcError)) {
+    return new WalletRejectedError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof ChainMismatchError)) {
+    return new WalletChainMismatchError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof InsufficientFundsError)) {
+    return new InsufficientGasFundsError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  const httpFrame = walk((e) => e instanceof HttpRequestError);
+  if (httpFrame) {
+    return new NetworkError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      statusCode: httpFrame.status,
+      cause: error
+    });
+  }
+  if (walk((e) => e instanceof TimeoutError)) {
+    return new NetworkError({
+      method: args.method,
+      contractAddress: args.contractAddress,
+      cause: error
+    });
+  }
+  return new UnknownWriteFailureError({
+    method: args.method,
+    contractAddress: args.contractAddress,
+    cause: error
+  });
+}
+function findRevertedError(err) {
+  if (!(err instanceof BaseError)) {
+    if (err instanceof Error) {
+      const hex = coerceRevertHex(err.data);
+      if (hex) return { raw: hex };
+    }
+    return void 0;
+  }
+  const frame = err.walk((f) => f instanceof ContractFunctionRevertedError);
+  if (frame instanceof ContractFunctionRevertedError) {
+    const data = frame.data ? {
+      errorName: frame.data.errorName,
+      args: frame.data.args
+    } : void 0;
+    return {
+      data,
+      raw: frame.raw,
+      reason: frame.reason
+    };
+  }
+  let cursor = err;
+  const seen = /* @__PURE__ */ new Set();
+  while (cursor && !seen.has(cursor)) {
+    seen.add(cursor);
+    const hex = coerceRevertHex(cursor.data);
+    if (hex) return { raw: hex };
+    cursor = cursor.cause;
+  }
+  return void 0;
+}
+function coerceRevertHex(value) {
+  if (typeof value === "string" && value.startsWith("0x") && value.length >= 10) {
+    return value;
+  }
+  if (value !== null && typeof value === "object" && "data" in value) {
+    const nested = value.data;
+    if (typeof nested === "string" && nested.startsWith("0x") && nested.length >= 10) {
+      return nested;
+    }
+  }
+  return void 0;
+}
+
+export { SDK_VERSION, isContractRevert, mapContractRevert };

package/dist/chunk-JFR5J4FL.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+var chunkSUOG3BQS_cjs = require('./chunk-SUOG3BQS.cjs');
+var chunk62DF53UQ_cjs = require('./chunk-62DF53UQ.cjs');
+var chunkOLDGMKW2_cjs = require('./chunk-OLDGMKW2.cjs');
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var react = require('react');
+var wagmi = require('wagmi');
+
+var FHE_VESTING_KEY = "tokenops-sdk";
+var FHE_VESTING_NAMESPACE = "fhe-vesting";
+function useHookFiredEvent(hookName, telemetry, hasWallet, chainId) {
+  const firedRef = react.useRef(false);
+  react.useEffect(() => {
+    if (firedRef.current || !telemetry) return;
+    firedRef.current = true;
+    telemetry.event("fhe-vesting.react.hook.fired", {
+      hookName,
+      surface: "react",
+      hasWallet,
+      chainId: chainId ?? null
+    });
+  }, []);
+}
+function tryResolveFactoryAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return chunkOLDGMKW2_cjs.getFheVestingFactoryAddress(chainId);
+}
+function useMemoFactoryClient(opts = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveFactoryAddress(opts.address, chainId);
+  const resolutionError = computeFactoryResolutionError(opts.address, chainId);
+  const telemetry = opts.telemetry;
+  useHookFiredEvent("manager-factory", telemetry, !!walletClient, chainId);
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunk62DF53UQ_cjs.createConfidentialVestingFactoryClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId, telemetry]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function computeFactoryResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheVesting",
+      contract: "confidentialVestingFactory",
+      clientLabel: "ConfidentialVestingFactoryClient"
+    });
+  }
+  const resolved = chunkOLDGMKW2_cjs.getFheVestingFactoryAddress(chainId);
+  if (!resolved) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheVesting",
+      contract: "confidentialVestingFactory",
+      chainId,
+      clientLabel: "ConfidentialVestingFactoryClient"
+    });
+  }
+  return void 0;
+}
+function useMemoManagerClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  useHookFiredEvent("manager", opts.telemetry, !!walletClient, chainId);
+  const encryptorSourceRef = react.useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const telemetry = opts.telemetry;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunkSUOG3BQS_cjs.createConfidentialVestingManagerClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      // Lazy — invoked per-encryption inside the headless client. Picks up
+      // whichever EncryptorSource the consumer last passed in.
+      encryptor: () => chunkSUOG3BQS_cjs.resolveEncryptor(encryptorSourceRef.current),
+      ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {},
+      ...telemetry ? { telemetry } : {}
+    });
+  }, [publicClient, walletClient, opts.address, opts.aclAddress, telemetry]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function buildQueryKey(method, chainId, address, ...args) {
+  return [
+    FHE_VESTING_KEY,
+    FHE_VESTING_NAMESPACE,
+    method,
+    chainId ?? null,
+    address ? address.toLowerCase() : null,
+    ...args.map(normalizeKeyArg)
+  ];
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+
+exports.buildQueryKey = buildQueryKey;
+exports.useMemoFactoryClient = useMemoFactoryClient;
+exports.useMemoManagerClient = useMemoManagerClient;

package/dist/chunk-K6MFFDBJ.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+var chunk5SA2HF2W_cjs = require('./chunk-5SA2HF2W.cjs');
+var chunk6ECAHP5O_cjs = require('./chunk-6ECAHP5O.cjs');
+var chunkOLDGMKW2_cjs = require('./chunk-OLDGMKW2.cjs');
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var react = require('react');
+var wagmi = require('wagmi');
+
+var FHE_AIRDROP_KEY = "tokenops-sdk";
+var FHE_AIRDROP_NAMESPACE = "fhe-airdrop";
+function tryResolveFactoryAddress(override, chainId) {
+  if (override) return override;
+  if (chainId === void 0) return void 0;
+  return chunkOLDGMKW2_cjs.getFheAirdropFactoryAddress(chainId);
+}
+function useMemoFactoryClient(opts = {}) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const resolvedAddress = tryResolveFactoryAddress(opts.address, chainId);
+  const resolutionError = computeFactoryResolutionError(opts.address, chainId);
+  const encryptorSourceRef = react.useRef(opts.encryptor);
+  encryptorSourceRef.current = opts.encryptor;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!resolvedAddress) return void 0;
+    return chunk6ECAHP5O_cjs.createConfidentialAirdropFactoryClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: resolvedAddress,
+      ...chainId !== void 0 ? { chainId } : {},
+      // Lazy — invoked per-encryption inside the headless client. Picks up
+      // whichever EncryptorSource the consumer last passed in.
+      encryptor: () => chunk6ECAHP5O_cjs.resolveEncryptor(encryptorSourceRef.current)
+    });
+  }, [publicClient, walletClient, resolvedAddress, chainId]);
+  return {
+    client,
+    resolutionError,
+    publicClient,
+    walletClient: walletClient ?? void 0,
+    chainId,
+    resolvedAddress
+  };
+}
+function computeFactoryResolutionError(override, chainId) {
+  if (override) return void 0;
+  if (chainId === void 0) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fheAirdrop",
+      contract: "confidentialAirdropFactory",
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  const resolved = chunkOLDGMKW2_cjs.getFheAirdropFactoryAddress(chainId);
+  if (!resolved) {
+    return new chunk56UI7LUR_cjs.DeploymentAddressUnavailableError({
+      reason: "registry-not-deployed",
+      product: "fheAirdrop",
+      contract: "confidentialAirdropFactory",
+      chainId,
+      clientLabel: "ConfidentialAirdropFactoryClient"
+    });
+  }
+  return void 0;
+}
+function useMemoAirdropClient(opts) {
+  const publicClient = wagmi.usePublicClient({ chainId: opts.chainId });
+  const { data: walletClient } = wagmi.useWalletClient({ chainId: opts.chainId });
+  const chainId = opts.chainId ?? publicClient?.chain?.id;
+  const client = react.useMemo(() => {
+    if (!publicClient) return void 0;
+    if (!opts.address) return void 0;
+    return chunk5SA2HF2W_cjs.createConfidentialAirdropClient({
+      publicClient,
+      ...walletClient ? { walletClient } : {},
+      address: opts.address,
+      ...opts.aclAddress ? { aclAddress: opts.aclAddress } : {}
+    });
+  }, [publicClient, walletClient, opts.address, opts.aclAddress]);
+  return { client, publicClient, walletClient: walletClient ?? void 0, chainId };
+}
+function buildQueryKey(method, chainId, address, ...args) {
+  return [
+    FHE_AIRDROP_KEY,
+    FHE_AIRDROP_NAMESPACE,
+    method,
+    chainId ?? null,
+    address ? address.toLowerCase() : null,
+    ...args.map(normalizeKeyArg)
+  ];
+}
+function normalizeKeyArg(value) {
+  if (typeof value === "bigint") return value.toString();
+  if (Array.isArray(value)) return value.map(normalizeKeyArg);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, normalizeKeyArg(v)])
+    );
+  }
+  if (typeof value === "string" && value.startsWith("0x")) return value.toLowerCase();
+  return value;
+}
+
+exports.buildQueryKey = buildQueryKey;
+exports.useMemoAirdropClient = useMemoAirdropClient;
+exports.useMemoFactoryClient = useMemoFactoryClient;

package/dist/chunk-KWFFIJYX.js

@@ -0,0 +1,11 @@
+// src/core/brands.ts
+var asEncryptedHandle = (h) => h;
+var asExternalInputProof = (h) => h;
+var asTxHash = (h) => h;
+var asVestingId = (h) => h;
+var asAirdropId = (h) => h;
+var asDisperseId = (h) => h;
+var asRole = (h) => h;
+var asSignature = (h) => h;
+
+export { asAirdropId, asDisperseId, asEncryptedHandle, asExternalInputProof, asRole, asSignature, asTxHash, asVestingId };

package/dist/chunk-NS44KBV5.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+
+// src/core/zama-error-mapper.ts
+function mapZamaError(error, args) {
+  if (error instanceof chunk56UI7LUR_cjs.TokenOpsSdkError) return error;
+  const zama = readZamaError(error);
+  if (zama?.code) {
+    switch (zama.code) {
+      case "SIGNING_REJECTED":
+        return new chunk56UI7LUR_cjs.UserRejectedSignatureError({ ...args, cause: error });
+      case "SIGNING_FAILED":
+        return new chunk56UI7LUR_cjs.SigningFailedError({ ...args, cause: error });
+      case "RELAYER_REQUEST_FAILED":
+        return new chunk56UI7LUR_cjs.RelayerUnreachableError({
+          ...args,
+          statusCode: zama.statusCode,
+          cause: error
+        });
+      case "ENCRYPTION_FAILED":
+        return new chunk56UI7LUR_cjs.EncryptionFailedError({ ...args, cause: error });
+      case "DECRYPTION_FAILED":
+        return new chunk56UI7LUR_cjs.DecryptionFailedError({ ...args, cause: error });
+      case "CONFIGURATION":
+        return new chunk56UI7LUR_cjs.InvalidArgumentError({
+          method: args.method,
+          argument: "config",
+          reason: "Zama SDK configuration is invalid (chain id, type, or signer state).",
+          cause: error
+        });
+    }
+  }
+  const message = readMessage(error);
+  if (message) {
+    if (USER_REJECTION_PATTERNS.some((pat) => pat.test(message))) {
+      return new chunk56UI7LUR_cjs.UserRejectedSignatureError({ ...args, cause: error });
+    }
+    if (USER_DECRYPT_NOT_ALLOWED_PATTERNS.some((pat) => pat.test(message))) {
+      return new chunk56UI7LUR_cjs.UserDecryptNotAllowedError({ method: args.method, cause: error });
+    }
+    if (INVALID_INPUT_PATTERNS.some((pat) => pat.test(message))) {
+      return new chunk56UI7LUR_cjs.InvalidArgumentError({
+        method: args.method,
+        argument: "input",
+        reason: "encrypted input value rejected by FHE SDK \u2014 see `error.cause` for details",
+        cause: error
+      });
+    }
+  }
+  return args.operation === "encrypt" ? new chunk56UI7LUR_cjs.EncryptionFailedError({ ...args, cause: error }) : new chunk56UI7LUR_cjs.DecryptionFailedError({ ...args, cause: error });
+}
+function readZamaError(err) {
+  if (typeof err !== "object" || err === null) return void 0;
+  const e = err;
+  const code = typeof e.code === "string" ? e.code : void 0;
+  const statusCode = typeof e.statusCode === "number" ? e.statusCode : void 0;
+  const message = typeof e.message === "string" ? e.message : void 0;
+  if (code === void 0 && statusCode === void 0) return void 0;
+  return { code, statusCode, message };
+}
+function readMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "object" && err !== null && typeof err.message === "string") {
+    return err.message;
+  }
+  return void 0;
+}
+var USER_REJECTION_PATTERNS = [
+  /user rejected/i,
+  /user denied/i,
+  /4001/
+  // EIP-1193 error code
+];
+var USER_DECRYPT_NOT_ALLOWED_PATTERNS = [
+  /not authorized to user decrypt/i,
+  /not authorized to decrypt/i,
+  /is not allowed for public decryption/i
+];
+var INVALID_INPUT_PATTERNS = [
+  /invalid unsigned integer value/i,
+  /exceeds the maximum allowed value/i,
+  /invalid address value/i,
+  /chainId exceeds maximum/i,
+  /packing more than .* in a single input/i,
+  /fhevm assertion failed/i
+];
+
+exports.mapZamaError = mapZamaError;