@tokenops/sdk 1.0.0

package/dist/chunk-7VELUOMI.js

@@ -0,0 +1,35 @@
+// src/fhe/erc7984-abi.ts
+var erc7984OperatorAbi = [
+  {
+    inputs: [
+      { internalType: "address", name: "holder", type: "address" },
+      { internalType: "address", name: "spender", type: "address" }
+    ],
+    name: "isOperator",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "uint48", name: "until", type: "uint48" }
+    ],
+    name: "setOperator",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "holder", type: "address" },
+      { indexed: true, internalType: "address", name: "operator", type: "address" },
+      { indexed: false, internalType: "uint48", name: "until", type: "uint48" }
+    ],
+    name: "OperatorSet",
+    type: "event"
+  }
+];
+
+export { erc7984OperatorAbi };

package/dist/chunk-BE2AIZ3K.js

@@ -0,0 +1,23 @@
+import { TokenOpsValidationError } from './chunk-IVE3QEGD.js';
+import { isAddress, getAddress } from 'viem';
+
+function normaliseAddress(input) {
+  if (typeof input !== "string") {
+    throw new TokenOpsValidationError("normaliseAddress: input is not a string", {
+      method: "normaliseAddress",
+      args: { input: typeof input }
+    });
+  }
+  if (!isAddress(input, { strict: false })) {
+    throw new TokenOpsValidationError(
+      `normaliseAddress: '${input}' is not a valid 0x-prefixed 20-byte hex address`,
+      {
+        method: "normaliseAddress",
+        args: { input }
+      }
+    );
+  }
+  return getAddress(input);
+}
+
+export { normaliseAddress };

package/dist/chunk-CMRETRZO.js

@@ -0,0 +1,46 @@
+import { ConfidentialVestingFactoryClient, confidentialVestingFactoryAbi } from './chunk-72YGZEQE.js';
+
+// src/fhe-vesting/advanced/factory-advanced.ts
+var ConfidentialVestingFactoryAdvancedClient = class extends ConfidentialVestingFactoryClient {
+  /**
+   * Compute the deterministic CREATE2 clone address as the factory would have
+   * computed it at `args.blockNumber`.
+   *
+   * **Block-dependent.** See class TSDoc — predict at block N, mine at N+1,
+   * the addresses differ.
+   *
+   * For the common "deploy a clone and learn its address" flow, prefer the
+   * headline `factory.createManager`, which parses the address from the tx
+   * receipt's `ManagerCreated` event.
+   */
+  async predictManagerAddress(args) {
+    const hasOptions = args.splitEnabled !== void 0 || args.pausableEnabled !== void 0;
+    if (hasOptions) {
+      return this.publicClient.readContract({
+        address: this.address,
+        abi: confidentialVestingFactoryAbi,
+        functionName: "predictManagerAddressWithOptions",
+        args: [
+          args.token,
+          args.userSalt,
+          args.deployer,
+          args.splitEnabled ?? true,
+          args.pausableEnabled ?? true
+        ],
+        blockNumber: args.blockNumber
+      });
+    }
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: confidentialVestingFactoryAbi,
+      functionName: "predictManagerAddress",
+      args: [args.token, args.userSalt, args.deployer],
+      blockNumber: args.blockNumber
+    });
+  }
+};
+function createConfidentialVestingFactoryAdvancedClient(config) {
+  return new ConfidentialVestingFactoryAdvancedClient(config);
+}
+
+export { ConfidentialVestingFactoryAdvancedClient, createConfidentialVestingFactoryAdvancedClient };

package/dist/chunk-COPFW5Z4.js

