@tokenops/sdk 1.0.0

package/dist/chunk-UOG4PJL5.js

@@ -0,0 +1,1488 @@
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-JFLEEXKP.js';
+import { getFheAirdropFactoryAddress } from './chunk-COPFW5Z4.js';
+import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { withTelemetry } from './chunk-Q2GP5UDC.js';
+import { asExternalInputProof, asEncryptedHandle, asSignature, asTxHash } from './chunk-KWFFIJYX.js';
+import { InvalidArgumentError, TokenOpsSdkError, MissingAccountError, DeploymentAddressUnavailableError, MissingWalletClientError, MissingEncryptorError } from './chunk-IVE3QEGD.js';
+import { bytesToHex, parseEventLogs } 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.** R02 ADR P-1 collapses the
+   * old hash-only + `…AndGetAddress` pair down to one rich-return method —
+   * 90 %+ of consumers want the deployed address back, and the SDK already
+   * waits + 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)`.
+   *
+   * Symmetric with {@link ConfidentialAirdropFactoryClient.createConfidentialAirdrop}
+   * — both return `{ hash, airdrop }` parsed from the
+   * `ConfidentialAirdropCreated` event (R02 ADR P-1).
+   *
+   * @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)`
+   *
+   * @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.
+   *
+   * 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`).
+   *
+   * Shipped proactively in R17 for parity with `fhe-vesting`'s
+   * `managerImplementation()` alias (commit 6f6d7bc, closing
+   * backend-integrator-r14 minor). 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]);
+  }
+  // ----------------------- 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 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 };