@tokenops/sdk 1.6.0 → 2.0.0-alpha.2

package/dist/chunk-UE5XK2SY.js

@@ -1,1673 +0,0 @@
-import { erc7984OperatorAbi } from './chunk-7VELUOMI.js';
-import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-6WSNS3UV.js';
-import { getFheAirdropFactoryAddress } from './chunk-QKKBBH7I.js';
-import { normaliseAddress } from './chunk-46T67CE2.js';
-import { InvalidArgumentError, asExternalInputProof, asEncryptedHandle, TokenOpsSdkError, MissingAccountError, asSignature, DeploymentAddressUnavailableError, OperatorNotApprovedError, AlreadyInitializedError, asTxHash, MissingWalletClientError, MissingEncryptorError } from './chunk-DRSPMIZ7.js';
-import { withTelemetry } from './chunk-Q2GP5UDC.js';
-import { bytesToHex, isAddress, parseEventLogs, BaseError, ContractFunctionZeroDataError } from 'viem';
-
-// src/fhe-airdrop/abis/factory.ts
-var confidentialAirdropFactoryAbi = [
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "implementation_",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "feeCollector_",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "defaultGasFee_",
-        type: "uint256"
-      },
-      {
-        internalType: "address",
-        name: "admin",
-        type: "address"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  {
-    inputs: [],
-    name: "AccessControlBadConfirmation",
-    type: "error"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "account",
-        type: "address"
-      },
-      {
-        internalType: "bytes32",
-        name: "neededRole",
-        type: "bytes32"
-      }
-    ],
-    name: "AccessControlUnauthorizedAccount",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "EndTimeInPast",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "InvalidAddress",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "InvalidDuration",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "InvalidStartTime",
-    type: "error"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "handle",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "sender",
-        type: "address"
-      }
-    ],
-    name: "SenderNotAllowedToUseHandle",
-    type: "error"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "sender",
-        type: "address"
-      }
-    ],
-    name: "SenderNotAllowed",
-    type: "error"
-  },
-  {
-    inputs: [],
-    name: "ZamaProtocolUnsupported",
-    type: "error"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "airdrop",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "admin",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "address",
-        name: "feeCollector",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint32",
-        name: "startTime",
-        type: "uint32"
-      },
-      {
-        indexed: false,
-        internalType: "uint32",
-        name: "endTime",
-        type: "uint32"
-      },
-      {
-        indexed: false,
-        internalType: "bool",
-        name: "canExtendClaimWindow",
-        type: "bool"
-      },
-      {
-        indexed: false,
-        internalType: "address",
-        name: "creator",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "bytes32",
-        name: "userSalt",
-        type: "bytes32"
-      }
-    ],
-    name: "ConfidentialAirdropCreated",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "airdrop",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "euint64",
-        name: "transferredAmount",
-        type: "bytes32"
-      }
-    ],
-    name: "ConfidentialAirdropFunded",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "admin",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "newFeeCollector",
-        type: "address"
-      }
-    ],
-    name: "FeeCollectorSet",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "previousAdminRole",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "newAdminRole",
-        type: "bytes32"
-      }
-    ],
-    name: "RoleAdminChanged",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "account",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "sender",
-        type: "address"
-      }
-    ],
-    name: "RoleGranted",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "account",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "sender",
-        type: "address"
-      }
-    ],
-    name: "RoleRevoked",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "admin",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "bool",
-        name: "enabled",
-        type: "bool"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "campaignCreator",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      }
-    ],
-    name: "SetCustomFee",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "admin",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "oldGasFee",
-        type: "uint256"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "newGasFee",
-        type: "uint256"
-      }
-    ],
-    name: "SetDefaultGasFee",
-    type: "event"
-  },
-  {
-    inputs: [],
-    name: "DEFAULT_ADMIN_ROLE",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "",
-        type: "bytes32"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "FEE_MANAGER_ROLE",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "",
-        type: "bytes32"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "confidentialProtocolId",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            internalType: "address",
-            name: "token",
-            type: "address"
-          },
-          {
-            internalType: "uint32",
-            name: "startTime",
-            type: "uint32"
-          },
-          {
-            internalType: "uint32",
-            name: "endTime",
-            type: "uint32"
-          },
-          {
-            internalType: "bool",
-            name: "canExtendClaimWindow",
-            type: "bool"
-          },
-          {
-            internalType: "address",
-            name: "admin",
-            type: "address"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.AirdropParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "bytes32",
-        name: "userSalt",
-        type: "bytes32"
-      },
-      {
-        internalType: "externalEuint64",
-        name: "encryptedAmount",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes",
-        name: "inputProof",
-        type: "bytes"
-      }
-    ],
-    name: "createAndFundConfidentialAirdrop",
-    outputs: [
-      {
-        internalType: "address",
-        name: "airdrop",
-        type: "address"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            internalType: "address",
-            name: "token",
-            type: "address"
-          },
-          {
-            internalType: "uint32",
-            name: "startTime",
-            type: "uint32"
-          },
-          {
-            internalType: "uint32",
-            name: "endTime",
-            type: "uint32"
-          },
-          {
-            internalType: "bool",
-            name: "canExtendClaimWindow",
-            type: "bool"
-          },
-          {
-            internalType: "address",
-            name: "admin",
-            type: "address"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.AirdropParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "bytes32",
-        name: "userSalt",
-        type: "bytes32"
-      }
-    ],
-    name: "createConfidentialAirdrop",
-    outputs: [
-      {
-        internalType: "address",
-        name: "airdrop",
-        type: "address"
-      }
-    ],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "defaultGasFee",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "campaignCreator",
-        type: "address"
-      }
-    ],
-    name: "disableCustomFee",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "feeCollector",
-    outputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "token",
-        type: "address"
-      },
-      {
-        components: [
-          {
-            internalType: "address",
-            name: "token",
-            type: "address"
-          },
-          {
-            internalType: "uint32",
-            name: "startTime",
-            type: "uint32"
-          },
-          {
-            internalType: "uint32",
-            name: "endTime",
-            type: "uint32"
-          },
-          {
-            internalType: "bool",
-            name: "canExtendClaimWindow",
-            type: "bool"
-          },
-          {
-            internalType: "address",
-            name: "admin",
-            type: "address"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.AirdropParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "bytes32",
-        name: "userSalt",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "deployer",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      },
-      {
-        internalType: "externalEuint64",
-        name: "encryptedAmount",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes",
-        name: "inputProof",
-        type: "bytes"
-      }
-    ],
-    name: "fundConfidentialAirdrop",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "campaignCreator",
-        type: "address"
-      }
-    ],
-    name: "getCustomFee",
-    outputs: [
-      {
-        components: [
-          {
-            internalType: "bool",
-            name: "enabled",
-            type: "bool"
-          },
-          {
-            internalType: "uint256",
-            name: "gasFee",
-            type: "uint256"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.CustomFee",
-        name: "",
-        type: "tuple"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            internalType: "address",
-            name: "token",
-            type: "address"
-          },
-          {
-            internalType: "uint32",
-            name: "startTime",
-            type: "uint32"
-          },
-          {
-            internalType: "uint32",
-            name: "endTime",
-            type: "uint32"
-          },
-          {
-            internalType: "bool",
-            name: "canExtendClaimWindow",
-            type: "bool"
-          },
-          {
-            internalType: "address",
-            name: "admin",
-            type: "address"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.AirdropParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      }
-    ],
-    name: "getInitCodeHash",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "hash",
-        type: "bytes32"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      }
-    ],
-    name: "getRoleAdmin",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "",
-        type: "bytes32"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "account",
-        type: "address"
-      }
-    ],
-    name: "grantRole",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "account",
-        type: "address"
-      }
-    ],
-    name: "hasRole",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "implementation",
-    outputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        components: [
-          {
-            internalType: "address",
-            name: "token",
-            type: "address"
-          },
-          {
-            internalType: "uint32",
-            name: "startTime",
-            type: "uint32"
-          },
-          {
-            internalType: "uint32",
-            name: "endTime",
-            type: "uint32"
-          },
-          {
-            internalType: "bool",
-            name: "canExtendClaimWindow",
-            type: "bool"
-          },
-          {
-            internalType: "address",
-            name: "admin",
-            type: "address"
-          }
-        ],
-        internalType: "struct IConfidentialAirdropFactory.AirdropParams",
-        name: "params",
-        type: "tuple"
-      },
-      {
-        internalType: "bytes32",
-        name: "userSalt",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "deployer",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      }
-    ],
-    name: "predictAirdropAddress",
-    outputs: [
-      {
-        internalType: "address",
-        name: "predicted",
-        type: "address"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "callerConfirmation",
-        type: "address"
-      }
-    ],
-    name: "renounceRole",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes32",
-        name: "role",
-        type: "bytes32"
-      },
-      {
-        internalType: "address",
-        name: "account",
-        type: "address"
-      }
-    ],
-    name: "revokeRole",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "campaignCreator",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "gasFee",
-        type: "uint256"
-      }
-    ],
-    name: "setCustomFee",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "uint256",
-        name: "newGasFee",
-        type: "uint256"
-      }
-    ],
-    name: "setDefaultGasFee",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "address",
-        name: "newFeeCollector",
-        type: "address"
-      }
-    ],
-    name: "setFeeCollector",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      {
-        internalType: "bytes4",
-        name: "interfaceId",
-        type: "bytes4"
-      }
-    ],
-    name: "supportsInterface",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-function resolveEncryptor(source) {
-  if (source === void 0) return void 0;
-  return typeof source === "function" ? source() : source;
-}
-var MAX_UINT64 = (1n << 64n) - 1n;
-function assertUint64(value, label) {
-  if (value < 0n || value > MAX_UINT64) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64",
-      argument: label,
-      reason: "exceeds uint64 range (0..2^64-1)",
-      value
-    });
-  }
-}
-async function encryptUint64({
-  encryptor,
-  contractAddress,
-  userAddress,
-  value
-}) {
-  assertUint64(value, "value");
-  const { handles, inputProof } = await encryptor.encrypt({
-    values: [{ value, type: "euint64" }],
-    contractAddress,
-    userAddress
-  });
-  if (handles.length !== 1) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64",
-      argument: "handles",
-      reason: `expected 1 handle, got ${handles.length}`,
-      value: handles.length
-    });
-  }
-  return {
-    handle: asEncryptedHandle(bytesToHex(handles[0])),
-    inputProof: asExternalInputProof(bytesToHex(inputProof))
-  };
-}
-async function encryptUint64Batch({
-  encryptor,
-  contractAddress,
-  userAddress,
-  values
-}) {
-  if (values.length === 0) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64Batch",
-      argument: "values",
-      reason: "must be non-empty"
-    });
-  }
-  values.forEach((v, i) => assertUint64(v, `values[${i}]`));
-  const { handles, inputProof } = await encryptor.encrypt({
-    values: values.map((value) => ({ value, type: "euint64" })),
-    contractAddress,
-    userAddress
-  });
-  if (handles.length !== values.length) {
-    throw new InvalidArgumentError({
-      method: "encryptUint64Batch",
-      argument: "handles",
-      reason: `expected ${values.length} handles, got ${handles.length}`,
-      value: handles.length
-    });
-  }
-  return {
-    handles: handles.map((h) => asEncryptedHandle(bytesToHex(h))),
-    inputProof: asExternalInputProof(bytesToHex(inputProof))
-  };
-}
-async function signClaimAuthorization(args) {
-  if (args.encryptedAmountHandle.length !== 66) {
-    throw new TokenOpsSdkError(
-      `signClaimAuthorization: encryptedAmountHandle must be a 32-byte hex string (0x + 64 chars), got length ${args.encryptedAmountHandle.length}`
-    );
-  }
-  const account = args.walletClient.account;
-  if (!account) {
-    throw new MissingAccountError("signClaimAuthorization");
-  }
-  const chainId = args.walletClient.chain?.id;
-  if (!chainId) {
-    throw new InvalidArgumentError({
-      method: "signClaimAuthorization",
-      argument: "walletClient.chain.id",
-      reason: "required for EIP712 chainId binding; pass a walletClient constructed with a known chain (e.g. `createWalletClient({ chain: sepolia, ... })`)."
-    });
-  }
-  const sig = await args.walletClient.signTypedData({
-    account,
-    domain: {
-      name: "ConfidentialAirdrop",
-      version: "1",
-      chainId,
-      verifyingContract: args.airdropAddress
-    },
-    types: {
-      Claim: [
-        { name: "recipient", type: "address" },
-        { name: "encryptedAmount", type: "bytes32" }
-      ]
-    },
-    primaryType: "Claim",
-    message: {
-      recipient: args.recipient,
-      encryptedAmount: args.encryptedAmountHandle
-    }
-  });
-  return asSignature(sig);
-}
-var airdropFactoryProductMapper = () => void 0;
-var ConfidentialAirdropFactoryClient = class {
-  publicClient;
-  walletClient;
-  address;
-  encryptor;
-  #telemetry;
-  constructor(config) {
-    this.publicClient = config.publicClient;
-    this.walletClient = config.walletClient;
-    this.encryptor = config.encryptor;
-    const chainId = config.chainId ?? config.publicClient.chain?.id;
-    const addressOverride = config.address ? normaliseAddress(config.address) : void 0;
-    const resolved = addressOverride ?? (chainId === void 0 ? void 0 : getFheAirdropFactoryAddress(chainId));
-    if (!resolved) {
-      throw new DeploymentAddressUnavailableError({
-        reason: chainId === void 0 ? "chain-id-missing" : "registry-not-deployed",
-        product: "fheAirdrop",
-        contract: "confidentialAirdropFactory",
-        chainId,
-        clientLabel: "ConfidentialAirdropFactoryClient"
-      });
-    }
-    this.address = resolved;
-    this.#telemetry = config.telemetry;
-    this.#telemetry?.event("fhe-airdrop.client.init", {
-      surface: "factory",
-      chainId: chainId ?? null,
-      hasWallet: !!this.walletClient,
-      aclResolved: true,
-      // factory has no ACL dependency; constant for funnel-shape parity with client.
-      sdkVersion: SDK_VERSION
-    });
-  }
-  // ----------------------- writes -----------------------
-  /**
-   * Deploy a new airdrop clone via the factory and return its address, parsed
-   * from the `ConfidentialAirdropCreated` event in the tx receipt.
-   *
-   * **This is the headline factory entry point.** It returns one rich-return
-   * shape: most consumers want the deployed address back, and the SDK already
-   * waits for and parses the event, so there's no reason to make consumers do
-   * it themselves.
-   *
-   * Internally: `writeContract` → {@link PublicClient.waitForTransactionReceipt} →
-   * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
-   *
-   * For genuine pre-mine prediction (rare), import
-   * `ConfidentialAirdropFactoryAdvancedClient` from
-   * `@tokenops/sdk/fhe-airdrop/advanced` and call `predictAirdropAddress`.
-   *
-   * @example
-   * const { hash, airdrop } = await factory.createConfidentialAirdrop({
-   *   params, userSalt,
-   * });
-   */
-  async createConfidentialAirdrop(args) {
-    return withTelemetry(
-      this.#telemetry,
-      "fhe-airdrop.factory.createConfidentialAirdrop",
-      async () => {
-        const hash = await this.#write(
-          "createConfidentialAirdrop",
-          [toAbiParams(args.params), args.userSalt],
-          args.account
-        );
-        return this.#resolveAirdropFromReceipt(hash, "createConfidentialAirdrop");
-      }
-    );
-  }
-  /**
-   * Deploy and fund a new airdrop in a single transaction, and return its
-   * address. The SDK encrypts `amount` into an `externalEuint64` before
-   * passing to the contract.
-   *
-   * Prerequisites: caller must have set this factory as an operator on the
-   * token: `token.setOperator(factoryAddress, deadline)`.
-   *
-   * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
-   *
-   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
-   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
-   * ERC-20. Amount parameters are base units of the token's actual decimals:
-   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
-   * transparent TTT test token uses 18 decimals.
-   *
-   * Symmetric with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop}
-   * — both return `{ hash, airdrop }` parsed from the
-   * `ConfidentialAirdropCreated` event.
-   *
-   * @example
-   * const { hash, airdrop } = await factory.createAndFundConfidentialAirdrop({
-   *   params, userSalt, amount: 1_000_000n,
-   * });
-   */
-  async createAndFundConfidentialAirdrop(args) {
-    return withTelemetry(
-      this.#telemetry,
-      "fhe-airdrop.factory.createAndFundConfidentialAirdrop",
-      async () => {
-        const wallet = this.#requireWallet("createAndFundConfidentialAirdrop");
-        const account = this.#resolveAccount(
-          wallet,
-          args.account,
-          "createAndFundConfidentialAirdrop"
-        );
-        const encrypted = await this.#encryptAmount(
-          args.amount,
-          args.encryptor,
-          args.encryptedInput,
-          account,
-          "createAndFundConfidentialAirdrop"
-        );
-        const writeArgs = [
-          toAbiParams(args.params),
-          args.userSalt,
-          encrypted.handle,
-          encrypted.inputProof
-        ];
-        await this.#preflightWrite(
-          "createAndFundConfidentialAirdrop",
-          "createAndFundConfidentialAirdrop",
-          writeArgs,
-          account
-        );
-        let hash;
-        try {
-          hash = await wallet.writeContract({
-            address: this.address,
-            abi: confidentialAirdropFactoryAbi,
-            functionName: "createAndFundConfidentialAirdrop",
-            args: writeArgs,
-            account,
-            chain: wallet.chain
-          });
-        } catch (err) {
-          throw this.#mapRevert("createAndFundConfidentialAirdrop", err, accountAddress(account));
-        }
-        return this.#resolveAirdropFromReceipt(hash, "createAndFundConfidentialAirdrop");
-      }
-    );
-  }
-  /**
-   * Fund an existing (or not-yet-deployed) airdrop with encrypted tokens.
-   *
-   * Prerequisites: caller must have set this factory as an operator on the token:
-   * `token.setOperator(factoryAddress, deadline)`
-   *
-   * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
-   *
-   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
-   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
-   * ERC-20. Amount parameters are base units of the token's actual decimals:
-   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
-   * transparent TTT test token uses 18 decimals.
-   *
-   * @returns Transaction hash.
-   */
-  async fundConfidentialAirdrop(args) {
-    const wallet = this.#requireWallet("fundConfidentialAirdrop");
-    const account = this.#resolveAccount(wallet, args.account, "fundConfidentialAirdrop");
-    const encrypted = await this.#encryptAmount(
-      args.amount,
-      args.encryptor,
-      args.encryptedInput,
-      account,
-      "fundConfidentialAirdrop"
-    );
-    const writeArgs = [
-      args.token,
-      toAbiParams(args.params),
-      args.userSalt,
-      args.deployer,
-      args.gasFee,
-      encrypted.handle,
-      encrypted.inputProof
-    ];
-    await this.#preflightWrite(
-      "fundConfidentialAirdrop",
-      "fundConfidentialAirdrop",
-      writeArgs,
-      account
-    );
-    try {
-      return await wallet.writeContract({
-        address: this.address,
-        abi: confidentialAirdropFactoryAbi,
-        functionName: "fundConfidentialAirdrop",
-        args: writeArgs,
-        account,
-        chain: wallet.chain
-      });
-    } catch (err) {
-      throw this.#mapRevert("fundConfidentialAirdrop", err, accountAddress(account));
-    }
-  }
-  /**
-   * Deploy a new airdrop clone and return its address, parsed from the
-   * `ConfidentialAirdropCreated` event in the tx receipt.
-   *
-   * Symmetry helper with the fhe-vesting client. Use this when you want a
-   * one-call "deploy and use" shape; otherwise call
-   * {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop} and parse
-   * the receipt yourself, or call
-   * {@link ConfidentialAirdropFactoryClient.predictAirdropAddress} before mining.
-   *
-   * Internally: {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop} →
-   * {@link PublicClient.waitForTransactionReceipt} →
-   * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
-   *
-   * @example
-   * const { hash, airdrop } = await factory.createConfidentialAirdropAndGetAddress({
-   *   params, userSalt,
-   * });
-   */
-  async createConfidentialAirdropAndGetAddress(args) {
-    return this.createConfidentialAirdrop(args);
-  }
-  /**
-   * Deploy AND fund a new airdrop clone in one tx, returning its address parsed
-   * from the `ConfidentialAirdropCreated` event in the receipt.
-   *
-   * Symmetry with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdropAndGetAddress}
-   * — use this when you also need to seed the pool in the same transaction.
-   *
-   * **Silent-zero transfers.** ERC-7984 transfers do not revert when the sender's encrypted balance is insufficient — the transfer succeeds and moves an encrypted zero instead. This is by design: reverting would leak balance information. The transaction receipt alone cannot tell you whether value actually moved.
-   *
-   * **Amount units:** TokenOps confidential (ERC-7984) tokens use a 6-decimals
-   * convention (1 token = 1_000_000 base units), not the 18 decimals typical of
-   * ERC-20. Amount parameters are base units of the token's actual decimals:
-   * for the CTTT test token (6 decimals) `1_000_000n` = 1 CTTT, while the
-   * transparent TTT test token uses 18 decimals.
-   *
-   * Internally: {@link ConfidentialAirdropFactoryClient.createAndFundConfidentialAirdrop} →
-   * {@link PublicClient.waitForTransactionReceipt} →
-   * `parseEventLogs({ eventName: "ConfidentialAirdropCreated" })`.
-   *
-   * @example
-   * const { hash, airdrop } = await factory.createAndFundConfidentialAirdropAndGetAddress({
-   *   params, userSalt, amount, encryptor,
-   * });
-   */
-  async createAndFundConfidentialAirdropAndGetAddress(args) {
-    return this.createAndFundConfidentialAirdrop(args);
-  }
-  // ----------------------- fee management (FEE_MANAGER_ROLE) -----------------------
-  /** Change the fee collector address. FEE_MANAGER_ROLE only. */
-  async setFeeCollector(newFeeCollector, account) {
-    return withTelemetry(this.#telemetry, "fhe-airdrop.factory.setFeeCollector", async () => {
-      return this.#write("setFeeCollector", [newFeeCollector], account);
-    });
-  }
-  /** Change the default per-claim gas fee in wei. FEE_MANAGER_ROLE only. */
-  async setDefaultGasFee(newGasFee, account) {
-    return withTelemetry(this.#telemetry, "fhe-airdrop.factory.setDefaultGasFee", async () => {
-      return this.#write("setDefaultGasFee", [newGasFee], account);
-    });
-  }
-  /** Set a per-creator gas fee override. FEE_MANAGER_ROLE only. */
-  async setCustomFee(campaignCreator, gasFee, account) {
-    return withTelemetry(this.#telemetry, "fhe-airdrop.factory.setCustomFee", async () => {
-      return this.#write("setCustomFee", [campaignCreator, gasFee], account);
-    });
-  }
-  /** Remove a per-creator fee override, reverting to `defaultGasFee`. FEE_MANAGER_ROLE only. */
-  async disableCustomFee(campaignCreator, account) {
-    return withTelemetry(this.#telemetry, "fhe-airdrop.factory.disableCustomFee", async () => {
-      return this.#write("disableCustomFee", [campaignCreator], account);
-    });
-  }
-  // ----------------------- reads -----------------------
-  /** Current LibClone implementation address. */
-  async implementation() {
-    return this.#read("implementation");
-  }
-  /**
-   * Alias for {@link ConfidentialAirdropFactoryClient.implementation} that matches
-   * the contract's storage field name (`_airdropImplementation`).
-   *
-   * Provided for parity with `fhe-vesting`'s `managerImplementation()` alias.
-   * The airdrop factory has the same
-   * LibClone shape mirroring `_airdropImplementation` storage, so server
-   * devs reading the Solidity first reach for `factory.airdropImplementation()`
-   * via autocomplete and would otherwise hit a TS2551 on the SDK's
-   * `implementation()` shape. The canonical `implementation()` method is
-   * retained for backwards-compat and cross-factory uniformity.
-   */
-  async airdropImplementation() {
-    return this.implementation();
-  }
-  /** Default per-claim gas fee in wei. Used when no custom fee is set for the campaign creator. */
-  async defaultGasFee() {
-    return this.#read("defaultGasFee");
-  }
-  /** Address authorized to collect gas fees from airdrop clones. */
-  async feeCollector() {
-    return this.#read("feeCollector");
-  }
-  /** Per-creator custom fee override. `enabled` is `false` when no override is set. */
-  async getCustomFee(campaignCreator) {
-    const raw = await this.#read("getCustomFee", [
-      campaignCreator
-    ]);
-    return { enabled: raw.enabled, gasFee: raw.gasFee };
-  }
-  /**
-   * Compute the CREATE2 init-code hash for a given set of params and gas fee.
-   * Useful for deriving the clone address off-chain. Use `predictAirdropAddress` from
-   * `@tokenops/sdk/fhe-airdrop/advanced` for the full address derivation.
-   * @param args `{ params, gasFee }` — must match the values used at deploy time.
-   * @returns `bytes32` init-code hash.
-   */
-  async getInitCodeHash(args) {
-    return this.#read("getInitCodeHash", [toAbiParams(args.params), args.gasFee]);
-  }
-  // ----------------------- preflight -----------------------
-  /**
-   * Read-only preflight for {@link createConfidentialAirdrop} /
-   * {@link createAndFundConfidentialAirdrop}. Runs the
-   * deterministic-from-off-chain checks and reports blockers both as
-   * human-readable strings (`blockers`) and as typed {@link TokenOpsSdkError}s
-   * (`blockerErrors`), index-aligned.
-   *
-   * Preflight is **opt-in**. Consumers who have already validated state can
-   * skip this call and invoke the write directly — they'll receive the same
-   * typed errors at write time via the revert mapper.
-   *
-   * Report fields: `isFactoryOperator`, `gasFee`, `predictedAirdrop`,
-   * `alreadyDeployed`, `ready`, `blockers`, `blockerErrors` — see
-   * {@link CreateAirdropPreflightReport} for the meaning of each.
-   *
-   * Checks performed (all read-only, no gas):
-   * - Structural `params` validation mirroring the factory + clone
-   *   `initialize` requirements (`InvalidArgumentError` blockers): `token` and
-   *   `admin` are checksummed non-zero addresses,
-   *   `startTimestamp < endTimestamp`, and `endTimestamp` is in the future
-   *   (the clone's `initialize` reverts with `EndTimeInPast`).
-   * - Operator: creator has approved this factory as an ERC-7984 operator on
-   *   `params.token` — a blocker only when `funding: true`
-   *   ({@link OperatorNotApprovedError}); otherwise informational via
-   *   `isFactoryOperator`.
-   * - Collision (only when `userSalt` is supplied): bytecode already at the
-   *   predicted CREATE2 address means a repeat create with the same
-   *   `(params, userSalt, gasFee)` would revert
-   *   ({@link AlreadyInitializedError} blocker).
-   *
-   * **Not preflight-detectable — read before trusting `ready: true`:** the
-   * creator's confidential token balance is an encrypted `euint64` the SDK
-   * cannot read in plaintext, and an underfunded `createAndFund` does **not**
-   * revert — the ERC-7984 transfer silently moves an encrypted zero. Confirm
-   * the creator's balance covers the pool before submitting.
-   *
-   * @param args See {@link PreflightCreateAirdropArgs}.
-   * @returns A {@link CreateAirdropPreflightReport}.
-   */
-  async preflightCreateAirdrop(args) {
-    const { params, creator, userSalt, funding } = args;
-    const blockers = [];
-    const blockerErrors = [];
-    const pushBlocker = (err) => {
-      blockerErrors.push(err);
-      blockers.push(err.message);
-    };
-    const tokenOk = isAddress(params.token, { strict: true }) && params.token !== ZERO_ADDRESS;
-    if (!tokenOk) {
-      pushBlocker(
-        new InvalidArgumentError({
-          method: "createConfidentialAirdrop",
-          argument: "params.token",
-          reason: "must be a valid, non-zero EIP-55 checksummed address",
-          value: params.token
-        })
-      );
-    }
-    const adminOk = isAddress(params.admin, { strict: true }) && params.admin !== ZERO_ADDRESS;
-    if (!adminOk) {
-      pushBlocker(
-        new InvalidArgumentError({
-          method: "createConfidentialAirdrop",
-          argument: "params.admin",
-          reason: "must be a valid, non-zero EIP-55 checksummed address",
-          value: params.admin
-        })
-      );
-    }
-    if (params.startTimestamp >= params.endTimestamp) {
-      pushBlocker(
-        new InvalidArgumentError({
-          method: "createConfidentialAirdrop",
-          argument: "params.startTimestamp/params.endTimestamp",
-          reason: "startTimestamp must be strictly less than endTimestamp",
-          value: { startTimestamp: params.startTimestamp, endTimestamp: params.endTimestamp }
-        })
-      );
-    }
-    const [block, customFee, defaultFee, operatorRead] = await Promise.all([
-      this.publicClient.getBlock(),
-      this.getCustomFee(creator),
-      this.defaultGasFee(),
-      tokenOk ? this.publicClient.readContract({
-        address: params.token,
-        abi: erc7984OperatorAbi,
-        functionName: "isOperator",
-        args: [creator, this.address]
-      }).then((v) => ({ ok: true, value: v })).catch((err) => {
-        if (isNotErc7984Failure(err)) return { ok: false, err };
-        throw err;
-      }) : Promise.resolve({ ok: true, value: false })
-    ]);
-    const isFactoryOperator = operatorRead.ok ? operatorRead.value : false;
-    if (!operatorRead.ok) {
-      pushBlocker(
-        new InvalidArgumentError({
-          method: "createConfidentialAirdrop",
-          argument: "params.token",
-          reason: "does not implement the ERC-7984 `isOperator(address,address)` view \u2014 it is not a confidential token (or the address holds no contract on this chain)",
-          value: params.token
-        })
-      );
-    }
-    const gasFee = customFee.enabled ? customFee.gasFee : defaultFee;
-    if (params.endTimestamp <= Number(block.timestamp)) {
-      pushBlocker(
-        new InvalidArgumentError({
-          method: "createConfidentialAirdrop",
-          argument: "params.endTimestamp",
-          reason: "must be in the future (the clone's initialize reverts with EndTimeInPast)",
-          value: params.endTimestamp
-        })
-      );
-    }
-    if (funding === true && tokenOk && operatorRead.ok && !isFactoryOperator) {
-      pushBlocker(
-        new OperatorNotApprovedError({
-          method: "createAndFundConfidentialAirdrop",
-          contractAddress: this.address,
-          tokenAddress: params.token,
-          holder: creator,
-          spender: this.address
-        })
-      );
-    }
-    let predictedAirdrop;
-    let alreadyDeployed;
-    if (userSalt !== void 0 && tokenOk && adminOk) {
-      predictedAirdrop = await this.#read("predictAirdropAddress", [
-        toAbiParams(params),
-        userSalt,
-        creator,
-        gasFee
-      ]);
-      const bytecode = await this.publicClient.getCode({ address: predictedAirdrop });
-      alreadyDeployed = bytecode !== void 0 && bytecode !== "0x";
-      if (alreadyDeployed) {
-        pushBlocker(
-          new AlreadyInitializedError({
-            method: "createConfidentialAirdrop",
-            contractAddress: predictedAirdrop
-          })
-        );
-      }
-    }
-    return {
-      isFactoryOperator,
-      gasFee,
-      predictedAirdrop,
-      alreadyDeployed,
-      ready: blockers.length === 0,
-      blockers,
-      blockerErrors
-    };
-  }
-  // ----------------------- internals -----------------------
-  /**
-   * Wait for the receipt of a clone-deploy tx and parse the
-   * `ConfidentialAirdropCreated` event to extract the deployed airdrop
-   * address. Branded result; throws `TokenOpsSdkError` if zero or >1 events
-   * match this factory address.
-   */
-  async #resolveAirdropFromReceipt(hash, method) {
-    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
-    const events = parseEventLogs({
-      abi: confidentialAirdropFactoryAbi,
-      eventName: "ConfidentialAirdropCreated",
-      logs: receipt.logs
-    });
-    const ours = events.filter((ev) => ev.address.toLowerCase() === this.address.toLowerCase());
-    if (ours.length === 0) {
-      throw new TokenOpsSdkError(
-        `${method}: no ConfidentialAirdropCreated event from factory ${this.address} in tx ${hash}`
-      );
-    }
-    if (ours.length > 1) {
-      throw new TokenOpsSdkError(
-        `${method}: ${ours.length} ConfidentialAirdropCreated events from factory ${this.address} in tx ${hash}; ambiguous result`
-      );
-    }
-    return { hash: asTxHash(hash), airdrop: ours[0].args.airdrop };
-  }
-  #requireWallet(method) {
-    if (!this.walletClient) {
-      throw new MissingWalletClientError(method);
-    }
-    return this.walletClient;
-  }
-  #resolveAccount(wallet, override, method) {
-    const acct = override ?? wallet.account;
-    if (!acct) {
-      throw new MissingAccountError(method);
-    }
-    return acct;
-  }
-  /**
-   * Resolve the encrypted-amount payload for a fund-style write. Enforces
-   * **exactly one** of `amount` / `encryptedInput` so a caller who hands the
-   * SDK a pre-encrypted handle cannot also pass a stale plaintext that drifts
-   * from the on-chain ciphertext.
-   */
-  async #encryptAmount(amount, encryptor, preEncrypted, account, method) {
-    const hasAmount = amount !== void 0;
-    const hasInput = preEncrypted !== void 0;
-    if (hasAmount && hasInput) {
-      throw new InvalidArgumentError({
-        method,
-        argument: "amount/encryptedInput",
-        reason: "exactly one of `amount` (plaintext, SDK encrypts) or `encryptedInput` (pre-encrypted) must be supplied \u2014 got both"
-      });
-    }
-    if (!hasAmount && !hasInput) {
-      throw new InvalidArgumentError({
-        method,
-        argument: "amount/encryptedInput",
-        reason: "exactly one of `amount` (plaintext, SDK encrypts) or `encryptedInput` (pre-encrypted) must be supplied \u2014 got neither"
-      });
-    }
-    if (hasInput) return preEncrypted;
-    const enc = encryptor ?? resolveEncryptor(this.encryptor);
-    if (!enc) {
-      throw new MissingEncryptorError("encryptAmount", {
-        hint: "Pass `encryptor` to the call or the client config (eager or lazy factory)."
-      });
-    }
-    return encryptUint64({
-      encryptor: enc,
-      contractAddress: this.address,
-      userAddress: accountAddress(account),
-      value: amount
-    });
-  }
-  async #write(functionName, args, account) {
-    const wallet = this.#requireWallet(functionName);
-    const acct = this.#resolveAccount(wallet, account, functionName);
-    await this.#preflightWrite(functionName, functionName, args, acct);
-    try {
-      return await wallet.writeContract({
-        address: this.address,
-        abi: confidentialAirdropFactoryAbi,
-        functionName,
-        args,
-        account: acct,
-        chain: wallet.chain
-      });
-    } catch (err) {
-      throw this.#mapRevert(functionName, err, accountAddress(acct));
-    }
-  }
-  #mapRevert(method, err, account) {
-    return mapContractRevert(err, {
-      method,
-      contractAddress: this.address,
-      abi: confidentialAirdropFactoryAbi,
-      productMapper: airdropFactoryProductMapper,
-      account
-    });
-  }
-  /**
-   * Pre-flight a write via `simulateContract` purely to surface typed reverts.
-   *
-   * The simulate's *return value* is discarded — FHE writes still need
-   * `writeContract` + receipt parsing because simulated FHE op handles diverge
-   * from the executed-tx handles (CLAUDE.md Pitfall #1). The only purpose of
-   * this call is to let viem decode any revert against the ABI and produce a
-   * `ContractFunctionRevertedError` frame the revert-mapper can classify.
-   */
-  async #preflightWrite(method, functionName, args, account, value) {
-    try {
-      await this.publicClient.simulateContract({
-        address: this.address,
-        abi: confidentialAirdropFactoryAbi,
-        functionName,
-        args,
-        account,
-        ...value !== void 0 ? { value } : {}
-      });
-    } catch (err) {
-      if (isContractRevert(err)) {
-        throw this.#mapRevert(method, err, accountAddress(account));
-      }
-    }
-  }
-  async #read(functionName, args = []) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: confidentialAirdropFactoryAbi,
-      functionName,
-      args
-    });
-    return result;
-  }
-};
-function createConfidentialAirdropFactoryClient(config) {
-  return new ConfidentialAirdropFactoryClient(config);
-}
-function isNotErc7984Failure(err) {
-  if (isContractRevert(err)) return true;
-  if (!(err instanceof BaseError)) return false;
-  return err.walk((e) => e instanceof ContractFunctionZeroDataError) instanceof ContractFunctionZeroDataError;
-}
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-function accountAddress(account) {
-  return typeof account === "string" ? account : account.address;
-}
-function toAbiParams(params) {
-  return {
-    token: params.token,
-    startTime: params.startTimestamp,
-    endTime: params.endTimestamp,
-    canExtendClaimWindow: params.canExtendClaimWindow,
-    admin: params.admin
-  };
-}
-
-export { ConfidentialAirdropFactoryClient, confidentialAirdropFactoryAbi, createConfidentialAirdropFactoryClient, encryptUint64, encryptUint64Batch, resolveEncryptor, signClaimAuthorization };