@tokenops/sdk 1.0.0

package/dist/chunk-56UI7LUR.cjs

@@ -0,0 +1,516 @@
+'use strict';
+
+// src/core/errors.ts
+var TOKENOPS_SDK_ERROR_BRAND = /* @__PURE__ */ Symbol.for("tokenops-sdk.error");
+var TokenOpsSdkError = class extends Error {
+  name = "TokenOpsSdkError";
+  code;
+  context;
+  [TOKENOPS_SDK_ERROR_BRAND] = true;
+  constructor(message, init) {
+    super(message, { cause: init?.cause });
+    this.code = init?.code ?? "TOKENOPS_UNKNOWN_WRITE_FAILURE";
+    this.context = init?.context ?? {};
+  }
+};
+function isTokenOpsSdkError(error) {
+  return typeof error === "object" && error !== null && error[TOKENOPS_SDK_ERROR_BRAND] === true;
+}
+var UnsupportedChainError = class extends TokenOpsSdkError {
+  name = "UnsupportedChainError";
+  constructor(chainId, options) {
+    super(`Chain ${chainId} is not supported by @tokenops/sdk`, {
+      code: "TOKENOPS_UNSUPPORTED_CHAIN",
+      cause: options?.cause,
+      context: { chainId }
+    });
+  }
+};
+var DeploymentAddressUnavailableError = class extends TokenOpsSdkError {
+  name = "DeploymentAddressUnavailableError";
+  constructor(args) {
+    const label = args.clientLabel ?? `${args.product ?? "product"}.${args.contract ?? "contract"}`;
+    const chain = args.chainId === void 0 ? "<unknown>" : String(args.chainId);
+    const override = args.overrideName ?? "address";
+    const message = (() => {
+      switch (args.reason) {
+        case "chain-id-missing":
+          return `${label}: no chain id available \u2014 pass \`chainId\` or construct \`publicClient\` with a recognized \`chain\`, or pass \`${override}\` explicitly.`;
+        case "registry-not-deployed":
+          return `${label} is not deployed on chain ${chain} yet \u2014 pass \`${override}\` explicitly.`;
+        case "registry-unknown-chain":
+          return `${label}: chain ${chain} is unknown to @tokenops/sdk \u2014 pass \`${override}\` explicitly.`;
+      }
+    })();
+    super(message, {
+      code: "TOKENOPS_DEPLOYMENT_ADDRESS_UNAVAILABLE",
+      cause: args.cause,
+      context: {
+        reason: args.reason,
+        product: args.product,
+        contract: args.contract,
+        chainId: args.chainId,
+        clientLabel: args.clientLabel,
+        overrideName: args.overrideName
+      }
+    });
+  }
+};
+var MissingPublicClientError = class extends TokenOpsSdkError {
+  name = "MissingPublicClientError";
+  constructor(method, options) {
+    super(`${method}: publicClient is required.`, {
+      code: "TOKENOPS_MISSING_PUBLIC_CLIENT",
+      cause: options?.cause,
+      context: { method }
+    });
+  }
+};
+var MissingWalletClientError = class extends TokenOpsSdkError {
+  name = "MissingWalletClientError";
+  constructor(method, options) {
+    super(`${method}: walletClient is required for write operations.`, {
+      code: "TOKENOPS_MISSING_WALLET_CLIENT",
+      cause: options?.cause,
+      context: { method }
+    });
+  }
+};
+var MissingAccountError = class extends TokenOpsSdkError {
+  name = "MissingAccountError";
+  constructor(method, options) {
+    super(`${method}: walletClient.account or args.account is required.`, {
+      code: "TOKENOPS_MISSING_ACCOUNT",
+      cause: options?.cause,
+      context: { method }
+    });
+  }
+};
+var MissingEncryptorError = class extends TokenOpsSdkError {
+  name = "MissingEncryptorError";
+  constructor(method, options) {
+    const baseMessage = `${method}: encryptor is required \u2014 pass an \`Encryptor\` or an \`EncryptorSource\` factory.`;
+    super(options?.hint ? `${baseMessage} ${options.hint}` : baseMessage, {
+      code: "TOKENOPS_MISSING_ENCRYPTOR",
+      cause: options?.cause,
+      context: { method, hint: options?.hint }
+    });
+  }
+};
+var MissingClientError = class extends TokenOpsSdkError {
+  name = "MissingClientError";
+  constructor(hook, clientKind, options) {
+    super(`${hook}: ${clientKind} client not available.`, {
+      code: "TOKENOPS_MISSING_CLIENT",
+      cause: options?.cause,
+      context: { hook, clientKind }
+    });
+  }
+};
+var InvalidArgumentError = class extends TokenOpsSdkError {
+  name = "InvalidArgumentError";
+  constructor(args) {
+    super(`${args.method}: invalid \`${args.argument}\` \u2014 ${args.reason}`, {
+      code: "TOKENOPS_INVALID_ARGUMENT",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        argument: args.argument,
+        reason: args.reason,
+        value: args.value
+      }
+    });
+  }
+};
+var ReceiptEventNotFoundError = class extends TokenOpsSdkError {
+  name = "ReceiptEventNotFoundError";
+  constructor(args) {
+    const hint = args.hint ? ` ${args.hint}` : "";
+    super(
+      `${args.method}: no \`${args.eventName}\` event from ${args.contractAddress} in tx ${args.txHash}.${hint}`,
+      {
+        code: "TOKENOPS_RECEIPT_EVENT_NOT_FOUND",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          eventName: args.eventName,
+          contractAddress: args.contractAddress,
+          txHash: args.txHash,
+          hint: args.hint
+        }
+      }
+    );
+  }
+};
+var ReceiptEventAmbiguousError = class extends TokenOpsSdkError {
+  name = "ReceiptEventAmbiguousError";
+  constructor(args) {
+    super(
+      `${args.method}: ${args.count} \`${args.eventName}\` events from ${args.contractAddress} in tx ${args.txHash}; ambiguous result.`,
+      {
+        code: "TOKENOPS_RECEIPT_EVENT_AMBIGUOUS",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          eventName: args.eventName,
+          contractAddress: args.contractAddress,
+          txHash: args.txHash,
+          count: args.count
+        }
+      }
+    );
+  }
+};
+var ContractRevertError = class extends TokenOpsSdkError {
+  name = "ContractRevertError";
+  constructor(args) {
+    const namePart = args.revertName ?? args.revertSelector ?? "unknown";
+    const fallbackMessage = args.revertReason !== void 0 ? `${args.method}: contract reverted with "${args.revertReason}".` : `${args.method}: contract ${args.contractAddress} reverted with ${namePart}.`;
+    super(args.message ?? fallbackMessage, {
+      code: "TOKENOPS_CONTRACT_REVERT",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        revertName: args.revertName,
+        revertSelector: args.revertSelector,
+        revertArgs: args.revertArgs,
+        revertReason: args.revertReason,
+        rawRevertData: args.rawRevertData
+      }
+    });
+  }
+};
+var PausedError = class extends TokenOpsSdkError {
+  name = "PausedError";
+  constructor(args) {
+    super(`${args.method}: ${args.contractAddress} is paused; the operation cannot proceed.`, {
+      code: "TOKENOPS_PAUSED",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var AccessDeniedError = class extends TokenOpsSdkError {
+  name = "AccessDeniedError";
+  constructor(args) {
+    const who = args.account ? `account ${args.account}` : "caller";
+    const which = args.role ? ` role ${args.role}` : "";
+    super(`${args.method}: ${who} does not have${which ? which : " the required role"}.`, {
+      code: "TOKENOPS_ACCESS_DENIED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        account: args.account,
+        role: args.role
+      }
+    });
+  }
+};
+var InsufficientFeeError = class extends TokenOpsSdkError {
+  name = "InsufficientFeeError";
+  constructor(args) {
+    const detail = args.feeKind === "gas" && args.required !== void 0 ? ` Required: ${args.required.toString()} wei${args.provided !== void 0 ? `; provided: ${args.provided.toString()} wei` : ""}.` : "";
+    super(`${args.method}: ${args.feeKind} fee payment is insufficient.${detail}`, {
+      code: "TOKENOPS_INSUFFICIENT_FEE",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        feeKind: args.feeKind,
+        required: args.required,
+        provided: args.provided
+      }
+    });
+  }
+};
+var InsufficientBalanceError = class extends TokenOpsSdkError {
+  name = "InsufficientBalanceError";
+  constructor(args) {
+    const detail = args.balanceKind !== "confidential" && args.requested !== void 0 && args.available !== void 0 ? ` Requested: ${args.requested.toString()}; available: ${args.available.toString()}.` : "";
+    super(`${args.method}: ${args.balanceKind} balance is insufficient.${detail}`, {
+      code: "TOKENOPS_INSUFFICIENT_BALANCE",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        balanceKind: args.balanceKind,
+        requested: args.requested,
+        available: args.available
+      }
+    });
+  }
+};
+var BatchTooLargeError = class extends TokenOpsSdkError {
+  name = "BatchTooLargeError";
+  constructor(args) {
+    super(
+      `${args.method}: batch of ${args.requested} exceeds the configured maximum of ${args.max.toString()}.`,
+      {
+        code: "TOKENOPS_BATCH_TOO_LARGE",
+        cause: args.cause,
+        context: {
+          method: args.method,
+          contractAddress: args.contractAddress,
+          requested: args.requested,
+          max: args.max
+        }
+      }
+    );
+  }
+};
+var FeatureDisabledError = class extends TokenOpsSdkError {
+  name = "FeatureDisabledError";
+  constructor(args) {
+    super(`${args.method}: \`${args.feature}\` is disabled for this contract.`, {
+      code: "TOKENOPS_FEATURE_DISABLED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        feature: args.feature
+      }
+    });
+  }
+};
+var TransferFailedError = class extends TokenOpsSdkError {
+  name = "TransferFailedError";
+  constructor(args) {
+    const what = args.asset === "eth" ? "ETH" : `token ${args.asset}`;
+    super(`${args.method}: ${what} transfer failed at the contract layer.`, {
+      code: "TOKENOPS_TRANSFER_FAILED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        asset: args.asset
+      }
+    });
+  }
+};
+var FheHandleNotAllowedError = class extends TokenOpsSdkError {
+  name = "FheHandleNotAllowedError";
+  constructor(args) {
+    const who = args.account ?? "caller";
+    const which = args.handle ? ` on handle ${args.handle}` : "";
+    super(`${args.method}: ${who} does not hold ACL access${which}.`, {
+      code: "TOKENOPS_FHE_HANDLE_NOT_ALLOWED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        handle: args.handle,
+        account: args.account
+      }
+    });
+  }
+};
+var AlreadyInitializedError = class extends TokenOpsSdkError {
+  name = "AlreadyInitializedError";
+  constructor(args) {
+    super(`${args.method}: ${args.contractAddress} has already been initialized.`, {
+      code: "TOKENOPS_ALREADY_INITIALIZED",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var ReentrancyError = class extends TokenOpsSdkError {
+  name = "ReentrancyError";
+  constructor(args) {
+    super(`${args.method}: reentrant call into ${args.contractAddress} blocked.`, {
+      code: "TOKENOPS_REENTRANCY",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var InvalidSignatureError = class extends TokenOpsSdkError {
+  name = "InvalidSignatureError";
+  constructor(args) {
+    super(`${args.method}: signature is invalid or the signer does not hold the required role.`, {
+      code: "TOKENOPS_INVALID_SIGNATURE",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var WalletRejectedError = class extends TokenOpsSdkError {
+  name = "WalletRejectedError";
+  constructor(args) {
+    super(`${args.method}: wallet rejected the request.`, {
+      code: "TOKENOPS_WALLET_REJECTED",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var WalletChainMismatchError = class extends TokenOpsSdkError {
+  name = "WalletChainMismatchError";
+  constructor(args) {
+    super(`${args.method}: wallet is connected to a different chain than the contract.`, {
+      code: "TOKENOPS_WALLET_CHAIN_MISMATCH",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var NetworkError = class extends TokenOpsSdkError {
+  name = "NetworkError";
+  constructor(args) {
+    const status = args.statusCode !== void 0 ? ` (HTTP ${args.statusCode})` : "";
+    super(`${args.method}: network/RPC request failed${status}.`, {
+      code: "TOKENOPS_NETWORK_ERROR",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        statusCode: args.statusCode
+      }
+    });
+  }
+};
+var InsufficientGasFundsError = class extends TokenOpsSdkError {
+  name = "InsufficientGasFundsError";
+  constructor(args) {
+    super(`${args.method}: wallet has insufficient native balance to cover gas.`, {
+      code: "TOKENOPS_INSUFFICIENT_GAS_FUNDS",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var UnknownWriteFailureError = class extends TokenOpsSdkError {
+  name = "UnknownWriteFailureError";
+  constructor(args) {
+    super(`${args.method}: request failed and could not be classified by the SDK.`, {
+      code: "TOKENOPS_UNKNOWN_WRITE_FAILURE",
+      cause: args.cause,
+      context: { method: args.method, contractAddress: args.contractAddress }
+    });
+  }
+};
+var UserRejectedSignatureError = class extends TokenOpsSdkError {
+  name = "UserRejectedSignatureError";
+  constructor(args) {
+    super(`${args.method}: user rejected the wallet signature for ${args.operation}.`, {
+      code: "TOKENOPS_USER_REJECTED",
+      cause: args.cause,
+      context: { method: args.method, operation: args.operation }
+    });
+  }
+};
+var SigningFailedError = class extends TokenOpsSdkError {
+  name = "SigningFailedError";
+  constructor(args) {
+    super(`${args.method}: wallet signature failed during ${args.operation}.`, {
+      code: "TOKENOPS_SIGNING_FAILED",
+      cause: args.cause,
+      context: { method: args.method, operation: args.operation }
+    });
+  }
+};
+var RelayerUnreachableError = class extends TokenOpsSdkError {
+  name = "RelayerUnreachableError";
+  constructor(args) {
+    const status = args.statusCode !== void 0 ? ` (HTTP ${args.statusCode})` : "";
+    super(`${args.method}: Zama relayer unreachable during ${args.operation}${status}.`, {
+      code: "TOKENOPS_RELAYER_UNREACHABLE",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        operation: args.operation,
+        statusCode: args.statusCode
+      }
+    });
+  }
+};
+var EncryptionFailedError = class extends TokenOpsSdkError {
+  name = "EncryptionFailedError";
+  constructor(args) {
+    super(`${args.method}: FHE encryption failed during ${args.operation}.`, {
+      code: "TOKENOPS_ENCRYPTION_FAILED",
+      cause: args.cause,
+      context: { method: args.method, operation: args.operation }
+    });
+  }
+};
+var DecryptionFailedError = class extends TokenOpsSdkError {
+  name = "DecryptionFailedError";
+  constructor(args) {
+    super(`${args.method}: FHE decryption failed during ${args.operation}.`, {
+      code: "TOKENOPS_DECRYPTION_FAILED",
+      cause: args.cause,
+      context: { method: args.method, operation: args.operation }
+    });
+  }
+};
+var UserDecryptNotAllowedError = class extends TokenOpsSdkError {
+  name = "UserDecryptNotAllowedError";
+  constructor(args) {
+    const who = args.userAddress ?? "caller";
+    const which = args.handle ? ` on handle ${args.handle}` : "";
+    super(`${args.method}: ${who} is not allowed to user-decrypt${which}.`, {
+      code: "TOKENOPS_USER_DECRYPT_NOT_ALLOWED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        handle: args.handle,
+        userAddress: args.userAddress
+      }
+    });
+  }
+};
+var TokenOpsValidationError = class extends TokenOpsSdkError {
+  name = "TokenOpsValidationError";
+  constructor(message, context = {}) {
+    const { cause, ...rest } = context;
+    super(message, { code: "TOKENOPS_INVALID_ARGUMENT", cause, context: rest });
+  }
+};
+var TokenOpsContractError = class extends TokenOpsSdkError {
+  name = "TokenOpsContractError";
+  constructor(message, context = {}) {
+    const { cause, ...rest } = context;
+    super(message, { code: "TOKENOPS_CONTRACT_REVERT", cause, context: rest });
+  }
+};
+
+exports.AccessDeniedError = AccessDeniedError;
+exports.AlreadyInitializedError = AlreadyInitializedError;
+exports.BatchTooLargeError = BatchTooLargeError;
+exports.ContractRevertError = ContractRevertError;
+exports.DecryptionFailedError = DecryptionFailedError;
+exports.DeploymentAddressUnavailableError = DeploymentAddressUnavailableError;
+exports.EncryptionFailedError = EncryptionFailedError;
+exports.FeatureDisabledError = FeatureDisabledError;
+exports.FheHandleNotAllowedError = FheHandleNotAllowedError;
+exports.InsufficientBalanceError = InsufficientBalanceError;
+exports.InsufficientFeeError = InsufficientFeeError;
+exports.InsufficientGasFundsError = InsufficientGasFundsError;
+exports.InvalidArgumentError = InvalidArgumentError;
+exports.InvalidSignatureError = InvalidSignatureError;
+exports.MissingAccountError = MissingAccountError;
+exports.MissingClientError = MissingClientError;
+exports.MissingEncryptorError = MissingEncryptorError;
+exports.MissingPublicClientError = MissingPublicClientError;
+exports.MissingWalletClientError = MissingWalletClientError;
+exports.NetworkError = NetworkError;
+exports.PausedError = PausedError;
+exports.ReceiptEventAmbiguousError = ReceiptEventAmbiguousError;
+exports.ReceiptEventNotFoundError = ReceiptEventNotFoundError;
+exports.ReentrancyError = ReentrancyError;
+exports.RelayerUnreachableError = RelayerUnreachableError;
+exports.SigningFailedError = SigningFailedError;
+exports.TokenOpsContractError = TokenOpsContractError;
+exports.TokenOpsSdkError = TokenOpsSdkError;
+exports.TokenOpsValidationError = TokenOpsValidationError;
+exports.TransferFailedError = TransferFailedError;
+exports.UnknownWriteFailureError = UnknownWriteFailureError;
+exports.UnsupportedChainError = UnsupportedChainError;
+exports.UserDecryptNotAllowedError = UserDecryptNotAllowedError;
+exports.UserRejectedSignatureError = UserRejectedSignatureError;
+exports.WalletChainMismatchError = WalletChainMismatchError;
+exports.WalletRejectedError = WalletRejectedError;
+exports.isTokenOpsSdkError = isTokenOpsSdkError;