@@ -0,0 +1,82 @@
+import { DeploymentAddressUnavailableError } from './chunk-IVE3QEGD.js';
+import { sepolia, mainnet } from 'viem/chains';
+
+var DEPLOYED_ADDRESSES = {
+  fheVesting: {
+    confidentialVestingFactory: {
+      [sepolia.id]: "0xA87701CE9A52D43681600583a99c85b50DbE3150"
+      // mainnet omitted — not deployed.
+    }
+  },
+  fheAirdrop: {
+    confidentialAirdropFactory: {
+      [sepolia.id]: "0xbE6A3B78B36684fFee48De77d47Bc3393F5Acd4c"
+      // mainnet omitted — not deployed.
+    }
+  },
+  fheDisperse: {
+    disperseConfidentialSingleton: {
+      [mainnet.id]: "0x4fC0d28cBe4B82D512Ad0B42F6787480Cc98cC70",
+      [sepolia.id]: "0x710dD9885Cc9986EfD234E7719483147a6d8DBb4"
+    }
+  }
+};
+function getDeployedAddress(product, contract, chainId) {
+  const productEntry = DEPLOYED_ADDRESSES[product];
+  const contractEntry = productEntry[contract];
+  return contractEntry?.[chainId] ?? void 0;
+}
+function requireDeployedAddress(product, contract, chainId) {
+  const productEntry = DEPLOYED_ADDRESSES[product];
+  const contractEntry = productEntry[contract];
+  const entry = contractEntry?.[chainId];
+  if (entry) return entry;
+  throw new DeploymentAddressUnavailableError({
+    reason: entry === null ? "registry-not-deployed" : "registry-unknown-chain",
+    product: String(product),
+    contract: String(contract),
+    chainId
+  });
+}
+function getFheVestingFactoryAddress(chainId) {
+  return getDeployedAddress("fheVesting", "confidentialVestingFactory", chainId);
+}
+function requireFheVestingFactoryAddress(chainId) {
+  return requireDeployedAddress("fheVesting", "confidentialVestingFactory", chainId);
+}
+function getFheAirdropFactoryAddress(chainId) {
+  return getDeployedAddress("fheAirdrop", "confidentialAirdropFactory", chainId);
+}
+function requireFheAirdropFactoryAddress(chainId) {
+  return requireDeployedAddress("fheAirdrop", "confidentialAirdropFactory", chainId);
+}
+function getFheDisperseSingletonAddress(chainId) {
+  return getDeployedAddress("fheDisperse", "disperseConfidentialSingleton", chainId);
+}
+function requireFheDisperseSingletonAddress(chainId) {
+  return requireDeployedAddress("fheDisperse", "disperseConfidentialSingleton", chainId);
+}
+function chainsWithKnownRegistryEntry(product) {
+  const productEntry = DEPLOYED_ADDRESSES[product];
+  const ids = /* @__PURE__ */ new Set();
+  for (const contractEntry of Object.values(productEntry)) {
+    for (const key of Object.keys(contractEntry)) {
+      ids.add(Number(key));
+    }
+  }
+  return [...ids].sort((a, b) => a - b);
+}
+function chainsWithDeployment(product) {
+  const productEntry = DEPLOYED_ADDRESSES[product];
+  const contracts = Object.values(productEntry);
+  if (contracts.length === 0) return [];
+  const candidates = new Set(Object.keys(contracts[0]).map(Number));
+  return [...candidates].filter(
+    (chainId) => contracts.every((entry) => {
+      const value = entry[chainId];
+      return value !== null && value !== void 0;
+    })
+  ).sort((a, b) => a - b);
+}
+
+export { DEPLOYED_ADDRESSES, chainsWithDeployment, chainsWithKnownRegistryEntry, getDeployedAddress, getFheAirdropFactoryAddress, getFheDisperseSingletonAddress, getFheVestingFactoryAddress, requireFheAirdropFactoryAddress, requireFheDisperseSingletonAddress, requireFheVestingFactoryAddress };

package/dist/chunk-CQIPRNS7.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var chunk56UI7LUR_cjs = require('./chunk-56UI7LUR.cjs');
+var viem = require('viem');
+
+function normaliseAddress(input) {
+  if (typeof input !== "string") {
+    throw new chunk56UI7LUR_cjs.TokenOpsValidationError("normaliseAddress: input is not a string", {
+      method: "normaliseAddress",
+      args: { input: typeof input }
+    });
+  }
+  if (!viem.isAddress(input, { strict: false })) {
+    throw new chunk56UI7LUR_cjs.TokenOpsValidationError(
+      `normaliseAddress: '${input}' is not a valid 0x-prefixed 20-byte hex address`,
+      {
+        method: "normaliseAddress",
+        args: { input }
+      }
+    );
+  }
+  return viem.getAddress(input);
+}
+
+exports.normaliseAddress = normaliseAddress;

package/dist/chunk-ECT3NL2L.js

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

package/dist/chunk-FWHYQZ5E.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+// src/fhe/erc7984-abi.ts
+var erc7984OperatorAbi = [
+  {
+    inputs: [
+      { internalType: "address", name: "holder", type: "address" },
+      { internalType: "address", name: "spender", type: "address" }
+    ],
+    name: "isOperator",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "uint48", name: "until", type: "uint48" }
+    ],
+    name: "setOperator",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "holder", type: "address" },
+      { indexed: true, internalType: "address", name: "operator", type: "address" },
+      { indexed: false, internalType: "uint48", name: "until", type: "uint48" }
+    ],
+    name: "OperatorSet",
+    type: "event"
+  }
+];
+
+exports.erc7984OperatorAbi = erc7984OperatorAbi;

package/dist/chunk-FYQ2UW4T.js

@@ -0,0 +1,37 @@
+import { DeploymentAddressUnavailableError } from './chunk-IVE3QEGD.js';
+import { parseAbiItem } from 'viem';
+
+var FHEVM_ACL_ADDRESS_BY_CHAIN = {
+  31337: "0x50157CFfD6bBFA2DECe204a89ec419c23ef5755D",
+  11155111: "0xf0Ffdc93b7E186bC2f8CB3dAA75D86d1930A433D",
+  1: "0xcA2E8f1F656CD25C01F05d0b243Ab1ecd4a8ffb6"
+};
+var ACL_ALLOWED_EVENT = parseAbiItem(
+  "event Allowed(address indexed caller, address indexed account, bytes32 handle)"
+);
+function getFhevmAclAddress(chainId) {
+  return FHEVM_ACL_ADDRESS_BY_CHAIN[chainId];
+}
+function requireFhevmAclAddress(chainId, clientLabel) {
+  if (chainId === void 0) {
+    throw new DeploymentAddressUnavailableError({
+      reason: "chain-id-missing",
+      product: "fhevm",
+      contract: "acl",
+      clientLabel,
+      overrideName: "aclAddress"
+    });
+  }
+  const addr = FHEVM_ACL_ADDRESS_BY_CHAIN[chainId];
+  if (addr) return addr;
+  throw new DeploymentAddressUnavailableError({
+    reason: "registry-unknown-chain",
+    product: "fhevm",
+    contract: "acl",
+    chainId,
+    clientLabel,
+    overrideName: "aclAddress"
+  });
+}
+
+export { ACL_ALLOWED_EVENT, FHEVM_ACL_ADDRESS_BY_CHAIN, getFhevmAclAddress, requireFhevmAclAddress };

package/dist/chunk-HGXNRR25.js

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