@tokenops/sdk 1.0.0

package/dist/chunk-52TC6BF7.js

@@ -0,0 +1,2755 @@
+import { mapZamaError } from './chunk-ZXCOJY2Z.js';
+import { scaleRatio } from './chunk-XSNLAS5M.js';
+import { getFhevmAclAddress, requireFhevmAclAddress, ACL_ALLOWED_EVENT } from './chunk-FYQ2UW4T.js';
+import { SDK_VERSION, mapContractRevert, isContractRevert } from './chunk-JFLEEXKP.js';
+import { normaliseAddress } from './chunk-BE2AIZ3K.js';
+import { withTelemetry } from './chunk-Q2GP5UDC.js';
+import { asExternalInputProof, asEncryptedHandle, asTxHash } from './chunk-KWFFIJYX.js';
+import { InvalidArgumentError, TokenOpsSdkError, PausedError, InsufficientFeeError, MissingEncryptorError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError } from './chunk-IVE3QEGD.js';
+import { bytesToHex, parseEventLogs, isAddress } from 'viem';
+
+// src/fhe-vesting/abis/manager.ts
+var confidentialVestingManagerAbi = [
+  {
+    inputs: [{ internalType: "address", name: "_extension", 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: "ArrayLengthMismatch", type: "error" },
+  { inputs: [], name: "BatchTooLarge", type: "error" },
+  { inputs: [], name: "CannotTransferToSelf", type: "error" },
+  { inputs: [], name: "CannotTransferToZero", type: "error" },
+  { inputs: [], name: "ClaimLocked", type: "error" },
+  { inputs: [], name: "CliffExceedsDuration", type: "error" },
+  { inputs: [], name: "EmptyBatch", type: "error" },
+  { inputs: [], name: "EnforcedPause", type: "error" },
+  { inputs: [], name: "ExpectedPause", type: "error" },
+  { inputs: [], name: "HandleNotAllowed", type: "error" },
+  { inputs: [], name: "InsufficientGasFee", type: "error" },
+  { inputs: [], name: "InvalidAdmin", type: "error" },
+  { inputs: [], name: "InvalidBps", type: "error" },
+  { inputs: [], name: "InvalidFeeCollector", type: "error" },
+  { inputs: [], name: "InvalidInitialization", type: "error" },
+  { inputs: [], name: "InvalidMaxBatchSize", type: "error" },
+  { inputs: [], name: "InvalidParty", type: "error" },
+  { inputs: [], name: "InvalidRecipient", type: "error" },
+  { inputs: [], name: "InvalidSplitDenominator", type: "error" },
+  { inputs: [], name: "InvalidTimestamps", type: "error" },
+  { inputs: [], name: "InvalidTransferDuration", type: "error" },
+  { inputs: [], name: "NoPendingTransfer", type: "error" },
+  { inputs: [], name: "NotInitializing", type: "error" },
+  { inputs: [], name: "NotPendingRecipient", type: "error" },
+  { inputs: [], name: "NotRecipient", type: "error" },
+  { inputs: [], name: "PausableDisabled", type: "error" },
+  { inputs: [], name: "RecipientIndexMismatch", type: "error" },
+  { inputs: [], name: "RedundantRoleTransfer", type: "error" },
+  { inputs: [], name: "ReentrancyGuardReentrantCall", type: "error" },
+  { inputs: [], name: "SameToken", 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: "SplitDisabled", type: "error" },
+  { inputs: [], name: "TimelockOverflow", type: "error" },
+  { inputs: [], name: "TransferAlreadyPending", type: "error" },
+  { inputs: [], name: "TransferExpired", type: "error" },
+  { inputs: [], name: "TransferFailed", type: "error" },
+  { inputs: [], name: "UnexpectedETH", type: "error" },
+  { inputs: [], name: "VestingAlreadyRevoked", type: "error" },
+  { inputs: [], name: "VestingEnded", type: "error" },
+  { inputs: [], name: "VestingIdsNotStrictlyAsc", type: "error" },
+  { inputs: [], name: "VestingNotFound", type: "error" },
+  { inputs: [], name: "VestingNotRevocable", type: "error" },
+  { inputs: [], name: "ZamaProtocolUnsupported", type: "error" },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "euint64", name: "amount", type: "bytes32" }
+    ],
+    name: "AdminWithdrawal",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "discloser", type: "address" },
+      { indexed: true, internalType: "address", name: "party", type: "address" },
+      {
+        indexed: false,
+        internalType: "enum IConfidentialVestingManagerTypes.DisclosureType",
+        name: "disclosureType",
+        type: "uint8"
+      },
+      { indexed: false, internalType: "euint128", name: "encryptedAmount", type: "bytes32" }
+    ],
+    name: "AmountDisclosed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "GasFeeWithdrawal",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "discloser", type: "address" },
+      { indexed: true, internalType: "address", name: "party", type: "address" },
+      { indexed: false, internalType: "euint128", name: "encryptedAmount", type: "bytes32" }
+    ],
+    name: "HandleDisclosedToParty",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "uint64", name: "version", type: "uint64" }],
+    name: "Initialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: false, internalType: "uint256", name: "oldMax", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "newMax", type: "uint256" }
+    ],
+    name: "MaxBatchSizeUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: false, internalType: "uint256", name: "oldMax", type: "uint256" },
+      { indexed: false, internalType: "uint256", name: "newMax", type: "uint256" }
+    ],
+    name: "MaxRevokeBatchSizeUpdated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "token", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "euint64", name: "amount", type: "bytes32" }
+    ],
+    name: "OtherConfidentialTokenWithdrawal",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "token", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      { indexed: false, internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "OtherTokenWithdrawal",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "address", name: "account", type: "address" }],
+    name: "Paused",
+    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: "to", type: "address" },
+      { indexed: false, internalType: "euint64", name: "amount", type: "bytes32" }
+    ],
+    name: "TokenFeeWithdrawal",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "recipient", type: "address" },
+      { indexed: false, internalType: "euint64", name: "amount", type: "bytes32" }
+    ],
+    name: "TokensClaimed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: false, internalType: "address", name: "account", type: "address" }],
+    name: "Unpaused",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "recipient", type: "address" },
+      { indexed: false, internalType: "uint32", name: "startTimestamp", type: "uint32" },
+      { indexed: false, internalType: "uint32", name: "endTimestamp", type: "uint32" },
+      { indexed: false, internalType: "uint32", name: "cliffReleaseTimestamp", type: "uint32" },
+      { indexed: false, internalType: "euint128", name: "encryptedAmount", type: "bytes32" }
+    ],
+    name: "VestingCreated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "address", name: "admin", type: "address" },
+      { indexed: true, internalType: "address", name: "feeCollector", type: "address" },
+      { indexed: false, internalType: "uint256", name: "blockNumber", type: "uint256" }
+    ],
+    name: "VestingManagerInitialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: false, internalType: "uint32", name: "revokeTimestamp", type: "uint32" }
+    ],
+    name: "VestingRevoked",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "originalVestingId", type: "bytes32" },
+      { indexed: true, internalType: "bytes32", name: "newVestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "newRecipient", type: "address" },
+      { indexed: false, internalType: "euint128", name: "origAllocation", type: "bytes32" },
+      { indexed: false, internalType: "euint128", name: "newAllocation", type: "bytes32" }
+    ],
+    name: "VestingSplit",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "oldRecipient", type: "address" },
+      { indexed: true, internalType: "address", name: "newRecipient", type: "address" }
+    ],
+    name: "VestingTransferAccepted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [{ indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "VestingTransferCancelled",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      { indexed: true, internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { indexed: true, internalType: "address", name: "from", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" }
+    ],
+    name: "VestingTransferInitiated",
+    type: "event"
+  },
+  { stateMutability: "payable", type: "fallback" },
+  {
+    inputs: [],
+    name: "CLAIMER_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "DEFAULT_ADMIN_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "DEPLOYMENT_BLOCK_NUMBER",
+    outputs: [{ internalType: "uint256", name: "blockNumber", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "DISCLOSURE_ADMIN_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE",
+    outputs: [{ internalType: "uint256", name: "fee", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_COLLECTOR_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "FEE_TYPE",
+    outputs: [{ internalType: "uint8", name: "feeType", type: "uint8" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "PAUSER_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "REVOKER_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "TOKEN_ADDRESS",
+    outputs: [{ internalType: "address", name: "token", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "VESTING_CREATOR_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "WITHDRAWER_ROLE",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "adminClaim",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "externalEuint64", name: "encryptedAmount", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "adminPartialClaim",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "recipient", type: "address" },
+          { internalType: "uint32", name: "startTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "endTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "cliffSeconds", type: "uint32" },
+          { internalType: "uint32", name: "releaseIntervalSecs", type: "uint32" },
+          { internalType: "uint32", name: "timelockSeconds", type: "uint32" },
+          { internalType: "uint16", name: "initialUnlockBps", type: "uint16" },
+          { internalType: "uint16", name: "cliffAmountBps", type: "uint16" },
+          { internalType: "bool", name: "isRevocable", type: "bool" }
+        ],
+        internalType: "struct IConfidentialVestingManagerTypes.VestingParams[]",
+        name: "params",
+        type: "tuple[]"
+      },
+      { internalType: "externalEuint64[]", name: "encryptedAmounts", type: "bytes32[]" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "batchCreateVesting",
+    outputs: [{ internalType: "bytes32[]", name: "vestingIds", type: "bytes32[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "claim",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: "address", name: "recipient", type: "address" },
+          { internalType: "uint32", name: "startTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "endTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "cliffSeconds", type: "uint32" },
+          { internalType: "uint32", name: "releaseIntervalSecs", type: "uint32" },
+          { internalType: "uint32", name: "timelockSeconds", type: "uint32" },
+          { internalType: "uint16", name: "initialUnlockBps", type: "uint16" },
+          { internalType: "uint16", name: "cliffAmountBps", type: "uint16" },
+          { internalType: "bool", name: "isRevocable", type: "bool" }
+        ],
+        internalType: "struct IConfidentialVestingManagerTypes.VestingParams",
+        name: "params",
+        type: "tuple"
+      },
+      { internalType: "externalEuint64", name: "encryptedAmount", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "createVesting",
+    outputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "extensionAddress",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    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: "uint256", name: "index", type: "uint256" }
+    ],
+    name: "getRoleMember",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "role", type: "bytes32" }],
+    name: "getRoleMemberCount",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "role", type: "bytes32" }],
+    name: "getRoleMembers",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    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: [
+      { internalType: "address", name: "admin", type: "address" },
+      { internalType: "address", name: "feeCollector", type: "address" }
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "externalEuint64", name: "encryptedAmount", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "partialClaim",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    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: "bytes4", name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  { stateMutability: "payable", type: "receive" },
+  {
+    inputs: [{ internalType: "address", name: "token", type: "address" }],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "acceptVestingTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "vestingIds", type: "bytes32[]" },
+      {
+        internalType: "enum IConfidentialVestingManagerTypes.DisclosureType[]",
+        name: "disclosureTypes",
+        type: "uint8[]"
+      },
+      { internalType: "address", name: "party", type: "address" }
+    ],
+    name: "adminBatchDiscloseToParty",
+    outputs: [{ internalType: "euint128[]", name: "", type: "bytes32[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "address", name: "party", type: "address" },
+      {
+        internalType: "enum IConfidentialVestingManagerTypes.DisclosureType",
+        name: "disclosureType",
+        type: "uint8"
+      }
+    ],
+    name: "adminDiscloseToParty",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "adminGetClaimableAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "adminGetSettledAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "adminGetTokenBalance",
+    outputs: [{ internalType: "euint64", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "adminGetTotalAllocation",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "uint48", name: "timestamp", type: "uint48" }
+    ],
+    name: "adminGetVestedAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "euint128[]", name: "handles", type: "bytes32[]" },
+      { internalType: "address", name: "party", type: "address" }
+    ],
+    name: "batchDiscloseHandlesToParty",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "vestingIds", type: "bytes32[]" },
+      {
+        internalType: "enum IConfidentialVestingManagerTypes.DisclosureType[]",
+        name: "disclosureTypes",
+        type: "uint8[]"
+      },
+      { internalType: "address", name: "party", type: "address" }
+    ],
+    name: "batchDiscloseToParty",
+    outputs: [{ internalType: "euint128[]", name: "", type: "bytes32[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32[]", name: "vestingIds", type: "bytes32[]" }],
+    name: "batchRevokeVesting",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "cancelVestingTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "address", name: "newOwner", type: "address" }
+    ],
+    name: "directVestingTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "euint128", name: "handle", type: "bytes32" },
+      { internalType: "address", name: "party", type: "address" }
+    ],
+    name: "discloseHandleToParty",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "address", name: "party", type: "address" },
+      {
+        internalType: "enum IConfidentialVestingManagerTypes.DisclosureType",
+        name: "disclosureType",
+        type: "uint8"
+      }
+    ],
+    name: "discloseToParty",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "recipient", type: "address" }],
+    name: "getAllRecipientVestings",
+    outputs: [{ internalType: "bytes32[]", name: "", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "recipient", type: "address" }],
+    name: "getAllRecipientVestingsLength",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "recipient", type: "address" },
+      { internalType: "uint256", name: "start", type: "uint256" },
+      { internalType: "uint256", name: "end", type: "uint256" }
+    ],
+    name: "getAllRecipientVestingsSliced",
+    outputs: [{ internalType: "bytes32[]", name: "", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getAllRecipients",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "getAllRecipientsLength",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "uint256", name: "start", type: "uint256" },
+      { internalType: "uint256", name: "end", type: "uint256" }
+    ],
+    name: "getAllRecipientsSliced",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "getClaimableAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "getPendingVestingTransfer",
+    outputs: [
+      { internalType: "address", name: "newRecipient", type: "address" },
+      { internalType: "uint48", name: "initiatedAt", type: "uint48" },
+      { internalType: "uint48", name: "expiresAt", type: "uint48" }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "getSettledAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "getTotalAllocation",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "uint48", name: "timestamp", type: "uint48" }
+    ],
+    name: "getVestedAmount",
+    outputs: [{ internalType: "euint128", name: "", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "getVestingInfo",
+    outputs: [
+      {
+        components: [
+          { internalType: "address", name: "recipient", type: "address" },
+          { internalType: "uint32", name: "startTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "endTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "revokeTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "cliffReleaseTimestamp", type: "uint32" },
+          { internalType: "uint32", name: "releaseIntervalSecs", type: "uint32" },
+          { internalType: "uint32", name: "timelock", type: "uint32" },
+          { internalType: "uint16", name: "initialUnlockBps", type: "uint16" },
+          { internalType: "uint16", name: "cliffAmountBps", type: "uint16" },
+          { internalType: "bool", name: "isRevocable", type: "bool" }
+        ],
+        internalType: "struct IConfidentialVestingManagerTypes.VestingInfo",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "address", name: "newRecipient", type: "address" },
+      { internalType: "uint48", name: "transferDurationSeconds", type: "uint48" }
+    ],
+    name: "initiateVestingTransfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "isPausable",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "account", type: "address" }],
+    name: "isRecipient",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "isSplitEnabled",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxBatchSize",
+    outputs: [{ internalType: "uint64", name: "", type: "uint64" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxRevokeBatchSize",
+    outputs: [{ internalType: "uint64", name: "", type: "uint64" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  { inputs: [], name: "pause", outputs: [], stateMutability: "nonpayable", type: "function" },
+  {
+    inputs: [{ internalType: "bytes32", name: "vestingId", type: "bytes32" }],
+    name: "revokeVesting",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint64", name: "newMax", type: "uint64" }],
+    name: "setMaxBatchSize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint64", name: "newMax", type: "uint64" }],
+    name: "setMaxRevokeBatchSize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "vestingId", type: "bytes32" },
+      { internalType: "externalEuint64", name: "encryptedNumerator", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" },
+      { internalType: "uint128", name: "denominator", type: "uint128" },
+      { internalType: "address", name: "newRecipient", type: "address" }
+    ],
+    name: "splitVesting",
+    outputs: [{ internalType: "bytes32", name: "newVestingId", type: "bytes32" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newCollector", type: "address" }],
+    name: "transferFeeCollectorRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  { inputs: [], name: "unpause", outputs: [], stateMutability: "nonpayable", type: "function" },
+  {
+    inputs: [
+      { internalType: "externalEuint64", name: "encryptedAmount", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "withdrawAdmin",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "withdrawGasFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "token", type: "address" },
+      { internalType: "address", name: "to", type: "address" }
+    ],
+    name: "withdrawOtherConfidentialToken",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "token", type: "address" },
+      { internalType: "address", name: "to", type: "address" }
+    ],
+    name: "withdrawOtherToken",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "externalEuint64", name: "encryptedAmount", type: "bytes32" },
+      { internalType: "bytes", name: "inputProof", type: "bytes" }
+    ],
+    name: "withdrawTokenFee",
+    outputs: [],
+    stateMutability: "nonpayable",
+    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: `does not fit in uint64 (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))
+  };
+}
+
+// src/fhe-vesting/errors.ts
+var VestingNotFoundError = class extends TokenOpsSdkError {
+  name = "VestingNotFoundError";
+  constructor(args) {
+    super(`${args.method}: no vesting schedule found for ${args.vestingId}.`, {
+      code: "TOKENOPS_VESTING_NOT_FOUND",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId
+      }
+    });
+  }
+};
+var NotVestingRecipientError = class extends TokenOpsSdkError {
+  name = "NotVestingRecipientError";
+  constructor(args) {
+    super(`${args.method}: caller is not the recipient of vesting ${args.vestingId}.`, {
+      code: "TOKENOPS_NOT_RECIPIENT",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        caller: args.caller,
+        expectedRecipient: args.expectedRecipient
+      }
+    });
+  }
+};
+var ClaimLockedError = class extends TokenOpsSdkError {
+  name = "ClaimLockedError";
+  constructor(args) {
+    const detail = args.unlocksAt !== void 0 ? ` Unlocks at unix timestamp ${args.unlocksAt}.` : "";
+    super(`${args.method}: vesting ${args.vestingId} is timelocked.${detail}`, {
+      code: "TOKENOPS_CLAIM_LOCKED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        unlocksAt: args.unlocksAt
+      }
+    });
+  }
+};
+var VestingRevokedError = class extends TokenOpsSdkError {
+  name = "VestingRevokedError";
+  constructor(args) {
+    const detail = args.revokedAt !== void 0 ? ` at unix timestamp ${args.revokedAt}` : "";
+    super(`${args.method}: vesting ${args.vestingId} has already been revoked${detail}.`, {
+      code: "TOKENOPS_VESTING_REVOKED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        revokedAt: args.revokedAt
+      }
+    });
+  }
+};
+var VestingNotRevocableError = class extends TokenOpsSdkError {
+  name = "VestingNotRevocableError";
+  constructor(args) {
+    super(`${args.method}: vesting ${args.vestingId} was created as non-revocable.`, {
+      code: "TOKENOPS_NOT_REVOCABLE",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId
+      }
+    });
+  }
+};
+var VestingExpiredError = class extends TokenOpsSdkError {
+  name = "VestingExpiredError";
+  constructor(args) {
+    super(`${args.method}: vesting ${args.vestingId} has already ended.`, {
+      code: "TOKENOPS_VESTING_EXPIRED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        endedAt: args.endedAt
+      }
+    });
+  }
+};
+var TransferAlreadyPendingError = class extends TokenOpsSdkError {
+  name = "TransferAlreadyPendingError";
+  constructor(args) {
+    super(`${args.method}: a transfer is already pending for vesting ${args.vestingId}.`, {
+      code: "TOKENOPS_TRANSFER_ALREADY_PENDING",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        pendingRecipient: args.pendingRecipient,
+        expiresAt: args.expiresAt
+      }
+    });
+  }
+};
+var NoPendingTransferError = class extends TokenOpsSdkError {
+  name = "NoPendingTransferError";
+  constructor(args) {
+    super(`${args.method}: no pending transfer for vesting ${args.vestingId}.`, {
+      code: "TOKENOPS_NO_PENDING_TRANSFER",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId
+      }
+    });
+  }
+};
+var NotPendingRecipientError = class extends TokenOpsSdkError {
+  name = "NotPendingRecipientError";
+  constructor(args) {
+    super(`${args.method}: caller is not the pending recipient of vesting ${args.vestingId}.`, {
+      code: "TOKENOPS_NOT_PENDING_RECIPIENT",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        caller: args.caller,
+        expectedRecipient: args.expectedRecipient
+      }
+    });
+  }
+};
+var TransferExpiredError = class extends TokenOpsSdkError {
+  name = "TransferExpiredError";
+  constructor(args) {
+    super(`${args.method}: pending transfer for vesting ${args.vestingId} has expired.`, {
+      code: "TOKENOPS_TRANSFER_EXPIRED",
+      cause: args.cause,
+      context: {
+        method: args.method,
+        contractAddress: args.contractAddress,
+        vestingId: args.vestingId,
+        expiredAt: args.expiredAt
+      }
+    });
+  }
+};
+var vestingProductMapper = (name, _args, ctx) => {
+  const vestingId = ctx.productContext?.["vestingId"] ?? "0x";
+  switch (name) {
+    case "VestingNotFound":
+      return new VestingNotFoundError({ ...ctx, vestingId });
+    case "NotRecipient":
+      return new NotVestingRecipientError({ ...ctx, vestingId });
+    case "ClaimLocked":
+      return new ClaimLockedError({ ...ctx, vestingId });
+    case "VestingAlreadyRevoked":
+      return new VestingRevokedError({ ...ctx, vestingId });
+    case "VestingNotRevocable":
+      return new VestingNotRevocableError({ ...ctx, vestingId });
+    case "VestingEnded":
+      return new VestingExpiredError({ ...ctx, vestingId });
+    case "TransferAlreadyPending":
+      return new TransferAlreadyPendingError({ ...ctx, vestingId });
+    case "NoPendingTransfer":
+      return new NoPendingTransferError({ ...ctx, vestingId });
+    case "NotPendingRecipient":
+      return new NotPendingRecipientError({ ...ctx, vestingId });
+    case "TransferExpired":
+      return new TransferExpiredError({ ...ctx, vestingId });
+    default:
+      return void 0;
+  }
+};
+var ConfidentialVestingManagerClient = class {
+  publicClient;
+  walletClient;
+  address;
+  encryptor;
+  #aclAddressOverride;
+  #telemetry;
+  #cachedAclAddress;
+  constructor(config) {
+    this.publicClient = config.publicClient;
+    this.walletClient = config.walletClient;
+    this.address = normaliseAddress(config.address);
+    this.encryptor = config.encryptor;
+    this.#telemetry = config.telemetry;
+    this.#aclAddressOverride = config.aclAddress;
+    const chainIdForInit = config.publicClient.chain?.id;
+    this.#telemetry?.event("fhe-vesting.client.init", {
+      surface: "manager",
+      chainId: chainIdForInit ?? null,
+      hasWallet: !!this.walletClient,
+      aclResolved: !!config.aclAddress || chainIdForInit !== void 0 && !!getFhevmAclAddress(chainIdForInit),
+      sdkVersion: SDK_VERSION
+    });
+  }
+  /**
+   * The FHEVM ACL contract address used by encrypted-view methods to parse
+   * `ACL.Allowed` events. Resolved lazily on first access; throws
+   * `DeploymentAddressUnavailableError` if no override was passed and the
+   * SDK does not have an ACL deployed for the connected chain.
+   */
+  get aclAddress() {
+    if (this.#cachedAclAddress) return this.#cachedAclAddress;
+    this.#cachedAclAddress = this.#aclAddressOverride ?? requireFhevmAclAddress(this.publicClient.chain?.id, "ConfidentialVestingManagerClient");
+    return this.#cachedAclAddress;
+  }
+  // ============================================================
+  //                       IMMUTABLE READS
+  // ============================================================
+  /**
+   * Return the ERC-7984 token address this manager clone is bound to.
+   * @returns Checksummed token address.
+   */
+  async token() {
+    return this.#read("TOKEN_ADDRESS");
+  }
+  /**
+   * Return the fee model baked into this clone's immutable args.
+   * @returns `FeeType.Gas` (0) or `FeeType.DistributionToken` (1).
+   */
+  async feeType() {
+    const raw = await this.#read("FEE_TYPE");
+    return raw;
+  }
+  /**
+   * Return the raw fee value baked into this clone's immutable args.
+   * Interpretation depends on `feeType`: wei for `Gas`, basis points for `DistributionToken`.
+   * @returns Fee amount in the unit appropriate for `feeType`.
+   */
+  async fee() {
+    return this.#read("FEE");
+  }
+  /**
+   * Read the manager's fee configuration in one call.
+   *
+   * Both fields are immutable (baked into the clone's bytecode at deploy time), so
+   * consumers should memoize the result for the manager's lifetime.
+   *
+   * @returns `{ feeType, fee }` — feed both into the discriminated
+   *   {@link ClaimArgs} union to construct the correct claim shape.
+   * @example
+   * const { feeType, fee } = await manager.getFeeInfo();
+   * await manager.claim(
+   *   feeType === FeeType.Gas
+   *     ? { feeType, vestingId, value: fee }
+   *     : { feeType, vestingId },
+   * );
+   */
+  async getFeeInfo() {
+    const [feeType, fee] = await Promise.all([this.feeType(), this.fee()]);
+    return { feeType, fee };
+  }
+  /**
+   * Return the block number at which this clone was deployed.
+   * Used for event log scanning — start from this block to avoid scanning from genesis.
+   * @returns Block number as `bigint`.
+   */
+  async deploymentBlockNumber() {
+    return this.#read("DEPLOYMENT_BLOCK_NUMBER");
+  }
+  /**
+   * Return whether `splitVesting` is enabled on this clone.
+   * @returns `true` if the split feature is enabled.
+   */
+  async isSplitEnabled() {
+    return this.#read("isSplitEnabled");
+  }
+  /**
+   * Return whether this clone supports pause/unpause.
+   * @returns `true` if the clone is pausable.
+   */
+  async isPausable() {
+    return this.#read("isPausable");
+  }
+  /**
+   * Return the current pause state. Always `false` for non-pausable clones.
+   * @returns `true` if the manager is paused and claims are blocked.
+   */
+  async paused() {
+    return this.#read("paused");
+  }
+  /**
+   * Return the maximum number of vesting schedules allowed in a single `batchCreateVesting` call.
+   * @returns Batch size limit as `bigint`.
+   */
+  async maxBatchSize() {
+    return this.#read("maxBatchSize");
+  }
+  /**
+   * Return the maximum number of vesting ids allowed in a single `batchRevokeVesting` call.
+   * @returns Revoke batch size limit as `bigint`.
+   */
+  async maxRevokeBatchSize() {
+    return this.#read("maxRevokeBatchSize");
+  }
+  // ============================================================
+  //                       VESTING VIEWS
+  // ============================================================
+  /**
+   * Return metadata for a vesting schedule. Returns a zero-struct when `vestingId` does not exist.
+   * @param vestingId The `bytes32` vesting schedule ID from the `VestingCreated` event.
+   * @returns `VestingInfo` struct; `startTimestamp === 0` means the schedule does not exist.
+   * @example
+   * const info = await manager.getVestingInfo(vestingId);
+   * if (info.startTimestamp === 0) throw new Error("vesting not found");
+   */
+  async getVestingInfo(vestingId) {
+    const raw = await this.#read("getVestingInfo", [vestingId]);
+    return raw;
+  }
+  /**
+   * Return all recipient addresses that have at least one vesting schedule on this manager.
+   * @returns Array of checksummed addresses; may be large — use `getAllRecipientsSliced` for pagination.
+   */
+  async getAllRecipients() {
+    return this.#read("getAllRecipients");
+  }
+  /**
+   * Return the total number of unique recipients on this manager.
+   * @returns Count as `bigint`.
+   */
+  async getAllRecipientsLength() {
+    return this.#read("getAllRecipientsLength");
+  }
+  /**
+   * Slice of `getAllRecipients`, half-open `[start, end)`.
+   *
+   * Accepts `bigint | number` for `start` / `end` for ergonomics on read paths
+   * — CI scripts typically derive these from `Number(process.env.X)` and
+   * forcing bigint coercion at the call site is a pure paper cut. The
+   * underlying contract reads through unchanged (viem coerces). R22
+   * devops-integrator MINOR-4; R25 close.
+   */
+  async getAllRecipientsSliced(start, end) {
+    return this.#read("getAllRecipientsSliced", [BigInt(start), BigInt(end)]);
+  }
+  /**
+   * Return whether `account` has at least one vesting schedule on this manager.
+   * @param account Address to check.
+   * @returns `true` if the account is a known recipient.
+   */
+  async isRecipient(account) {
+    return this.#read("isRecipient", [account]);
+  }
+  /**
+   * Return all vesting schedule IDs for `recipient`.
+   * @param recipient Address of the vesting recipient.
+   * @returns Array of `bytes32` vesting IDs; may be large — use `getAllRecipientVestingsSliced` for pagination.
+   */
+  async getAllRecipientVestings(recipient) {
+    return this.#read("getAllRecipientVestings", [recipient]);
+  }
+  /**
+   * Return the number of vesting schedules for `recipient`.
+   * @param recipient Address of the vesting recipient.
+   * @returns Count as `bigint`.
+   */
+  async getAllRecipientVestingsLength(recipient) {
+    return this.#read("getAllRecipientVestingsLength", [recipient]);
+  }
+  /**
+   * Slice of `getAllRecipientVestings(recipient)`, half-open `[start, end)`.
+   * See {@link getAllRecipientsSliced} for the bigint-permissiveness rationale.
+   */
+  async getAllRecipientVestingsSliced(recipient, start, end) {
+    return this.#read("getAllRecipientVestingsSliced", [recipient, BigInt(start), BigInt(end)]);
+  }
+  /**
+   * Return the pending transfer details for a vesting schedule.
+   * @param vestingId The `bytes32` vesting schedule ID.
+   * @returns `{ newRecipient, initiatedAt, expiresAt }` — all zero if no transfer is pending.
+   */
+  async getPendingVestingTransfer(vestingId) {
+    const [newRecipient, initiatedAt, expiresAt] = await this.#read(
+      "getPendingVestingTransfer",
+      [vestingId]
+    );
+    return { newRecipient, initiatedAt, expiresAt };
+  }
+  // ============================================================
+  //                       PREFLIGHT
+  // ============================================================
+  /**
+   * Read-only preflight for {@link claim}. Runs the deterministic-from-off-chain
+   * checks in parallel and reports any blockers as typed {@link TokenOpsSdkError}s.
+   * Returns `{ ready: true, blockers: [] }` when the claim is safe to submit.
+   *
+   * Preflight is **opt-in**. Consumers who have already validated state can
+   * skip this call and invoke `claim` directly — they'll receive the same
+   * typed errors at write time via the revert mapper.
+   *
+   * Checks performed (all read-only, no gas):
+   * - Recipient match: `vestingInfo.recipient === caller`.
+   * - Schedule exists: `getVestingInfo` returns a non-zero startTimestamp.
+   * - Timelock elapsed: `block.timestamp ≥ startTimestamp + timelock`.
+   * - Manager is not paused (only when the clone has pause enabled).
+   * - ETH balance covers the gas fee (only when `feeType === FeeType.Gas`).
+   *
+   * Stochastic failures (FHE handle invalidation between read and write, ACL
+   * race conditions) cannot be detected off-chain and still surface as
+   * typed errors via the revert mapper.
+   *
+   * @returns `{ ready, blockers }` — same `code` shape as the write would throw.
+   */
+  async preflightClaim(args) {
+    const blockers = [];
+    const [info, isPausable, currentBlock, feeInfo, callerBalance] = await Promise.all([
+      this.getVestingInfo(args.vestingId),
+      this.isPausable(),
+      this.publicClient.getBlock(),
+      this.getFeeInfo(),
+      this.publicClient.getBalance({ address: args.caller })
+    ]);
+    const paused = isPausable ? await this.paused() : false;
+    if (info.startTimestamp === 0) {
+      blockers.push(
+        new VestingNotFoundError({
+          method: "claim",
+          contractAddress: this.address,
+          vestingId: args.vestingId
+        })
+      );
+      return { ready: false, blockers };
+    }
+    if (info.recipient.toLowerCase() !== args.caller.toLowerCase()) {
+      blockers.push(
+        new NotVestingRecipientError({
+          method: "claim",
+          contractAddress: this.address,
+          vestingId: args.vestingId,
+          caller: args.caller,
+          expectedRecipient: info.recipient
+        })
+      );
+    }
+    const unlocksAt = info.startTimestamp + info.timelock;
+    if (Number(currentBlock.timestamp) < unlocksAt) {
+      blockers.push(
+        new ClaimLockedError({
+          method: "claim",
+          contractAddress: this.address,
+          vestingId: args.vestingId,
+          unlocksAt
+        })
+      );
+    }
+    if (paused) {
+      blockers.push(new PausedError({ method: "claim", contractAddress: this.address }));
+    }
+    if (feeInfo.feeType === 0 /* Gas */ && callerBalance < feeInfo.fee) {
+      blockers.push(
+        new InsufficientFeeError({
+          method: "claim",
+          contractAddress: this.address,
+          feeKind: "gas",
+          required: feeInfo.fee,
+          provided: callerBalance
+        })
+      );
+    }
+    return { ready: blockers.length === 0, blockers };
+  }
+  // ============================================================
+  //                     ENCRYPTED VIEWS (TX)
+  // ============================================================
+  //
+  // These contract functions perform `FHE.allow(handle, msg.sender)` so they
+  // mutate ACL state and must run as transactions. We simulate first to lift
+  // the returned handle out of calldata, then submit the tx to persist ACL.
+  /**
+   * Get the vested amount at a given timestamp as an encrypted handle.
+   *
+   * Submits a transaction that calls `FHE.allow(handle, msg.sender)` — the handle
+   * is extracted from the receipt's ACL `Allowed` event, not from simulation. Pass
+   * `handle` to the Zama relayer's `userDecrypt` to obtain the plaintext.
+   *
+   * @param args.timestamp Unix timestamp to evaluate vesting at (use `Date.now() / 1000` for current).
+   * @returns `{ handle, hash }` — `handle` is a `euint128` granted to the caller.
+   */
+  async getVestedAmount(args) {
+    return this.#encryptedView("getVestedAmount", [args.vestingId, args.timestamp], args.account);
+  }
+  /**
+   * Get the currently claimable token amount as an encrypted handle.
+   *
+   * Like all encrypted view methods, this submits a transaction. Pass `handle`
+   * to the Zama relayer's `userDecrypt` to obtain the plaintext.
+   *
+   * @returns `{ handle, hash }` — `handle` is a `euint128` granted to the caller.
+   */
+  async getClaimableAmount(args) {
+    return this.#encryptedView("getClaimableAmount", [args.vestingId], args.account);
+  }
+  async getTotalAllocation(args) {
+    return this.#encryptedView("getTotalAllocation", [args.vestingId], args.account);
+  }
+  async getSettledAmount(args) {
+    return this.#encryptedView("getSettledAmount", [args.vestingId], args.account);
+  }
+  async adminGetVestedAmount(args) {
+    return this.#encryptedView(
+      "adminGetVestedAmount",
+      [args.vestingId, args.timestamp],
+      args.account
+    );
+  }
+  async adminGetClaimableAmount(args) {
+    return this.#encryptedView("adminGetClaimableAmount", [args.vestingId], args.account);
+  }
+  async adminGetTotalAllocation(args) {
+    return this.#encryptedView("adminGetTotalAllocation", [args.vestingId], args.account);
+  }
+  async adminGetSettledAmount(args) {
+    return this.#encryptedView("adminGetSettledAmount", [args.vestingId], args.account);
+  }
+  async adminGetTokenBalance(args) {
+    return this.#encryptedView("adminGetTokenBalance", [], args?.account);
+  }
+  // ============================================================
+  //                       VESTING WRITES
+  // ============================================================
+  /**
+   * Create a single vesting schedule. The SDK encrypts `amount` into an
+   * `externalEuint64` and submits it as the input proof — callers pass plaintext.
+   *
+   * Pass `encryptedInput` to bypass the encryptor when you manage encryption yourself.
+   *
+   * @returns Transaction hash. Parse the `VestingCreated` event to extract the `vestingId`.
+   * @example
+   * const hash = await manager.createVesting({
+   *   params: { recipient, startTimestamp, endTimestamp, cliffSeconds: 0,
+   *             releaseIntervalSecs: 86400, timelockSeconds: 0,
+   *             initialUnlockBps: 0, cliffAmountBps: 0, isRevocable: false },
+   *   amount: 1_000_000n,
+   * });
+   */
+  async createVesting(args) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.createVesting", async () => {
+      const wallet = this.#requireWallet("createVesting");
+      const account = this.#resolveAccount(wallet, args.account, "createVesting");
+      this.#validateVestingParams(args.params, "createVesting");
+      const encrypted = await this.#resolveEncryptedAmount({
+        amount: args.amount,
+        encryptedInput: args.encryptedInput,
+        encryptor: args.encryptor,
+        method: "createVesting",
+        account
+      });
+      try {
+        return await wallet.writeContract({
+          address: this.address,
+          abi: confidentialVestingManagerAbi,
+          functionName: "createVesting",
+          args: [args.params, encrypted.handle, encrypted.inputProof],
+          account,
+          chain: wallet.chain
+        });
+      } catch (err) {
+        throw this.#mapRevert("createVesting", err, void 0, accountAddress(account));
+      }
+    });
+  }
+  /**
+   * Batch-create vesting schedules. All amounts are encrypted together under a
+   * single input proof, saving gas vs. multiple `createVesting` calls.
+   *
+   * Respects `maxBatchSize` — check before calling on large lists.
+   *
+   * @returns Transaction hash.
+   */
+  async batchCreateVesting(args) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.batchCreateVesting", async () => {
+      if (args.items.length === 0) {
+        throw new InvalidArgumentError({
+          method: "batchCreateVesting",
+          argument: "items",
+          reason: "must be non-empty"
+        });
+      }
+      args.items.forEach(
+        (it, i) => this.#validateVestingParams(it.params, `batchCreateVesting.items[${i}].params`)
+      );
+      const wallet = this.#requireWallet("batchCreateVesting");
+      const account = this.#resolveAccount(wallet, args.account, "batchCreateVesting");
+      const encryptor = args.encryptor ?? resolveEncryptor(this.encryptor);
+      if (!encryptor) {
+        throw new MissingEncryptorError("batchCreateVesting");
+      }
+      const userAddress = accountAddress(account);
+      let batch;
+      try {
+        batch = await encryptUint64Batch({
+          encryptor,
+          contractAddress: this.address,
+          userAddress,
+          values: args.items.map((it) => it.amount)
+        });
+      } catch (err) {
+        throw mapZamaError(err, { method: "batchCreateVesting", operation: "encrypt" });
+      }
+      try {
+        return await wallet.writeContract({
+          address: this.address,
+          abi: confidentialVestingManagerAbi,
+          functionName: "batchCreateVesting",
+          // handles[i] corresponds to items[i] — order must be preserved
+          args: [args.items.map((it) => it.params), batch.handles, batch.inputProof],
+          account,
+          chain: wallet.chain
+        });
+      } catch (err) {
+        throw this.#mapRevert("batchCreateVesting", err, void 0, userAddress);
+      }
+    });
+  }
+  /**
+   * Claim all currently vested tokens for `vestingId`.
+   * For `FeeType.Gas` managers, pass `value` (gas fee in wei from `getFeeInfo()`).
+   * @param args Discriminated by `feeType`: pass `{ feeType, vestingId, value }` for Gas, `{ feeType, vestingId }` for DistributionToken.
+   * @returns Transaction hash.
+   * @example
+   * const { feeType, fee } = await manager.getFeeInfo();
+   * const hash = await manager.claim(
+   *   feeType === FeeType.Gas ? { feeType, vestingId, value: fee } : { feeType, vestingId },
+   * );
+   */
+  async claim(args) {
+    const wallet = this.#requireWallet("claim");
+    const account = this.#resolveAccount(wallet, args.account, "claim");
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "claim",
+        args: [args.vestingId],
+        account,
+        chain: wallet.chain,
+        value: args.value
+      });
+    } catch (err) {
+      throw this.#mapRevert("claim", err, { vestingId: args.vestingId }, accountAddress(account));
+    }
+  }
+  /**
+   * Admin variant of `claim` — callable by the manager admin on behalf of any recipient.
+   * Useful for gas-sponsored claim flows. Same fee rules as `claim`.
+   * @param args Same discriminated union as `claim`.
+   * @returns Transaction hash.
+   */
+  async adminClaim(args) {
+    const wallet = this.#requireWallet("adminClaim");
+    const account = this.#resolveAccount(wallet, args.account, "adminClaim");
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "adminClaim",
+        args: [args.vestingId],
+        account,
+        chain: wallet.chain,
+        value: args.value
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        "adminClaim",
+        err,
+        { vestingId: args.vestingId },
+        accountAddress(account)
+      );
+    }
+  }
+  /**
+   * Claim a specific encrypted amount from a vesting schedule rather than the full claimable balance.
+   * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput` to bypass encryption.
+   * @param args Includes `vestingId`, `amount` or `encryptedInput`, and optional `value` for Gas-fee managers.
+   * @returns Transaction hash.
+   */
+  async partialClaim(args) {
+    const wallet = this.#requireWallet("partialClaim");
+    const account = this.#resolveAccount(wallet, args.account, "partialClaim");
+    const encrypted = await this.#resolveEncryptedAmount({
+      amount: args.amount,
+      encryptedInput: args.encryptedInput,
+      encryptor: args.encryptor,
+      method: "partialClaim",
+      account
+    });
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "partialClaim",
+        args: [args.vestingId, encrypted.handle, encrypted.inputProof],
+        account,
+        chain: wallet.chain,
+        value: args.value
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        "partialClaim",
+        err,
+        { vestingId: args.vestingId },
+        accountAddress(account)
+      );
+    }
+  }
+  /**
+   * Admin variant of `partialClaim` — callable by the manager admin on behalf of any recipient.
+   * @param args Same as `partialClaim`.
+   * @returns Transaction hash.
+   */
+  async adminPartialClaim(args) {
+    const wallet = this.#requireWallet("adminPartialClaim");
+    const account = this.#resolveAccount(wallet, args.account, "adminPartialClaim");
+    const encrypted = await this.#resolveEncryptedAmount({
+      amount: args.amount,
+      encryptedInput: args.encryptedInput,
+      encryptor: args.encryptor,
+      method: "adminPartialClaim",
+      account
+    });
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "adminPartialClaim",
+        args: [args.vestingId, encrypted.handle, encrypted.inputProof],
+        account,
+        chain: wallet.chain,
+        value: args.value
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        "adminPartialClaim",
+        err,
+        { vestingId: args.vestingId },
+        accountAddress(account)
+      );
+    }
+  }
+  /**
+   * Revoke a vesting schedule. Callable only when the schedule was created with `isRevocable: true`.
+   * The unvested remainder is returned to the manager admin.
+   * @param vestingId The `bytes32` vesting schedule ID to revoke.
+   * @returns Transaction hash.
+   */
+  async revokeVesting(vestingId, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.revokeVesting", async () => {
+      return this.#simpleWrite("revokeVesting", [vestingId], account, { vestingId });
+    });
+  }
+  /**
+   * Revoke multiple vesting schedules in one transaction. Respects `maxRevokeBatchSize`.
+   * @param vestingIds Array of `bytes32` vesting schedule IDs to revoke.
+   * @returns Transaction hash.
+   */
+  async batchRevokeVesting(vestingIds, account) {
+    if (vestingIds.length === 0) {
+      throw new InvalidArgumentError({
+        method: "batchRevokeVesting",
+        argument: "vestingIds",
+        reason: "must be non-empty"
+      });
+    }
+    return this.#simpleWrite("batchRevokeVesting", [vestingIds], account);
+  }
+  /**
+   * Split a vesting into two positions.
+   *
+   * The `numerator/denominator` ratio is auto-scaled via `scaleRatio` to the
+   * universal split constant `FHE_SPLIT_DENOMINATOR` (`90_090_000` =
+   * LCM(1..16, 10_000)) unless `args.preScaled` is set. Every confidential
+   * split lands on the same plaintext denominator so the constant itself
+   * leaks no information about the split's shape; only the encrypted
+   * numerator carries the share. `90_090_000` is well above the contract's
+   * `MIN_SPLIT_DENOMINATOR` (10_000) floor. The SDK encrypts `numerator` —
+   * pass plaintext.
+   *
+   * Two natural input shapes both produce exact integer numerators against
+   * the universal denominator:
+   * - `n/m` with `m ∈ 1..16` (halves, thirds, …, sixteenths)
+   * - `bps/10_000` (basis points)
+   *
+   * Use the {@link share} builder to construct them without manual math:
+   * `share.fraction(1, 7)` or `share.basisPoints(250)` → pass the returned
+   * `{ numerator, denominator }` with `preScaled: true`.
+   *
+   * @param args.numerator Plaintext share numerator (kept confidential on-chain).
+   * @param args.denominator Plaintext denominator — auto-scaled to 90_090_000.
+   * @param args.newRecipient Recipient address for the split-off position.
+   * @returns `{ hash, newVestingId }` — the receipt-derived id of the
+   *          newly-created vesting position, required for any follow-up call
+   *          (claim, transfer, disclose) on the split-off position.
+   * @example
+   * const { newVestingId } = await manager.splitVesting({
+   *   vestingId,
+   *   numerator: 1n, denominator: 2n,   // 50% split; SDK scales to 45_045_000 / 90_090_000
+   *   newRecipient: "0xNewRecipient",
+   * });
+   *
+   * @example
+   * // Basis-point style via the guided builder:
+   * const ratio = share.basisPoints(250);    // 2.5%
+   * const { newVestingId } = await manager.splitVesting({
+   *   vestingId,
+   *   numerator: ratio.numerator,
+   *   denominator: ratio.denominator,
+   *   preScaled: true,
+   *   newRecipient: "0xNewRecipient",
+   * });
+   */
+  async splitVesting(args) {
+    const wallet = this.#requireWallet("splitVesting");
+    const account = this.#resolveAccount(wallet, args.account, "splitVesting");
+    const { numerator, denominator } = args.preScaled ? { numerator: args.numerator, denominator: args.denominator } : scaleRatio({
+      numerator: args.numerator,
+      denominator: args.denominator,
+      // The encrypted numerator is submitted via `encryptUint64`, so
+      // bound `scaleRatio`'s validator to that width. Out-of-range
+      // inputs surface as `InvalidArgumentError` on `numerator`
+      // instead of a downstream `EncryptionFailedError`.
+      width: "uint64"
+    });
+    if (denominator < 10000n) {
+      throw new InvalidArgumentError({
+        method: "splitVesting",
+        argument: "denominator",
+        reason: "must be \u2265 10000 (the contract's MIN_SPLIT_DENOMINATOR floor)",
+        value: denominator
+      });
+    }
+    if (args.newRecipient === ZERO_ADDRESS) {
+      throw new InvalidArgumentError({
+        method: "splitVesting",
+        argument: "newRecipient",
+        reason: "must not be the zero address"
+      });
+    }
+    const encrypted = await this.#encryptUint64(numerator, args.encryptor, account);
+    let hash;
+    try {
+      hash = await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "splitVesting",
+        args: [
+          args.vestingId,
+          encrypted.handle,
+          encrypted.inputProof,
+          denominator,
+          args.newRecipient
+        ],
+        account,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        "splitVesting",
+        err,
+        { vestingId: args.vestingId },
+        accountAddress(account)
+      );
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const ours = receipt.logs.filter(
+      (log) => log.address.toLowerCase() === this.address.toLowerCase()
+    );
+    const events = parseEventLogs({ abi: confidentialVestingManagerAbi, eventName: "VestingSplit", logs: ours });
+    const matches = events.filter(
+      (ev) => ev.args.originalVestingId.toLowerCase() === args.vestingId.toLowerCase() && ev.args.newRecipient.toLowerCase() === args.newRecipient.toLowerCase()
+    );
+    if (matches.length === 0) {
+      throw new ReceiptEventNotFoundError({
+        method: "splitVesting",
+        eventName: "VestingSplit",
+        contractAddress: this.address,
+        txHash: hash,
+        hint: `Expected VestingSplit for original ${args.vestingId} \u2192 recipient ${args.newRecipient}; the contract did not emit one.`
+      });
+    }
+    if (matches.length > 1) {
+      throw new ReceiptEventAmbiguousError({
+        method: "splitVesting",
+        eventName: "VestingSplit",
+        contractAddress: this.address,
+        txHash: hash,
+        count: matches.length
+      });
+    }
+    return { hash, newVestingId: matches[0].args.newVestingId };
+  }
+  // ============================================================
+  //                       TRANSFER FLOW
+  // ============================================================
+  /**
+   * Initiate a vesting schedule transfer to a new recipient.
+   * The new recipient has `transferDurationSeconds` to accept before the offer expires.
+   * @param args `{ vestingId, newRecipient, transferDurationSeconds }`.
+   * @returns Transaction hash.
+   */
+  async initiateVestingTransfer(args) {
+    if (!isAddress(args.newRecipient, { strict: true })) {
+      throw new InvalidArgumentError({
+        method: "initiateVestingTransfer",
+        argument: "newRecipient",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: args.newRecipient
+      });
+    }
+    if (args.newRecipient === ZERO_ADDRESS) {
+      throw new InvalidArgumentError({
+        method: "initiateVestingTransfer",
+        argument: "newRecipient",
+        reason: "must not be the zero address"
+      });
+    }
+    if (args.transferDurationSeconds <= 0) {
+      throw new InvalidArgumentError({
+        method: "initiateVestingTransfer",
+        argument: "transferDurationSeconds",
+        reason: "must be > 0",
+        value: args.transferDurationSeconds
+      });
+    }
+    return this.#simpleWrite(
+      "initiateVestingTransfer",
+      [args.vestingId, args.newRecipient, args.transferDurationSeconds],
+      args.account,
+      { vestingId: args.vestingId }
+    );
+  }
+  /**
+   * Accept a pending vesting transfer. Called by the `newRecipient` named in `initiateVestingTransfer`.
+   * @param vestingId The `bytes32` vesting schedule ID being transferred.
+   * @returns Transaction hash.
+   */
+  async acceptVestingTransfer(vestingId, account) {
+    return this.#simpleWrite("acceptVestingTransfer", [vestingId], account, { vestingId });
+  }
+  /**
+   * Cancel a pending vesting transfer. Callable by either the original or new recipient.
+   * @param vestingId The `bytes32` vesting schedule ID with a pending transfer.
+   * @returns Transaction hash.
+   */
+  async cancelVestingTransfer(vestingId, account) {
+    return this.#simpleWrite("cancelVestingTransfer", [vestingId], account, { vestingId });
+  }
+  /**
+   * Transfer ownership of a vesting schedule directly to `newOwner` without a time-locked acceptance window.
+   * Callable only by the manager admin.
+   * @param vestingId The `bytes32` vesting schedule ID to transfer.
+   * @param newOwner Address that will become the new recipient.
+   * @returns Transaction hash.
+   */
+  async directVestingTransfer(vestingId, newOwner, account) {
+    if (!isAddress(newOwner, { strict: true })) {
+      throw new InvalidArgumentError({
+        method: "directVestingTransfer",
+        argument: "newOwner",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: newOwner
+      });
+    }
+    if (newOwner === ZERO_ADDRESS) {
+      throw new InvalidArgumentError({
+        method: "directVestingTransfer",
+        argument: "newOwner",
+        reason: "must not be the zero address"
+      });
+    }
+    return this.#simpleWrite("directVestingTransfer", [vestingId, newOwner], account, {
+      vestingId
+    });
+  }
+  // ============================================================
+  //                       DISCLOSURE
+  // ============================================================
+  /**
+   * Disclose a single vesting amount to `party`, granting them persistent FHE
+   * ACL on the corresponding `euint128` handle. The handle is parsed from the
+   * `AmountDisclosed` event filtered by the indexed
+   * `(vestingId, discloser=caller, party)` tuple — exactly one match expected.
+   *
+   * @returns `{ hash, handle }` — pass `handle` to the Zama relayer's
+   *          `userDecrypt` (from the `party` side) to obtain the plaintext.
+   */
+  async discloseToParty(args) {
+    return this.#discloseSingleWithReceipt({
+      functionName: "discloseToParty",
+      vestingId: args.vestingId,
+      party: args.party,
+      writeArgs: [args.vestingId, args.party, args.disclosureType],
+      account: args.account
+    });
+  }
+  /**
+   * Disclose multiple vesting amounts to one `party` in a single tx. Handles
+   * are parsed from the matching `AmountDisclosed` events and returned in the
+   * same order as `args.vestingIds` (one handle per input id).
+   *
+   * @returns `{ hash, handles }` — `handles[i]` corresponds to `vestingIds[i]`.
+   */
+  async batchDiscloseToParty(args) {
+    if (args.vestingIds.length === 0) {
+      throw new InvalidArgumentError({
+        method: "batchDiscloseToParty",
+        argument: "vestingIds",
+        reason: "must be non-empty"
+      });
+    }
+    if (args.vestingIds.length !== args.disclosureTypes.length) {
+      throw new InvalidArgumentError({
+        method: "batchDiscloseToParty",
+        argument: "disclosureTypes",
+        reason: `length mismatch: vestingIds=${args.vestingIds.length}, disclosureTypes=${args.disclosureTypes.length}`
+      });
+    }
+    return this.#discloseBatchWithReceipt({
+      functionName: "batchDiscloseToParty",
+      vestingIds: args.vestingIds,
+      party: args.party,
+      writeArgs: [args.vestingIds, args.disclosureTypes, args.party],
+      account: args.account
+    });
+  }
+  /**
+   * Admin-only counterpart to {@link discloseToParty}. Same receipt-parsing
+   * semantics — returns the granted `euint128` handle from the
+   * `AmountDisclosed` event.
+   */
+  async adminDiscloseToParty(args) {
+    return this.#discloseSingleWithReceipt({
+      functionName: "adminDiscloseToParty",
+      vestingId: args.vestingId,
+      party: args.party,
+      writeArgs: [args.vestingId, args.party, args.disclosureType],
+      account: args.account
+    });
+  }
+  /**
+   * Admin-only counterpart to {@link batchDiscloseToParty}. Same return shape.
+   */
+  async adminBatchDiscloseToParty(args) {
+    if (args.vestingIds.length === 0) {
+      throw new InvalidArgumentError({
+        method: "adminBatchDiscloseToParty",
+        argument: "vestingIds",
+        reason: "must be non-empty"
+      });
+    }
+    if (args.vestingIds.length !== args.disclosureTypes.length) {
+      throw new InvalidArgumentError({
+        method: "adminBatchDiscloseToParty",
+        argument: "disclosureTypes",
+        reason: `length mismatch: vestingIds=${args.vestingIds.length}, disclosureTypes=${args.disclosureTypes.length}`
+      });
+    }
+    return this.#discloseBatchWithReceipt({
+      functionName: "adminBatchDiscloseToParty",
+      vestingIds: args.vestingIds,
+      party: args.party,
+      writeArgs: [args.vestingIds, args.disclosureTypes, args.party],
+      account: args.account
+    });
+  }
+  /**
+   * Grant `party` persistent FHE ACL on an already-obtained encrypted handle.
+   * Use this when you hold a handle from a previous call and want to share it with another address.
+   * @param handle The `euint128` encrypted handle to disclose.
+   * @param party Address to grant ACL on the handle.
+   * @returns Transaction hash.
+   */
+  async discloseHandleToParty(handle, party, account) {
+    return this.#simpleWrite("discloseHandleToParty", [handle, party], account);
+  }
+  /**
+   * Grant `party` persistent FHE ACL on multiple encrypted handles in one transaction.
+   * @param handles Array of `euint128` handles to disclose.
+   * @param party Address to grant ACL on all handles.
+   * @returns Transaction hash.
+   */
+  async batchDiscloseHandlesToParty(handles, party, account) {
+    if (handles.length === 0) {
+      throw new InvalidArgumentError({
+        method: "batchDiscloseHandlesToParty",
+        argument: "handles",
+        reason: "must be non-empty"
+      });
+    }
+    return this.#simpleWrite("batchDiscloseHandlesToParty", [handles, party], account);
+  }
+  // ============================================================
+  //                       ADMIN WRITES
+  // ============================================================
+  /**
+   * Withdraw a confidential token amount from the manager's balance back to the admin.
+   * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput`.
+   * @param args `{ amount }` (plaintext, SDK encrypts) or `{ encryptedInput }` (pre-encrypted).
+   * @returns Transaction hash.
+   */
+  async withdrawAdmin(args) {
+    const wallet = this.#requireWallet("withdrawAdmin");
+    const account = this.#resolveAccount(wallet, args.account, "withdrawAdmin");
+    const encrypted = await this.#resolveEncryptedAmount({
+      amount: args.amount,
+      encryptedInput: args.encryptedInput,
+      encryptor: args.encryptor,
+      method: "withdrawAdmin",
+      account
+    });
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "withdrawAdmin",
+        args: [encrypted.handle, encrypted.inputProof],
+        account,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert("withdrawAdmin", err, void 0, accountAddress(account));
+    }
+  }
+  /**
+   * Recover a plain ERC-20 token accidentally sent to this manager. Admin only.
+   * @param token ERC-20 token address to recover.
+   * @param to Recipient address for the recovered tokens.
+   * @returns Transaction hash.
+   */
+  async withdrawOtherToken(token, to, account) {
+    return this.#simpleWrite("withdrawOtherToken", [token, to], account);
+  }
+  /**
+   * Recover a confidential ERC-7984 token accidentally sent to this manager. Admin only.
+   * @param token ERC-7984 token address to recover.
+   * @param to Recipient address for the recovered tokens.
+   * @returns Transaction hash.
+   */
+  async withdrawOtherConfidentialToken(token, to, account) {
+    return this.#simpleWrite("withdrawOtherConfidentialToken", [token, to], account);
+  }
+  /**
+   * Withdraw accumulated ETH gas fees from the manager to `to`. Admin only.
+   * @param to Recipient address.
+   * @param amount Amount in wei.
+   * @returns Transaction hash.
+   */
+  async withdrawGasFee(to, amount, account) {
+    return this.#simpleWrite("withdrawGasFee", [to, amount], account);
+  }
+  /**
+   * Withdraw accumulated token fees from a `FeeType.DistributionToken` manager. Admin only.
+   * The SDK encrypts `amount` — pass plaintext. Alternatively pass `encryptedInput`.
+   * @param args `{ to, amount }` (plaintext, SDK encrypts) or `{ to, encryptedInput }` (pre-encrypted).
+   * @returns Transaction hash.
+   */
+  async withdrawTokenFee(args) {
+    if (args.to === ZERO_ADDRESS) {
+      throw new InvalidArgumentError({
+        method: "withdrawTokenFee",
+        argument: "to",
+        reason: "must not be the zero address"
+      });
+    }
+    const wallet = this.#requireWallet("withdrawTokenFee");
+    const account = this.#resolveAccount(wallet, args.account, "withdrawTokenFee");
+    const encrypted = await this.#resolveEncryptedAmount({
+      amount: args.amount,
+      encryptedInput: args.encryptedInput,
+      encryptor: args.encryptor,
+      method: "withdrawTokenFee",
+      account
+    });
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: "withdrawTokenFee",
+        args: [args.to, encrypted.handle, encrypted.inputProof],
+        account,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert("withdrawTokenFee", err, void 0, accountAddress(account));
+    }
+  }
+  /**
+   * Update the maximum number of vestings allowed in a single `batchCreateVesting` call. Admin only.
+   * @param newMax New batch size limit.
+   * @returns Transaction hash.
+   */
+  async setMaxBatchSize(newMax, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.setMaxBatchSize", async () => {
+      return this.#simpleWrite("setMaxBatchSize", [newMax], account);
+    });
+  }
+  /**
+   * Update the maximum number of vestings allowed in a single `batchRevokeVesting` call. Admin only.
+   * @param newMax New revoke batch size limit.
+   * @returns Transaction hash.
+   */
+  async setMaxRevokeBatchSize(newMax, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.setMaxRevokeBatchSize", async () => {
+      return this.#simpleWrite("setMaxRevokeBatchSize", [BigInt(newMax)], account);
+    });
+  }
+  /**
+   * Transfer the fee-collector role to a new address. Callable by the current fee collector.
+   * @param newCollector Address to assign the fee-collector role.
+   * @returns Transaction hash.
+   */
+  async transferFeeCollectorRole(newCollector, account) {
+    return this.#simpleWrite("transferFeeCollectorRole", [newCollector], account);
+  }
+  // ============================================================
+  //                          PAUSE
+  // ============================================================
+  /**
+   * Pause the manager, blocking all claim operations. Requires `isPausable() === true`. PAUSER_ROLE only.
+   * @returns Transaction hash.
+   */
+  async pause(account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.pause", async () => {
+      return this.#simpleWrite("pause", [], account);
+    });
+  }
+  /**
+   * Resume a paused manager, re-enabling claim operations. PAUSER_ROLE only.
+   * @returns Transaction hash.
+   */
+  async unpause(account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.unpause", async () => {
+      return this.#simpleWrite("unpause", [], account);
+    });
+  }
+  // ============================================================
+  //                          ROLES
+  // ============================================================
+  /**
+   * Check whether `account` holds `role` on this manager.
+   * @param role `bytes32` role identifier — use the `roleConstants()` helper or the SDK's exported role constants.
+   * @param account Address to check.
+   * @returns `true` if the account holds the role.
+   */
+  async hasRole(role, account) {
+    return this.#read("hasRole", [role, account]);
+  }
+  /**
+   * Grant `role` to `accountTarget`. Requires DEFAULT_ADMIN_ROLE.
+   * @param role `bytes32` role identifier.
+   * @param accountTarget Address to grant the role to.
+   * @returns Transaction hash.
+   */
+  async grantRole(role, accountTarget, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.grantRole", async () => {
+      return this.#simpleWrite("grantRole", [role, accountTarget], account);
+    });
+  }
+  /**
+   * Revoke `role` from `accountTarget`. Requires DEFAULT_ADMIN_ROLE.
+   * @param role `bytes32` role identifier.
+   * @param accountTarget Address to revoke the role from.
+   * @returns Transaction hash.
+   */
+  async revokeRole(role, accountTarget, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.revokeRole", async () => {
+      return this.#simpleWrite("revokeRole", [role, accountTarget], account);
+    });
+  }
+  /**
+   * Renounce a role held by the caller. `callerConfirm` must equal `msg.sender` (OpenZeppelin guard).
+   * @param role `bytes32` role identifier to renounce.
+   * @param callerConfirm Must equal the calling account address.
+   * @returns Transaction hash.
+   */
+  async renounceRole(role, callerConfirm, account) {
+    return withTelemetry(this.#telemetry, "fhe-vesting.manager.renounceRole", async () => {
+      return this.#simpleWrite("renounceRole", [role, callerConfirm], account);
+    });
+  }
+  /**
+   * Read all role identifiers from the contract in one multicall.
+   * @returns Object mapping role name to its `bytes32` identifier.
+   * @example
+   * const { VESTING_CREATOR_ROLE } = await manager.roleConstants();
+   * await manager.grantRole(VESTING_CREATOR_ROLE, creatorAddress);
+   */
+  async roleConstants() {
+    const [
+      DEFAULT_ADMIN_ROLE,
+      VESTING_CREATOR_ROLE,
+      REVOKER_ROLE,
+      WITHDRAWER_ROLE,
+      CLAIMER_ROLE,
+      FEE_COLLECTOR_ROLE,
+      PAUSER_ROLE,
+      DISCLOSURE_ADMIN_ROLE
+    ] = await Promise.all([
+      this.#read("DEFAULT_ADMIN_ROLE"),
+      this.#read("VESTING_CREATOR_ROLE"),
+      this.#read("REVOKER_ROLE"),
+      this.#read("WITHDRAWER_ROLE"),
+      this.#read("CLAIMER_ROLE"),
+      this.#read("FEE_COLLECTOR_ROLE"),
+      this.#read("PAUSER_ROLE"),
+      this.#read("DISCLOSURE_ADMIN_ROLE")
+    ]);
+    return {
+      DEFAULT_ADMIN_ROLE,
+      VESTING_CREATOR_ROLE,
+      REVOKER_ROLE,
+      WITHDRAWER_ROLE,
+      CLAIMER_ROLE,
+      FEE_COLLECTOR_ROLE,
+      PAUSER_ROLE,
+      DISCLOSURE_ADMIN_ROLE
+    };
+  }
+  // ============================================================
+  //                        INTERNALS
+  // ============================================================
+  #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;
+  }
+  async #encryptUint64(value, encryptor, account) {
+    const enc = encryptor ?? resolveEncryptor(this.encryptor);
+    if (!enc) {
+      throw new MissingEncryptorError("encryptUint64", {
+        hint: "Pass `encryptor` to the call or the client config (eager or lazy factory)."
+      });
+    }
+    try {
+      return await encryptUint64({
+        encryptor: enc,
+        contractAddress: this.address,
+        userAddress: accountAddress(account),
+        value
+      });
+    } catch (err) {
+      throw mapZamaError(err, { method: "encryptUint64", operation: "encrypt" });
+    }
+  }
+  /**
+   * Resolve the encrypted-input payload for a write that takes either a plaintext
+   * `amount` (which the SDK encrypts) or a pre-built `encryptedInput`. Enforces
+   * the **exactly-one-of** contract — neither path silently wins if both are
+   * supplied, which would let plaintext metadata drift from the on-chain
+   * ciphertext. Pre-encrypted callers can omit `amount` entirely.
+   */
+  async #resolveEncryptedAmount(args) {
+    const hasAmount = args.amount !== void 0;
+    const hasInput = args.encryptedInput !== void 0;
+    if (hasAmount && hasInput) {
+      throw new InvalidArgumentError({
+        method: args.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: args.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 args.encryptedInput;
+    return this.#encryptUint64(args.amount, args.encryptor, args.account);
+  }
+  /**
+   * Translate any error from a vesting `writeContract` / `readContract` /
+   * `simulateContract` call into a typed {@link TokenOpsSdkError}. Pass
+   * `productContext.vestingId` so the resulting vesting-typed error carries
+   * the offending schedule id in its context.
+   */
+  #mapRevert(method, err, productContext, account) {
+    return mapContractRevert(err, {
+      method,
+      contractAddress: this.address,
+      abi: confidentialVestingManagerAbi,
+      productMapper: vestingProductMapper,
+      productContext,
+      account
+    });
+  }
+  async #simpleWrite(functionName, args, account, productContext) {
+    const wallet = this.#requireWallet(functionName);
+    const acct = this.#resolveAccount(wallet, account, functionName);
+    await this.#preflightWrite(functionName, functionName, args, acct, productContext);
+    try {
+      return await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName,
+        args,
+        account: acct,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert(functionName, err, productContext, accountAddress(acct));
+    }
+  }
+  /**
+   * 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, productContext, value) {
+    try {
+      await this.publicClient.simulateContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName,
+        args,
+        account,
+        ...value !== void 0 ? { value } : {}
+      });
+    } catch (err) {
+      if (isContractRevert(err)) {
+        throw this.#mapRevert(method, err, productContext, accountAddress(account));
+      }
+    }
+  }
+  /**
+   * Submit a single-vesting disclosure write and parse the `AmountDisclosed`
+   * event for the granted `euint128` handle. The event has
+   * `(vestingId, discloser, party)` indexed — all three are known at call
+   * time, so the filter is exact.
+   */
+  async #discloseSingleWithReceipt(input) {
+    if (!isAddress(input.party, { strict: true })) {
+      throw new InvalidArgumentError({
+        method: input.functionName,
+        argument: "party",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: input.party
+      });
+    }
+    const wallet = this.#requireWallet(input.functionName);
+    const acct = this.#resolveAccount(wallet, input.account, input.functionName);
+    let hash;
+    try {
+      hash = await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: input.functionName,
+        args: input.writeArgs,
+        account: acct,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        input.functionName,
+        err,
+        { vestingId: input.vestingId },
+        accountAddress(acct)
+      );
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const ours = receipt.logs.filter(
+      (log) => log.address.toLowerCase() === this.address.toLowerCase()
+    );
+    const events = parseEventLogs({ abi: confidentialVestingManagerAbi, eventName: "AmountDisclosed", logs: ours });
+    const callerAddress = accountAddress(acct).toLowerCase();
+    const matches = events.filter(
+      (ev) => ev.args.vestingId.toLowerCase() === input.vestingId.toLowerCase() && ev.args.discloser.toLowerCase() === callerAddress && ev.args.party.toLowerCase() === input.party.toLowerCase()
+    );
+    if (matches.length === 0) {
+      throw new ReceiptEventNotFoundError({
+        method: input.functionName,
+        eventName: "AmountDisclosed",
+        contractAddress: this.address,
+        txHash: hash,
+        hint: `Expected AmountDisclosed for vestingId ${input.vestingId} \u2192 party ${input.party}; the contract did not emit one.`
+      });
+    }
+    if (matches.length > 1) {
+      throw new ReceiptEventAmbiguousError({
+        method: input.functionName,
+        eventName: "AmountDisclosed",
+        contractAddress: this.address,
+        txHash: hash,
+        count: matches.length
+      });
+    }
+    return { hash, handle: matches[0].args.encryptedAmount };
+  }
+  /**
+   * Submit a batch-disclosure write and parse one `AmountDisclosed` event per
+   * input `vestingId`. Handles are returned in input order (each `handles[i]`
+   * corresponds to `vestingIds[i]`).
+   */
+  async #discloseBatchWithReceipt(input) {
+    if (!isAddress(input.party, { strict: true })) {
+      throw new InvalidArgumentError({
+        method: input.functionName,
+        argument: "party",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: input.party
+      });
+    }
+    const wallet = this.#requireWallet(input.functionName);
+    const acct = this.#resolveAccount(wallet, input.account, input.functionName);
+    let hash;
+    try {
+      hash = await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName: input.functionName,
+        args: input.writeArgs,
+        account: acct,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert(input.functionName, err, void 0, accountAddress(acct));
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const ours = receipt.logs.filter(
+      (log) => log.address.toLowerCase() === this.address.toLowerCase()
+    );
+    const events = parseEventLogs({ abi: confidentialVestingManagerAbi, eventName: "AmountDisclosed", logs: ours });
+    const callerAddress = accountAddress(acct).toLowerCase();
+    const partyLower = input.party.toLowerCase();
+    const byVestingId = /* @__PURE__ */ new Map();
+    for (const ev of events) {
+      if (ev.args.discloser.toLowerCase() === callerAddress && ev.args.party.toLowerCase() === partyLower) {
+        byVestingId.set(ev.args.vestingId.toLowerCase(), ev.args.encryptedAmount);
+      }
+    }
+    const handles = [];
+    for (const id of input.vestingIds) {
+      const handle = byVestingId.get(id.toLowerCase());
+      if (handle === void 0) {
+        throw new ReceiptEventNotFoundError({
+          method: input.functionName,
+          eventName: "AmountDisclosed",
+          contractAddress: this.address,
+          txHash: hash,
+          hint: `Missing AmountDisclosed for vestingId ${id}; the batch did not produce a handle for every input id.`
+        });
+      }
+      handles.push(handle);
+    }
+    return { hash, handles };
+  }
+  /**
+   * Cheap structural validation that mirrors the contract-side
+   * `_validateVestingParams` invariants. Throws `InvalidArgumentError` with a
+   * specific `argument` field so UIs can highlight the offending input rather
+   * than wait for the on-chain revert.
+   */
+  #validateVestingParams(params, where) {
+    if (!isAddress(params.recipient, { strict: true })) {
+      throw new InvalidArgumentError({
+        method: where,
+        argument: "recipient",
+        reason: "must be a valid EIP-55 checksummed address",
+        value: params.recipient
+      });
+    }
+    if (params.recipient === ZERO_ADDRESS) {
+      throw new InvalidArgumentError({
+        method: where,
+        argument: "recipient",
+        reason: "must not be the zero address"
+      });
+    }
+    if (params.startTimestamp >= params.endTimestamp) {
+      throw new InvalidArgumentError({
+        method: where,
+        argument: "startTimestamp/endTimestamp",
+        reason: "startTimestamp must be strictly less than endTimestamp",
+        value: { startTimestamp: params.startTimestamp, endTimestamp: params.endTimestamp }
+      });
+    }
+    if (params.startTimestamp + params.cliffSeconds > params.endTimestamp) {
+      throw new InvalidArgumentError({
+        method: where,
+        argument: "cliffSeconds",
+        reason: "cliff cannot extend past endTimestamp",
+        value: params.cliffSeconds
+      });
+    }
+    if (params.initialUnlockBps + params.cliffAmountBps > 1e4) {
+      throw new InvalidArgumentError({
+        method: where,
+        argument: "initialUnlockBps + cliffAmountBps",
+        reason: "must be \u2264 10000 (100%)",
+        value: { initialUnlockBps: params.initialUnlockBps, cliffAmountBps: params.cliffAmountBps }
+      });
+    }
+  }
+  async #read(functionName, args = []) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: confidentialVestingManagerAbi,
+      functionName,
+      args
+    });
+    return result;
+  }
+  /**
+   * Submit a tx for a function that performs `FHE.allow(handle, msg.sender)` and
+   * extract the granted handle from the receipt's ACL `Allowed` events. The
+   * "simulate first to get the return value" pattern would lie: when the
+   * function does FHE ops (`FHE.add` / `mul` / `sub` / …), each op produces a
+   * fresh handle bound to the *tx context*, so the simulate result diverges
+   * from what actually lands in ACL. Reading the event log is canonical.
+   */
+  async #encryptedView(functionName, args, accountOverride) {
+    const wallet = this.#requireWallet(functionName);
+    const account = this.#resolveAccount(wallet, accountOverride, functionName);
+    const vestingId = args[0];
+    let hash;
+    try {
+      hash = await wallet.writeContract({
+        address: this.address,
+        abi: confidentialVestingManagerAbi,
+        functionName,
+        args,
+        account,
+        chain: wallet.chain
+      });
+    } catch (err) {
+      throw this.#mapRevert(
+        functionName,
+        err,
+        vestingId ? { vestingId } : void 0,
+        accountAddress(account)
+      );
+    }
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const callerAddress = accountAddress(account).toLowerCase();
+    const aclLogs = receipt.logs.filter(
+      (log) => log.address.toLowerCase() === this.aclAddress.toLowerCase()
+    );
+    const events = parseEventLogs({ abi: [ACL_ALLOWED_EVENT], logs: aclLogs });
+    const granted = events.filter(
+      (ev) => ev.args.account.toLowerCase() === callerAddress && ev.args.caller.toLowerCase() === this.address.toLowerCase()
+    );
+    if (granted.length === 0) {
+      throw new ReceiptEventNotFoundError({
+        method: functionName,
+        eventName: "Allowed",
+        contractAddress: this.aclAddress,
+        txHash: hash,
+        hint: `Expected ACL grant from manager ${this.address} to caller ${callerAddress}; the contract did not grant decrypt access.`
+      });
+    }
+    if (granted.length > 1) {
+      throw new ReceiptEventAmbiguousError({
+        method: functionName,
+        eventName: "Allowed",
+        contractAddress: this.aclAddress,
+        txHash: hash,
+        count: granted.length
+      });
+    }
+    const handle = asEncryptedHandle(granted[0].args.handle);
+    return { handle, hash: asTxHash(hash) };
+  }
+};
+function createConfidentialVestingManagerClient(config) {
+  return new ConfidentialVestingManagerClient(config);
+}
+function accountAddress(account) {
+  return typeof account === "string" ? account : account.address;
+}
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+
+export { ClaimLockedError, ConfidentialVestingManagerClient, NoPendingTransferError, NotPendingRecipientError, NotVestingRecipientError, TransferAlreadyPendingError, TransferExpiredError, VestingExpiredError, VestingNotFoundError, VestingNotRevocableError, VestingRevokedError, confidentialVestingManagerAbi, createConfidentialVestingManagerClient, encryptUint64, encryptUint64Batch, resolveEncryptor };