@tokenops/sdk 1.0.0

package/dist/chunk-ITQ7WKVC.cjs

@@ -0,0 +1,101 @@
+'use strict';
+
+var chunkCQIPRNS7_cjs = require('./chunk-CQIPRNS7.cjs');
+var chunkVJKZWYYJ_cjs = require('./chunk-VJKZWYYJ.cjs');
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+
+// src/fhe/operators.ts
+var ERC7984_SET_OPERATOR_ABI = [
+  {
+    type: "function",
+    name: "setOperator",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "operator", type: "address" },
+      { name: "until", type: "uint48" }
+    ],
+    outputs: []
+  }
+];
+var ERC7984_OPERATOR_MAX_DEADLINE = (1n << 48n) - 1n;
+async function setOperator(args) {
+  const { publicClient, walletClient, account, waitForReceipt = true, telemetry } = args;
+  const token = chunkCQIPRNS7_cjs.normaliseAddress(args.token);
+  const spender = chunkCQIPRNS7_cjs.normaliseAddress(args.spender);
+  const deadline = args.deadline ?? ERC7984_OPERATOR_MAX_DEADLINE;
+  return chunkVJKZWYYJ_cjs.withTelemetry(telemetry, "fhe.setOperator", async () => {
+    const fromAccount = account ?? walletClient.account;
+    if (!fromAccount) {
+      throw new chunk56UI7LUR_cjs.TokenOpsContractError(
+        "setOperator: no account available \u2014 pass `account` explicitly or attach an account to the walletClient",
+        { contract: "ERC7984", call: "setOperator" }
+      );
+    }
+    if (deadline < 0n || deadline > ERC7984_OPERATOR_MAX_DEADLINE) {
+      throw new chunk56UI7LUR_cjs.TokenOpsContractError(
+        `setOperator: deadline ${deadline} out of uint48 range [0, ${ERC7984_OPERATOR_MAX_DEADLINE}]`,
+        { contract: "ERC7984", call: "setOperator", deadline: deadline.toString() }
+      );
+    }
+    const deadlineNum = Number(deadline);
+    let hash;
+    try {
+      hash = await walletClient.writeContract({
+        address: token,
+        abi: ERC7984_SET_OPERATOR_ABI,
+        functionName: "setOperator",
+        args: [spender, deadlineNum],
+        account: fromAccount,
+        // viem requires `chain` to be passed explicitly when the wallet has
+        // no default chain (e.g. some consumer-side constructions). Forward
+        // whatever the wallet is bound to; viem accepts undefined and falls
+        // back to the wallet's chain when present.
+        chain: walletClient.chain
+      });
+    } catch (err) {
+      throw new chunk56UI7LUR_cjs.TokenOpsContractError(
+        `setOperator: writeContract failed (token=${token}, spender=${spender})`,
+        {
+          contract: "ERC7984",
+          call: "setOperator",
+          token,
+          spender,
+          cause: err
+        }
+      );
+    }
+    if (waitForReceipt) {
+      try {
+        await publicClient.waitForTransactionReceipt({ hash });
+      } catch (err) {
+        throw new chunk56UI7LUR_cjs.TokenOpsContractError(`setOperator: receipt wait failed (tx=${hash})`, {
+          contract: "ERC7984",
+          call: "setOperator",
+          tx: hash,
+          cause: err
+        });
+      }
+    }
+    return hash;
+  });
+}
+async function revokeOperator(args) {
+  return chunkVJKZWYYJ_cjs.withTelemetry(args.telemetry, "fhe.revokeOperator", async () => {
+    return setOperator({
+      publicClient: args.publicClient,
+      walletClient: args.walletClient,
+      ...args.account !== void 0 ? { account: args.account } : {},
+      token: args.token,
+      spender: args.spender,
+      deadline: 0n,
+      ...args.waitForReceipt !== void 0 ? { waitForReceipt: args.waitForReceipt } : {}
+      // Do NOT forward `telemetry` — the inner `fhe.setOperator` span would
+      // double-emit. The outer `fhe.revokeOperator` span carries the call.
+    });
+  });
+}
+
+exports.ERC7984_OPERATOR_MAX_DEADLINE = ERC7984_OPERATOR_MAX_DEADLINE;
+exports.ERC7984_SET_OPERATOR_ABI = ERC7984_SET_OPERATOR_ABI;
+exports.revokeOperator = revokeOperator;
+exports.setOperator = setOperator;

package/dist/chunk-IVE3QEGD.js

@@ -0,0 +1,478 @@
+// 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 });
+  }
+};
+
+export { AccessDeniedError, AlreadyInitializedError, BatchTooLargeError, ContractRevertError, DecryptionFailedError, DeploymentAddressUnavailableError, EncryptionFailedError, FeatureDisabledError, FheHandleNotAllowedError, InsufficientBalanceError, InsufficientFeeError, InsufficientGasFundsError, InvalidArgumentError, InvalidSignatureError, MissingAccountError, MissingClientError, MissingEncryptorError, MissingPublicClientError, MissingWalletClientError, NetworkError, PausedError, ReceiptEventAmbiguousError, ReceiptEventNotFoundError, ReentrancyError, RelayerUnreachableError, SigningFailedError, TokenOpsContractError, TokenOpsSdkError, TokenOpsValidationError, TransferFailedError, UnknownWriteFailureError, UnsupportedChainError, UserDecryptNotAllowedError, UserRejectedSignatureError, WalletChainMismatchError, WalletRejectedError, isTokenOpsSdkError };