@tokenops/sdk 1.0.0 → 1.5.1

package/dist/chunk-IJFQ5L4I.js

@@ -0,0 +1,2171 @@
+import { SDK_VERSION, isContractRevert, mapContractRevert } from './chunk-SG65XWH7.js';
+import { getConfidentialTestTokenAddress, getTestTokenAddress } from './chunk-XGGTQQFH.js';
+import { normaliseAddress } from './chunk-ZA673I3O.js';
+import { withTelemetry } from './chunk-Q2GP5UDC.js';
+import { asEncryptedHandle, asTxHash } from './chunk-KWFFIJYX.js';
+import { TokenOpsSdkError, UnsupportedChainError, DeploymentAddressUnavailableError, TokenOpsContractError, ReceiptEventNotFoundError, ReceiptEventAmbiguousError, MissingWalletClientError, MissingAccountError, InvalidArgumentError } from './chunk-QBJ7O2B4.js';
+import { sepolia } from 'viem/chains';
+import { parseEventLogs } from 'viem';
+
+// src/testnet-faucet/abis/confidential-test-token.ts
+var confidentialTokenopsTestTokenAbi = [
+  {
+    inputs: [],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "target",
+        type: "address"
+      }
+    ],
+    name: "AddressEmptyCode",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "implementation",
+        type: "address"
+      }
+    ],
+    name: "ERC1967InvalidImplementation",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC1967NonPayable",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      }
+    ],
+    name: "ERC7984InvalidReceiver",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      }
+    ],
+    name: "ERC7984InvalidReceiver",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "ERC7984InvalidSender",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC7984TotalSupplyOverflow",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "ERC7984UnauthorizedCaller",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "holder",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      }
+    ],
+    name: "ERC7984UnauthorizedSpender",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      },
+      {
+        internalType: "address",
+        name: "user",
+        type: "address"
+      }
+    ],
+    name: "ERC7984UnauthorizedUseOfEncryptedAmount",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "holder",
+        type: "address"
+      }
+    ],
+    name: "ERC7984ZeroBalance",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "FailedCall",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidInitialization",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidKMSSignatures",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      }
+    ],
+    name: "InvalidUnwrapRequest",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "NotInitializing",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      }
+    ],
+    name: "OwnableInvalidOwner",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "OwnableUnauthorizedAccount",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8",
+        name: "bits",
+        type: "uint8"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "SafeCastOverflowedUintDowncast",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "token",
+        type: "address"
+      }
+    ],
+    name: "SafeERC20FailedOperation",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "handle",
+        type: "bytes32"
+      },
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "SenderNotAllowedToUseHandle",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "UUPSUnauthorizedCallContext",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "slot",
+        type: "bytes32"
+      }
+    ],
+    name: "UUPSUnsupportedProxiableUUID",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ZamaProtocolUnsupported",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "requester",
+        type: "address"
+      }
+    ],
+    name: "AmountDiscloseRequested",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "amount",
+        type: "uint64"
+      }
+    ],
+    name: "AmountDisclosed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "underlyingMinted",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      }
+    ],
+    name: "ConfidentialMint",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      }
+    ],
+    name: "ConfidentialTransfer",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "version",
+        type: "uint64"
+      }
+    ],
+    name: "Initialized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "holder",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint48",
+        name: "until",
+        type: "uint48"
+      }
+    ],
+    name: "OperatorSet",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferStarted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "bytes32[]",
+        name: "handlesList",
+        type: "bytes32[]"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "abiEncodedCleartexts",
+        type: "bytes"
+      }
+    ],
+    name: "PublicDecryptionVerified",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "cleartextAmount",
+        type: "uint64"
+      }
+    ],
+    name: "UnwrapFinalized",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      }
+    ],
+    name: "UnwrapRequested",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "implementation",
+        type: "address"
+      }
+    ],
+    name: "Upgraded",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "roundedAmount",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "euint64",
+        name: "encryptedWrappedAmount",
+        type: "bytes32"
+      }
+    ],
+    name: "Wrap",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "UPGRADE_INTERFACE_VERSION",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "acceptOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "confidentialBalanceOf",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "confidentialProtocolId",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "confidentialTotalSupply",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "externalEuint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "inputProof",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransfer",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      }
+    ],
+    name: "confidentialTransfer",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransferAndCall",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "externalEuint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "inputProof",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransferAndCall",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "externalEuint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "inputProof",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransferFrom",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      }
+    ],
+    name: "confidentialTransferFrom",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "externalEuint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "inputProof",
+        type: "bytes"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransferFromAndCall",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "confidentialTransferFromAndCall",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "transferred",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "contractURI",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint64",
+        name: "cleartextAmount",
+        type: "uint64"
+      },
+      {
+        internalType: "bytes",
+        name: "decryptionProof",
+        type: "bytes"
+      }
+    ],
+    name: "discloseEncryptedAmount",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      },
+      {
+        internalType: "uint64",
+        name: "unwrapAmountCleartext",
+        type: "uint64"
+      },
+      {
+        internalType: "bytes",
+        name: "decryptionProof",
+        type: "bytes"
+      }
+    ],
+    name: "finalizeUnwrap",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "inferredTotalSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "name_",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "symbol_",
+        type: "string"
+      },
+      {
+        internalType: "string",
+        name: "contractURI_",
+        type: "string"
+      },
+      {
+        internalType: "contract IERC20",
+        name: "underlying_",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "owner_",
+        type: "address"
+      }
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "holder",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      }
+    ],
+    name: "isOperator",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "maxTotalSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint64",
+        name: "amount",
+        type: "uint64"
+      }
+    ],
+    name: "mint",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "minted",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "onTransferReceived",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pendingOwner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "proxiableUUID",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "rate",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "euint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      }
+    ],
+    name: "requestDiscloseEncryptedAmount",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        internalType: "uint48",
+        name: "until",
+        type: "uint48"
+      }
+    ],
+    name: "setOperator",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "underlying",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "externalEuint64",
+        name: "encryptedAmount",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "inputProof",
+        type: "bytes"
+      }
+    ],
+    name: "unwrap",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "euint64",
+        name: "amount",
+        type: "bytes32"
+      }
+    ],
+    name: "unwrap",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      }
+    ],
+    name: "unwrapAmount",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "unwrapRequestId",
+        type: "bytes32"
+      }
+    ],
+    name: "unwrapRequester",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newImplementation",
+        type: "address"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "upgradeToAndCall",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    name: "wrap",
+    outputs: [
+      {
+        internalType: "euint64",
+        name: "",
+        type: "bytes32"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/testnet-faucet/abis/test-token.ts
+var tokenopsTestTokenAbi = [
+  {
+    inputs: [],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "allowance",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "needed",
+        type: "uint256"
+      }
+    ],
+    name: "ERC20InsufficientAllowance",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "balance",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "needed",
+        type: "uint256"
+      }
+    ],
+    name: "ERC20InsufficientBalance",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "approver",
+        type: "address"
+      }
+    ],
+    name: "ERC20InvalidApprover",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "receiver",
+        type: "address"
+      }
+    ],
+    name: "ERC20InvalidReceiver",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "sender",
+        type: "address"
+      }
+    ],
+    name: "ERC20InvalidSender",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      }
+    ],
+    name: "ERC20InvalidSpender",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Approval",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "owner",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      }
+    ],
+    name: "allowance",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "spender",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "approve",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "account",
+        type: "address"
+      }
+    ],
+    name: "balanceOf",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "amount",
+        type: "uint256"
+      }
+    ],
+    name: "mint",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "name",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "symbol",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "transfer",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "transferFrom",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/testnet-faucet/errors.ts
+var FaucetSupplyExhaustedError = class extends TokenOpsSdkError {
+  name = "FaucetSupplyExhaustedError";
+  constructor(args) {
+    super(
+      `${args.method}: the confidential faucet's backing is saturated (max total supply reached). Unwrap existing CTTT to free capacity, or mint a smaller amount.`,
+      {
+        code: "TOKENOPS_FAUCET_SUPPLY_EXHAUSTED",
+        cause: args.cause,
+        context: { method: args.method, contractAddress: args.contractAddress }
+      }
+    );
+  }
+};
+var TESTNET_FAUCET_SUPPORTED_CHAIN_IDS = [sepolia.id, 31337];
+function isTestnetFaucetChainId(chainId) {
+  return TESTNET_FAUCET_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function assertTestnetFaucetChain(chainId) {
+  if (chainId === void 0) return;
+  if (!isTestnetFaucetChainId(chainId)) {
+    throw new UnsupportedChainError(chainId);
+  }
+}
+var UINT64_MAX = (1n << 64n) - 1n;
+var UINT256_MAX = (1n << 256n) - 1n;
+function assertUint64Amount(value, argument, method) {
+  if (typeof value !== "bigint") {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "amount must be a bigint",
+      value: String(value)
+    });
+  }
+  if (value <= 0n) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "amount must be greater than zero",
+      value: value.toString()
+    });
+  }
+  if (value > UINT64_MAX) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: `amount exceeds uint64 max (${UINT64_MAX.toString()})`,
+      value: value.toString()
+    });
+  }
+}
+function assertUint256Amount(value, argument, method) {
+  if (typeof value !== "bigint") {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "amount must be a bigint",
+      value: String(value)
+    });
+  }
+  if (value <= 0n) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "amount must be greater than zero",
+      value: value.toString()
+    });
+  }
+  if (value > UINT256_MAX) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "amount exceeds uint256 max",
+      value: value.toString()
+    });
+  }
+}
+function assertNonZeroRecipient(input, argument, method) {
+  const normalised = normaliseAddress(input);
+  if (/^0x0{40}$/i.test(normalised)) {
+    throw new InvalidArgumentError({
+      method,
+      argument,
+      reason: "recipient must not be the zero address",
+      value: normalised
+    });
+  }
+  return normalised;
+}
+var faucetProductMapper = (name, _args, ctx) => {
+  switch (name) {
+    case "ERC7984TotalSupplyOverflow":
+      return new FaucetSupplyExhaustedError({
+        method: ctx.method,
+        contractAddress: ctx.contractAddress
+      });
+    case "ERC7984InvalidReceiver":
+    case "ERC20InvalidReceiver":
+      return new InvalidArgumentError({
+        method: ctx.method,
+        argument: "to",
+        reason: "recipient must not be the zero address"
+      });
+    default:
+      return void 0;
+  }
+};
+var TestnetFaucetClient = class {
+  publicClient;
+  walletClient;
+  /** The `ConfidentialTokenopsTestToken` (CTTT) proxy address this client targets. */
+  address;
+  #chainId;
+  #cttAddressIsOverride = false;
+  #telemetry;
+  #cachedUnderlying;
+  constructor(config) {
+    this.publicClient = config.publicClient;
+    this.walletClient = config.walletClient;
+    this.#telemetry = config.telemetry;
+    const chainId = config.chainId ?? config.publicClient.chain?.id;
+    this.#chainId = chainId;
+    assertTestnetFaucetChain(chainId);
+    const addressOverride = config.address ? normaliseAddress(config.address) : void 0;
+    const resolved = addressOverride ?? (chainId === void 0 ? void 0 : getConfidentialTestTokenAddress(chainId));
+    if (!resolved) {
+      throw new DeploymentAddressUnavailableError({
+        reason: chainId === void 0 ? "chain-id-missing" : "registry-not-deployed",
+        product: "testnetFaucet",
+        contract: "confidentialTestToken",
+        chainId,
+        clientLabel: "TestnetFaucetClient"
+      });
+    }
+    this.address = resolved;
+    this.#cttAddressIsOverride = !!addressOverride;
+    this.#telemetry?.event("testnet-faucet.client.init", {
+      chainId: chainId ?? null,
+      hasWallet: !!this.walletClient,
+      sdkVersion: SDK_VERSION
+    });
+  }
+  // ============================================================
+  //                       READ METHODS
+  // ============================================================
+  /**
+   * Resolve the underlying `TokenopsTestToken` (TTT) address.
+   *
+   * Resolution order: registry entry for the chain → the wrapper's own
+   * `underlying()` getter (read once, cached). The wrapper is the authoritative
+   * source, so this works even on a local deployment where only the CTTT
+   * address was supplied.
+   *
+   * The registry shortcut is only taken for the canonical (registry) CTTT. If
+   * the CTTT `address` was overridden, the registry is skipped and the custom
+   * wrapper's own authoritative `underlying()` is read — otherwise a custom
+   * CTTT on a registry chain would silently pair with the canonical TTT. The
+   * backing token is never consumer-supplied: a faucet client always pairs the
+   * CTTT with the TTT that the CTTT itself reports.
+   */
+  async underlyingToken() {
+    if (this.#cachedUnderlying) return this.#cachedUnderlying;
+    const fromRegistry = this.#cttAddressIsOverride || this.#chainId === void 0 ? void 0 : getTestTokenAddress(this.#chainId);
+    const resolved = fromRegistry ?? await this.#readCtt("underlying");
+    this.#cachedUnderlying = normaliseAddress(resolved);
+    return this.#cachedUnderlying;
+  }
+  /**
+   * Read the encrypted confidential balance handle for `account` (defaults to
+   * the wallet's account).
+   *
+   * Returns the `euint64` ciphertext handle. The account holds persistent ACL
+   * on its own balance, so pass this handle — together with the CTTT contract
+   * address ({@link address}) and the account's signer — to the Zama relayer's
+   * `userDecrypt` to obtain the plaintext. The SDK is the producer side only;
+   * it does not call `userDecrypt`.
+   *
+   * @returns the `bytes32` balance handle (an {@link EncryptedHandle}). A
+   *   never-credited account reads back the zero handle.
+   */
+  async confidentialBalanceOf(account) {
+    const who = this.#resolveReadAddress(account, "confidentialBalanceOf");
+    const handle = await this.#readCtt("confidentialBalanceOf", [who]);
+    return asEncryptedHandle(handle);
+  }
+  /**
+   * Read the plaintext underlying `TokenopsTestToken` (TTT) balance for
+   * `account` (defaults to the wallet's account), in TTT 18-decimal base units.
+   */
+  async underlyingBalanceOf(account) {
+    const who = this.#resolveReadAddress(account, "underlyingBalanceOf");
+    return this.#readTtt("balanceOf", [who]);
+  }
+  /**
+   * Decimal-conversion rate between underlying and confidential units:
+   * `1` CTTT 6-decimal unit is backed by `rate` TTT 18-decimal base units
+   * (`10^(18-6) = 10^12`).
+   */
+  async rate() {
+    return this.#readCtt("rate");
+  }
+  /** Decimals of the confidential token (CTTT) — `6`. */
+  async decimals() {
+    return this.#readCtt("decimals");
+  }
+  /** Decimals of the underlying token (TTT) — `18`. */
+  async underlyingDecimals() {
+    return this.#readTtt("decimals");
+  }
+  /**
+   * The wrapper's inferred total supply: underlying held in custody divided by
+   * `rate`, an upper bound on the confidential total supply. In CTTT 6-decimal
+   * units.
+   */
+  async inferredTotalSupply() {
+    return this.#readCtt("inferredTotalSupply");
+  }
+  /** Max confidential total supply the wrapper supports (`type(uint64).max`). */
+  async maxTotalSupply() {
+    return this.#readCtt("maxTotalSupply");
+  }
+  /**
+   * Consolidated faucet metadata — both tokens' name/symbol/decimals/address,
+   * the conversion `rate`, and the `maxTotalSupply` ceiling — in a single
+   * parallel read. Handy for rendering a faucet panel.
+   */
+  async getMetadata() {
+    const underlyingAddress = await this.underlyingToken();
+    const [cName, cSymbol, cDecimals, rate, maxTotalSupply, uName, uSymbol, uDecimals] = await Promise.all([
+      this.#readCtt("name"),
+      this.#readCtt("symbol"),
+      this.#readCtt("decimals"),
+      this.#readCtt("rate"),
+      this.#readCtt("maxTotalSupply"),
+      this.#readTtt("name"),
+      this.#readTtt("symbol"),
+      this.#readTtt("decimals")
+    ]);
+    return {
+      confidential: { address: this.address, name: cName, symbol: cSymbol, decimals: cDecimals },
+      underlying: {
+        address: underlyingAddress,
+        name: uName,
+        symbol: uSymbol,
+        decimals: uDecimals
+      },
+      rate,
+      maxTotalSupply
+    };
+  }
+  // ============================================================
+  //                       WRITE METHODS
+  // ============================================================
+  /**
+   * Mint confidential test tokens (CTTT) to `to`, fully backed by freshly
+   * minted underlying TTT held in custody.
+   *
+   * **This is the confidential faucet.** Open and permissionless — anyone can
+   * mint any `uint64` amount. The amount is PUBLIC (plaintext calldata +
+   * `ConfidentialMint` event); only the recipient's aggregated balance and
+   * later confidential transfers are private.
+   *
+   * @returns `{ hash, to, amount, underlyingMinted, handle }` decoded from the
+   *   `ConfidentialMint` event. To read the recipient's plaintext balance,
+   *   call {@link confidentialBalanceOf} and user-decrypt it.
+   * @throws {InvalidArgumentError} for a zero recipient or out-of-range amount.
+   * @throws {FaucetSupplyExhaustedError} if the wrapper's backing ceiling is reached.
+   * @throws {ReceiptEventNotFoundError} if no `ConfidentialMint` event is found.
+   */
+  async mintConfidential(args) {
+    return withTelemetry(this.#telemetry, "testnet-faucet.mintConfidential", async () => {
+      const wallet = this.#requireWallet("mintConfidential");
+      const account = this.#resolveAccount(wallet, args.account, "mintConfidential");
+      const to = assertNonZeroRecipient(
+        args.to ?? accountAddress(account),
+        "to",
+        "mintConfidential"
+      );
+      assertUint64Amount(args.amount, "amount", "mintConfidential");
+      const target = this.#cttTarget();
+      await this.#preflightWrite(target, "mintConfidential", "mint", [to, args.amount], account);
+      let hash;
+      try {
+        hash = await wallet.writeContract({
+          address: target.address,
+          abi: target.abi,
+          functionName: "mint",
+          args: [to, args.amount],
+          account,
+          chain: wallet.chain
+        });
+      } catch (err) {
+        throw this.#mapRevert(target, "mintConfidential", err, void 0, accountAddress(account));
+      }
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      if (receipt.status !== "success") {
+        throw new TokenOpsContractError(`mintConfidential: transaction ${hash} reverted`, {
+          contract: "ConfidentialTokenopsTestToken",
+          call: "mint",
+          tx: hash
+        });
+      }
+      const events = parseEventLogs({
+        abi: confidentialTokenopsTestTokenAbi,
+        eventName: "ConfidentialMint",
+        logs: receipt.logs
+      });
+      const ours = events.filter((ev2) => ev2.address.toLowerCase() === this.address.toLowerCase());
+      if (ours.length === 0) {
+        throw new ReceiptEventNotFoundError({
+          method: "mintConfidential",
+          eventName: "ConfidentialMint",
+          contractAddress: this.address,
+          txHash: hash
+        });
+      }
+      if (ours.length > 1) {
+        throw new ReceiptEventAmbiguousError({
+          method: "mintConfidential",
+          eventName: "ConfidentialMint",
+          contractAddress: this.address,
+          txHash: hash,
+          count: ours.length
+        });
+      }
+      const ev = ours[0];
+      return {
+        hash: asTxHash(hash),
+        to: ev.args.to,
+        amount: args.amount,
+        underlyingMinted: ev.args.underlyingMinted,
+        handle: asEncryptedHandle(ev.args.encryptedAmount)
+      };
+    });
+  }
+  /**
+   * Mint standard (non-confidential) ERC-20 test tokens (TTT) to `to`.
+   *
+   * Open and permissionless. Use this when you want plain TTT — e.g. to then
+   * `approve` + `wrap` it into CTTT through the standard ERC-7984 flow.
+   *
+   * @returns `{ hash, to, amount }`.
+   * @throws {InvalidArgumentError} for a zero recipient or out-of-range amount.
+   */
+  async mintUnderlying(args) {
+    return withTelemetry(this.#telemetry, "testnet-faucet.mintUnderlying", async () => {
+      const wallet = this.#requireWallet("mintUnderlying");
+      const account = this.#resolveAccount(wallet, args.account, "mintUnderlying");
+      const to = assertNonZeroRecipient(args.to ?? accountAddress(account), "to", "mintUnderlying");
+      assertUint256Amount(args.amount, "amount", "mintUnderlying");
+      const target = {
+        address: await this.underlyingToken(),
+        abi: tokenopsTestTokenAbi
+      };
+      await this.#preflightWrite(target, "mintUnderlying", "mint", [to, args.amount], account);
+      let hash;
+      try {
+        hash = await wallet.writeContract({
+          address: target.address,
+          abi: target.abi,
+          functionName: "mint",
+          args: [to, args.amount],
+          account,
+          chain: wallet.chain
+        });
+      } catch (err) {
+        throw this.#mapRevert(target, "mintUnderlying", err, void 0, accountAddress(account));
+      }
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+      if (receipt.status !== "success") {
+        throw new TokenOpsContractError(`mintUnderlying: transaction ${hash} reverted`, {
+          contract: "TokenopsTestToken",
+          call: "mint",
+          tx: hash
+        });
+      }
+      return { hash: asTxHash(hash), to, amount: args.amount };
+    });
+  }
+  // ============================================================
+  //                       INTERNAL HELPERS
+  // ============================================================
+  #cttTarget() {
+    return { address: this.address, abi: confidentialTokenopsTestTokenAbi };
+  }
+  #requireWallet(method) {
+    if (!this.walletClient) {
+      throw new MissingWalletClientError(method);
+    }
+    return this.walletClient;
+  }
+  #resolveAccount(wallet, override, method) {
+    const acct = override ?? wallet.account;
+    if (!acct) {
+      throw new MissingAccountError(method);
+    }
+    return acct;
+  }
+  /**
+   * Resolve the address a read targets. Uses the explicit `override` if given,
+   * else the wallet's account address. Throws {@link MissingAccountError} when
+   * neither is available (a read-only client must be told whose balance to read).
+   */
+  #resolveReadAddress(override, method) {
+    if (override) return normaliseAddress(override);
+    const acct = this.walletClient?.account?.address;
+    if (!acct) {
+      throw new MissingAccountError(method);
+    }
+    return acct;
+  }
+  async #readCtt(functionName, args = []) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: confidentialTokenopsTestTokenAbi,
+      functionName,
+      args
+    });
+    return result;
+  }
+  async #readTtt(functionName, args = []) {
+    const address = await this.underlyingToken();
+    const result = await this.publicClient.readContract({
+      address,
+      abi: tokenopsTestTokenAbi,
+      functionName,
+      args
+    });
+    return result;
+  }
+  /**
+   * Pre-flight a write via `simulateContract` purely to surface typed reverts.
+   * The simulate's return value is discarded; only its revert-decoding side
+   * effect matters (so role/state/overflow reverts classify into typed SDK
+   * errors instead of `UnknownWriteFailureError` on wallet transports).
+   */
+  async #preflightWrite(target, method, functionName, args, account) {
+    try {
+      await this.publicClient.simulateContract({
+        address: target.address,
+        abi: target.abi,
+        functionName,
+        args,
+        account
+      });
+    } catch (err) {
+      if (isContractRevert(err)) {
+        throw this.#mapRevert(target, method, err, void 0, accountAddress(account));
+      }
+    }
+  }
+  #mapRevert(target, method, err, productContext, account) {
+    return mapContractRevert(err, {
+      method,
+      contractAddress: target.address,
+      abi: target.abi,
+      productMapper: faucetProductMapper,
+      productContext,
+      account
+    });
+  }
+};
+function createTestnetFaucetClient(config) {
+  return new TestnetFaucetClient(config);
+}
+function accountAddress(account) {
+  return typeof account === "string" ? account : account.address;
+}
+
+export { FaucetSupplyExhaustedError, TESTNET_FAUCET_SUPPORTED_CHAIN_IDS, TestnetFaucetClient, assertTestnetFaucetChain, confidentialTokenopsTestTokenAbi, createTestnetFaucetClient, isTestnetFaucetChainId, tokenopsTestTokenAbi };