@kwespay/widget 1.0.8 → 1.0.9

package/dist/esm/index-Bd9oDICQ.js

@@ -0,0 +1,3085 @@
+class KwesPayError extends Error {
+    constructor(message, code, cause) {
+        super(message);
+        this.name = "KwesPayError";
+        this.code = code;
+        this.cause = cause;
+    }
+}
+
+const ENDPOINT = "https://f433-154-161-230-28.ngrok-free.app/graphql";
+const TESTNET_CONTRACTS = {
+    sepolia: "0xFC0A3A00008B79f080648A12FFb07dDE3C34F789",
+    baseSepolia: "0x8662EEA4eACCAef3e5c33c50Ac3a2b9B1B0033c7",
+    polygonAmoy: "0xc46E4D2005014990F600741A2Ce189f8118CB58e",
+    liskTestnet: "0xe0daD0d9e7413AA06859d26A552fD6a07855B070",
+    mezoTestnet: "0xa430B2e0D1273464809f8541286058e90781DA9C",
+};
+const MAINNET_CONTRACTS = {
+// lisk: "0x...",
+};
+const CONTRACT_ADDRESSES = {
+    ...TESTNET_CONTRACTS,
+    ...MAINNET_CONTRACTS,
+};
+function resolveContractAddress(network) {
+    const addr = CONTRACT_ADDRESSES[network];
+    if (!addr)
+        throw new Error(`No contract deployed on network: ${network}`);
+    return addr;
+}
+
+async function gqlRequest(query, variables, apiKey) {
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (apiKey)
+        headers["X-API-Key"] = apiKey;
+    let response;
+    try {
+        response = await fetch(ENDPOINT, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ query, variables }),
+        });
+    }
+    catch (err) {
+        throw new KwesPayError("Network request failed — check your connectivity", "NETWORK_ERROR", err);
+    }
+    if (!response.ok) {
+        throw new KwesPayError(`HTTP ${response.status}: ${response.statusText}`, "NETWORK_ERROR");
+    }
+    const json = await response.json();
+    if (json.errors?.length) {
+        throw new KwesPayError(json.errors[0]?.message ?? "GraphQL error", "UNKNOWN");
+    }
+    if (!json.data) {
+        throw new KwesPayError("Empty response from server", "UNKNOWN");
+    }
+    return json.data;
+}
+
+const GQL_VALIDATE_KEY = `
+  query ValidateAccessKey($accessKey: String!) {
+    validateAccessKey(accessKey: $accessKey) {
+      isValid
+      keyId
+      keyLabel
+      activeFlag
+      expirationDate
+      vendorInfo {
+        vendorPk
+        vendorIdentifier
+        businessName
+      }
+      allowedVendors
+      allowedNetworks
+      allowedTokens
+      error
+    }
+  }
+`;
+const GQL_CREATE_QUOTE = `
+  mutation CreateQuote($input: CreateQuoteInput!) {
+    createQuote(input: $input) {
+      success
+      message
+      quoteId
+      quoteReference
+      cryptoCurrency
+      tokenAddress
+      amountBaseUnits
+      displayAmount
+      network
+      chainId
+      expiresAt
+    }
+  }
+`;
+// deadline is NOT queried — derived from expiresAt (same point in time, Unix int).
+// Add `deadline` back here after the backend schema is regenerated with the
+// updated BlockchainTransactionResponse type.
+const GQL_CREATE_TRANSACTION = `
+  mutation CreateTransaction($input: CreateTransactionInput!) {
+    createTransaction(input: $input) {
+      success
+      message
+      paymentIdBytes32
+      backendSignature
+      tokenAddress
+      amountBaseUnits
+      chainId
+      expiresAt
+      transaction {
+        transactionReference
+        transactionStatus
+      }
+    }
+  }
+`;
+const GQL_TRANSACTION_STATUS = `
+  query GetTransactionStatus($transactionReference: String!) {
+    getTransactionStatus(transactionReference: $transactionReference) {
+      transactionReference
+      transactionStatus
+      blockchainHash
+      blockchainNetwork
+      displayAmount
+      cryptoCurrency
+      payerWalletAddress
+      initiatedAt
+    }
+  }
+`;
+
+const version$1 = '1.2.3';
+
+let BaseError$1 = class BaseError extends Error {
+    constructor(shortMessage, args = {}) {
+        const details = args.cause instanceof BaseError
+            ? args.cause.details
+            : args.cause?.message
+                ? args.cause.message
+                : args.details;
+        const docsPath = args.cause instanceof BaseError
+            ? args.cause.docsPath || args.docsPath
+            : args.docsPath;
+        const message = [
+            shortMessage || 'An error occurred.',
+            '',
+            ...(args.metaMessages ? [...args.metaMessages, ''] : []),
+            ...(docsPath ? [`Docs: https://abitype.dev${docsPath}`] : []),
+            ...(details ? [`Details: ${details}`] : []),
+            `Version: abitype@${version$1}`,
+        ].join('\n');
+        super(message);
+        Object.defineProperty(this, "details", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiTypeError'
+        });
+        if (args.cause)
+            this.cause = args.cause;
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.shortMessage = shortMessage;
+    }
+};
+
+// TODO: This looks cool. Need to check the performance of `new RegExp` versus defined inline though.
+// https://twitter.com/GabrielVergnaud/status/1622906834343366657
+function execTyped(regex, string) {
+    const match = regex.exec(string);
+    return match?.groups;
+}
+// `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+// https://regexr.com/6va55
+const bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
+// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+// https://regexr.com/6v8hp
+const integerRegex$1 = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+const isTupleRegex = /^\(.+?\).*?$/;
+
+// https://regexr.com/7f7rv
+const tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
+/**
+ * Formats {@link AbiParameter} to human-readable ABI parameter.
+ *
+ * @param abiParameter - ABI parameter
+ * @returns Human-readable ABI parameter
+ *
+ * @example
+ * const result = formatAbiParameter({ type: 'address', name: 'from' })
+ * //    ^? const result: 'address from'
+ */
+function formatAbiParameter(abiParameter) {
+    let type = abiParameter.type;
+    if (tupleRegex.test(abiParameter.type) && 'components' in abiParameter) {
+        type = '(';
+        const length = abiParameter.components.length;
+        for (let i = 0; i < length; i++) {
+            const component = abiParameter.components[i];
+            type += formatAbiParameter(component);
+            if (i < length - 1)
+                type += ', ';
+        }
+        const result = execTyped(tupleRegex, abiParameter.type);
+        type += `)${result?.array || ''}`;
+        return formatAbiParameter({
+            ...abiParameter,
+            type,
+        });
+    }
+    // Add `indexed` to type if in `abiParameter`
+    if ('indexed' in abiParameter && abiParameter.indexed)
+        type = `${type} indexed`;
+    // Return human-readable ABI parameter
+    if (abiParameter.name)
+        return `${type} ${abiParameter.name}`;
+    return type;
+}
+
+/**
+ * Formats {@link AbiParameter}s to human-readable ABI parameters.
+ *
+ * @param abiParameters - ABI parameters
+ * @returns Human-readable ABI parameters
+ *
+ * @example
+ * const result = formatAbiParameters([
+ *   //  ^? const result: 'address from, uint256 tokenId'
+ *   { type: 'address', name: 'from' },
+ *   { type: 'uint256', name: 'tokenId' },
+ * ])
+ */
+function formatAbiParameters(abiParameters) {
+    let params = '';
+    const length = abiParameters.length;
+    for (let i = 0; i < length; i++) {
+        const abiParameter = abiParameters[i];
+        params += formatAbiParameter(abiParameter);
+        if (i !== length - 1)
+            params += ', ';
+    }
+    return params;
+}
+
+/**
+ * Formats ABI item (e.g. error, event, function) into human-readable ABI item
+ *
+ * @param abiItem - ABI item
+ * @returns Human-readable ABI item
+ */
+function formatAbiItem$1(abiItem) {
+    if (abiItem.type === 'function')
+        return `function ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability && abiItem.stateMutability !== 'nonpayable'
+            ? ` ${abiItem.stateMutability}`
+            : ''}${abiItem.outputs?.length
+            ? ` returns (${formatAbiParameters(abiItem.outputs)})`
+            : ''}`;
+    if (abiItem.type === 'event')
+        return `event ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+    if (abiItem.type === 'error')
+        return `error ${abiItem.name}(${formatAbiParameters(abiItem.inputs)})`;
+    if (abiItem.type === 'constructor')
+        return `constructor(${formatAbiParameters(abiItem.inputs)})${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
+    if (abiItem.type === 'fallback')
+        return `fallback() external${abiItem.stateMutability === 'payable' ? ' payable' : ''}`;
+    return 'receive() external payable';
+}
+
+// https://regexr.com/7gmok
+const errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isErrorSignature(signature) {
+    return errorSignatureRegex.test(signature);
+}
+function execErrorSignature(signature) {
+    return execTyped(errorSignatureRegex, signature);
+}
+// https://regexr.com/7gmoq
+const eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
+function isEventSignature(signature) {
+    return eventSignatureRegex.test(signature);
+}
+function execEventSignature(signature) {
+    return execTyped(eventSignatureRegex, signature);
+}
+// https://regexr.com/7gmot
+const functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
+function isFunctionSignature(signature) {
+    return functionSignatureRegex.test(signature);
+}
+function execFunctionSignature(signature) {
+    return execTyped(functionSignatureRegex, signature);
+}
+// https://regexr.com/7gmp3
+const structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
+function isStructSignature(signature) {
+    return structSignatureRegex.test(signature);
+}
+function execStructSignature(signature) {
+    return execTyped(structSignatureRegex, signature);
+}
+// https://regexr.com/78u01
+const constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
+function isConstructorSignature(signature) {
+    return constructorSignatureRegex.test(signature);
+}
+function execConstructorSignature(signature) {
+    return execTyped(constructorSignatureRegex, signature);
+}
+// https://regexr.com/7srtn
+const fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
+function isFallbackSignature(signature) {
+    return fallbackSignatureRegex.test(signature);
+}
+function execFallbackSignature(signature) {
+    return execTyped(fallbackSignatureRegex, signature);
+}
+// https://regexr.com/78u1k
+const receiveSignatureRegex = /^receive\(\) external payable$/;
+function isReceiveSignature(signature) {
+    return receiveSignatureRegex.test(signature);
+}
+const eventModifiers = new Set(['indexed']);
+const functionModifiers = new Set([
+    'calldata',
+    'memory',
+    'storage',
+]);
+
+class UnknownTypeError extends BaseError$1 {
+    constructor({ type }) {
+        super('Unknown type.', {
+            metaMessages: [
+                `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`,
+            ],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'UnknownTypeError'
+        });
+    }
+}
+class UnknownSolidityTypeError extends BaseError$1 {
+    constructor({ type }) {
+        super('Unknown type.', {
+            metaMessages: [`Type "${type}" is not a valid ABI type.`],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'UnknownSolidityTypeError'
+        });
+    }
+}
+
+class InvalidParameterError extends BaseError$1 {
+    constructor({ param }) {
+        super('Invalid ABI parameter.', {
+            details: param,
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidParameterError'
+        });
+    }
+}
+class SolidityProtectedKeywordError extends BaseError$1 {
+    constructor({ param, name }) {
+        super('Invalid ABI parameter.', {
+            details: param,
+            metaMessages: [
+                `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`,
+            ],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'SolidityProtectedKeywordError'
+        });
+    }
+}
+class InvalidModifierError extends BaseError$1 {
+    constructor({ param, type, modifier, }) {
+        super('Invalid ABI parameter.', {
+            details: param,
+            metaMessages: [
+                `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ''}.`,
+            ],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidModifierError'
+        });
+    }
+}
+class InvalidFunctionModifierError extends BaseError$1 {
+    constructor({ param, type, modifier, }) {
+        super('Invalid ABI parameter.', {
+            details: param,
+            metaMessages: [
+                `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ''}.`,
+                `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`,
+            ],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidFunctionModifierError'
+        });
+    }
+}
+class InvalidAbiTypeParameterError extends BaseError$1 {
+    constructor({ abiParameter, }) {
+        super('Invalid ABI parameter.', {
+            details: JSON.stringify(abiParameter, null, 2),
+            metaMessages: ['ABI parameter type is invalid.'],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidAbiTypeParameterError'
+        });
+    }
+}
+
+class InvalidSignatureError extends BaseError$1 {
+    constructor({ signature, type, }) {
+        super(`Invalid ${type} signature.`, {
+            details: signature,
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidSignatureError'
+        });
+    }
+}
+class UnknownSignatureError extends BaseError$1 {
+    constructor({ signature }) {
+        super('Unknown signature.', {
+            details: signature,
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'UnknownSignatureError'
+        });
+    }
+}
+class InvalidStructSignatureError extends BaseError$1 {
+    constructor({ signature }) {
+        super('Invalid struct signature.', {
+            details: signature,
+            metaMessages: ['No properties exist.'],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidStructSignatureError'
+        });
+    }
+}
+
+class CircularReferenceError extends BaseError$1 {
+    constructor({ type }) {
+        super('Circular reference detected.', {
+            metaMessages: [`Struct "${type}" is a circular reference.`],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'CircularReferenceError'
+        });
+    }
+}
+
+class InvalidParenthesisError extends BaseError$1 {
+    constructor({ current, depth }) {
+        super('Unbalanced parentheses.', {
+            metaMessages: [
+                `"${current.trim()}" has too many ${depth > 0 ? 'opening' : 'closing'} parentheses.`,
+            ],
+            details: `Depth "${depth}"`,
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'InvalidParenthesisError'
+        });
+    }
+}
+
+/**
+ * Gets {@link parameterCache} cache key namespaced by {@link type} and {@link structs}. This prevents parameters from being accessible to types that don't allow them (e.g. `string indexed foo` not allowed outside of `type: 'event'`) and ensures different struct definitions with the same name are cached separately.
+ * @param param ABI parameter string
+ * @param type ABI parameter type
+ * @param structs Struct definitions to include in cache key
+ * @returns Cache key for {@link parameterCache}
+ */
+function getParameterCacheKey(param, type, structs) {
+    let structKey = '';
+    if (structs)
+        for (const struct of Object.entries(structs)) {
+            if (!struct)
+                continue;
+            let propertyKey = '';
+            for (const property of struct[1]) {
+                propertyKey += `[${property.type}${property.name ? `:${property.name}` : ''}]`;
+            }
+            structKey += `(${struct[0]}{${propertyKey}})`;
+        }
+    if (type)
+        return `${type}:${param}${structKey}`;
+    return `${param}${structKey}`;
+}
+/**
+ * Basic cache seeded with common ABI parameter strings.
+ *
+ * **Note: When seeding more parameters, make sure you benchmark performance. The current number is the ideal balance between performance and having an already existing cache.**
+ */
+const parameterCache = new Map([
+    // Unnamed
+    ['address', { type: 'address' }],
+    ['bool', { type: 'bool' }],
+    ['bytes', { type: 'bytes' }],
+    ['bytes32', { type: 'bytes32' }],
+    ['int', { type: 'int256' }],
+    ['int256', { type: 'int256' }],
+    ['string', { type: 'string' }],
+    ['uint', { type: 'uint256' }],
+    ['uint8', { type: 'uint8' }],
+    ['uint16', { type: 'uint16' }],
+    ['uint24', { type: 'uint24' }],
+    ['uint32', { type: 'uint32' }],
+    ['uint64', { type: 'uint64' }],
+    ['uint96', { type: 'uint96' }],
+    ['uint112', { type: 'uint112' }],
+    ['uint160', { type: 'uint160' }],
+    ['uint192', { type: 'uint192' }],
+    ['uint256', { type: 'uint256' }],
+    // Named
+    ['address owner', { type: 'address', name: 'owner' }],
+    ['address to', { type: 'address', name: 'to' }],
+    ['bool approved', { type: 'bool', name: 'approved' }],
+    ['bytes _data', { type: 'bytes', name: '_data' }],
+    ['bytes data', { type: 'bytes', name: 'data' }],
+    ['bytes signature', { type: 'bytes', name: 'signature' }],
+    ['bytes32 hash', { type: 'bytes32', name: 'hash' }],
+    ['bytes32 r', { type: 'bytes32', name: 'r' }],
+    ['bytes32 root', { type: 'bytes32', name: 'root' }],
+    ['bytes32 s', { type: 'bytes32', name: 's' }],
+    ['string name', { type: 'string', name: 'name' }],
+    ['string symbol', { type: 'string', name: 'symbol' }],
+    ['string tokenURI', { type: 'string', name: 'tokenURI' }],
+    ['uint tokenId', { type: 'uint256', name: 'tokenId' }],
+    ['uint8 v', { type: 'uint8', name: 'v' }],
+    ['uint256 balance', { type: 'uint256', name: 'balance' }],
+    ['uint256 tokenId', { type: 'uint256', name: 'tokenId' }],
+    ['uint256 value', { type: 'uint256', name: 'value' }],
+    // Indexed
+    [
+        'event:address indexed from',
+        { type: 'address', name: 'from', indexed: true },
+    ],
+    ['event:address indexed to', { type: 'address', name: 'to', indexed: true }],
+    [
+        'event:uint indexed tokenId',
+        { type: 'uint256', name: 'tokenId', indexed: true },
+    ],
+    [
+        'event:uint256 indexed tokenId',
+        { type: 'uint256', name: 'tokenId', indexed: true },
+    ],
+]);
+
+function parseSignature(signature, structs = {}) {
+    if (isFunctionSignature(signature))
+        return parseFunctionSignature(signature, structs);
+    if (isEventSignature(signature))
+        return parseEventSignature(signature, structs);
+    if (isErrorSignature(signature))
+        return parseErrorSignature(signature, structs);
+    if (isConstructorSignature(signature))
+        return parseConstructorSignature(signature, structs);
+    if (isFallbackSignature(signature))
+        return parseFallbackSignature(signature);
+    if (isReceiveSignature(signature))
+        return {
+            type: 'receive',
+            stateMutability: 'payable',
+        };
+    throw new UnknownSignatureError({ signature });
+}
+function parseFunctionSignature(signature, structs = {}) {
+    const match = execFunctionSignature(signature);
+    if (!match)
+        throw new InvalidSignatureError({ signature, type: 'function' });
+    const inputParams = splitParameters(match.parameters);
+    const inputs = [];
+    const inputLength = inputParams.length;
+    for (let i = 0; i < inputLength; i++) {
+        inputs.push(parseAbiParameter(inputParams[i], {
+            modifiers: functionModifiers,
+            structs,
+            type: 'function',
+        }));
+    }
+    const outputs = [];
+    if (match.returns) {
+        const outputParams = splitParameters(match.returns);
+        const outputLength = outputParams.length;
+        for (let i = 0; i < outputLength; i++) {
+            outputs.push(parseAbiParameter(outputParams[i], {
+                modifiers: functionModifiers,
+                structs,
+                type: 'function',
+            }));
+        }
+    }
+    return {
+        name: match.name,
+        type: 'function',
+        stateMutability: match.stateMutability ?? 'nonpayable',
+        inputs,
+        outputs,
+    };
+}
+function parseEventSignature(signature, structs = {}) {
+    const match = execEventSignature(signature);
+    if (!match)
+        throw new InvalidSignatureError({ signature, type: 'event' });
+    const params = splitParameters(match.parameters);
+    const abiParameters = [];
+    const length = params.length;
+    for (let i = 0; i < length; i++)
+        abiParameters.push(parseAbiParameter(params[i], {
+            modifiers: eventModifiers,
+            structs,
+            type: 'event',
+        }));
+    return { name: match.name, type: 'event', inputs: abiParameters };
+}
+function parseErrorSignature(signature, structs = {}) {
+    const match = execErrorSignature(signature);
+    if (!match)
+        throw new InvalidSignatureError({ signature, type: 'error' });
+    const params = splitParameters(match.parameters);
+    const abiParameters = [];
+    const length = params.length;
+    for (let i = 0; i < length; i++)
+        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'error' }));
+    return { name: match.name, type: 'error', inputs: abiParameters };
+}
+function parseConstructorSignature(signature, structs = {}) {
+    const match = execConstructorSignature(signature);
+    if (!match)
+        throw new InvalidSignatureError({ signature, type: 'constructor' });
+    const params = splitParameters(match.parameters);
+    const abiParameters = [];
+    const length = params.length;
+    for (let i = 0; i < length; i++)
+        abiParameters.push(parseAbiParameter(params[i], { structs, type: 'constructor' }));
+    return {
+        type: 'constructor',
+        stateMutability: match.stateMutability ?? 'nonpayable',
+        inputs: abiParameters,
+    };
+}
+function parseFallbackSignature(signature) {
+    const match = execFallbackSignature(signature);
+    if (!match)
+        throw new InvalidSignatureError({ signature, type: 'fallback' });
+    return {
+        type: 'fallback',
+        stateMutability: match.stateMutability ?? 'nonpayable',
+    };
+}
+const abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*(?:\spayable)?)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+const abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
+const dynamicIntegerRegex = /^u?int$/;
+function parseAbiParameter(param, options) {
+    // optional namespace cache by `type`
+    const parameterCacheKey = getParameterCacheKey(param, options?.type, options?.structs);
+    if (parameterCache.has(parameterCacheKey))
+        return parameterCache.get(parameterCacheKey);
+    const isTuple = isTupleRegex.test(param);
+    const match = execTyped(isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex, param);
+    if (!match)
+        throw new InvalidParameterError({ param });
+    if (match.name && isSolidityKeyword(match.name))
+        throw new SolidityProtectedKeywordError({ param, name: match.name });
+    const name = match.name ? { name: match.name } : {};
+    const indexed = match.modifier === 'indexed' ? { indexed: true } : {};
+    const structs = options?.structs ?? {};
+    let type;
+    let components = {};
+    if (isTuple) {
+        type = 'tuple';
+        const params = splitParameters(match.type);
+        const components_ = [];
+        const length = params.length;
+        for (let i = 0; i < length; i++) {
+            // remove `modifiers` from `options` to prevent from being added to tuple components
+            components_.push(parseAbiParameter(params[i], { structs }));
+        }
+        components = { components: components_ };
+    }
+    else if (match.type in structs) {
+        type = 'tuple';
+        components = { components: structs[match.type] };
+    }
+    else if (dynamicIntegerRegex.test(match.type)) {
+        type = `${match.type}256`;
+    }
+    else if (match.type === 'address payable') {
+        type = 'address';
+    }
+    else {
+        type = match.type;
+        if (!(options?.type === 'struct') && !isSolidityType(type))
+            throw new UnknownSolidityTypeError({ type });
+    }
+    if (match.modifier) {
+        // Check if modifier exists, but is not allowed (e.g. `indexed` in `functionModifiers`)
+        if (!options?.modifiers?.has?.(match.modifier))
+            throw new InvalidModifierError({
+                param,
+                type: options?.type,
+                modifier: match.modifier,
+            });
+        // Check if resolved `type` is valid if there is a function modifier
+        if (functionModifiers.has(match.modifier) &&
+            !isValidDataLocation(type, !!match.array))
+            throw new InvalidFunctionModifierError({
+                param,
+                type: options?.type,
+                modifier: match.modifier,
+            });
+    }
+    const abiParameter = {
+        type: `${type}${match.array ?? ''}`,
+        ...name,
+        ...indexed,
+        ...components,
+    };
+    parameterCache.set(parameterCacheKey, abiParameter);
+    return abiParameter;
+}
+// s/o latika for this
+function splitParameters(params, result = [], current = '', depth = 0) {
+    const length = params.trim().length;
+    // biome-ignore lint/correctness/noUnreachable: recursive
+    for (let i = 0; i < length; i++) {
+        const char = params[i];
+        const tail = params.slice(i + 1);
+        switch (char) {
+            case ',':
+                return depth === 0
+                    ? splitParameters(tail, [...result, current.trim()])
+                    : splitParameters(tail, result, `${current}${char}`, depth);
+            case '(':
+                return splitParameters(tail, result, `${current}${char}`, depth + 1);
+            case ')':
+                return splitParameters(tail, result, `${current}${char}`, depth - 1);
+            default:
+                return splitParameters(tail, result, `${current}${char}`, depth);
+        }
+    }
+    if (current === '')
+        return result;
+    if (depth !== 0)
+        throw new InvalidParenthesisError({ current, depth });
+    result.push(current.trim());
+    return result;
+}
+function isSolidityType(type) {
+    return (type === 'address' ||
+        type === 'bool' ||
+        type === 'function' ||
+        type === 'string' ||
+        bytesRegex.test(type) ||
+        integerRegex$1.test(type));
+}
+const protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;
+/** @internal */
+function isSolidityKeyword(name) {
+    return (name === 'address' ||
+        name === 'bool' ||
+        name === 'function' ||
+        name === 'string' ||
+        name === 'tuple' ||
+        bytesRegex.test(name) ||
+        integerRegex$1.test(name) ||
+        protectedKeywordsRegex.test(name));
+}
+/** @internal */
+function isValidDataLocation(type, isArray) {
+    return isArray || type === 'bytes' || type === 'string' || type === 'tuple';
+}
+
+function parseStructs(signatures) {
+    // Create "shallow" version of each struct (and filter out non-structs or invalid structs)
+    const shallowStructs = {};
+    const signaturesLength = signatures.length;
+    for (let i = 0; i < signaturesLength; i++) {
+        const signature = signatures[i];
+        if (!isStructSignature(signature))
+            continue;
+        const match = execStructSignature(signature);
+        if (!match)
+            throw new InvalidSignatureError({ signature, type: 'struct' });
+        const properties = match.properties.split(';');
+        const components = [];
+        const propertiesLength = properties.length;
+        for (let k = 0; k < propertiesLength; k++) {
+            const property = properties[k];
+            const trimmed = property.trim();
+            if (!trimmed)
+                continue;
+            const abiParameter = parseAbiParameter(trimmed, {
+                type: 'struct',
+            });
+            components.push(abiParameter);
+        }
+        if (!components.length)
+            throw new InvalidStructSignatureError({ signature });
+        shallowStructs[match.name] = components;
+    }
+    // Resolve nested structs inside each parameter
+    const resolvedStructs = {};
+    const entries = Object.entries(shallowStructs);
+    const entriesLength = entries.length;
+    for (let i = 0; i < entriesLength; i++) {
+        const [name, parameters] = entries[i];
+        resolvedStructs[name] = resolveStructs(parameters, shallowStructs);
+    }
+    return resolvedStructs;
+}
+const typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
+function resolveStructs(abiParameters = [], structs = {}, ancestors = new Set()) {
+    const components = [];
+    const length = abiParameters.length;
+    for (let i = 0; i < length; i++) {
+        const abiParameter = abiParameters[i];
+        const isTuple = isTupleRegex.test(abiParameter.type);
+        if (isTuple)
+            components.push(abiParameter);
+        else {
+            const match = execTyped(typeWithoutTupleRegex, abiParameter.type);
+            if (!match?.type)
+                throw new InvalidAbiTypeParameterError({ abiParameter });
+            const { array, type } = match;
+            if (type in structs) {
+                if (ancestors.has(type))
+                    throw new CircularReferenceError({ type });
+                components.push({
+                    ...abiParameter,
+                    type: `tuple${array ?? ''}`,
+                    components: resolveStructs(structs[type], structs, new Set([...ancestors, type])),
+                });
+            }
+            else {
+                if (isSolidityType(type))
+                    components.push(abiParameter);
+                else
+                    throw new UnknownTypeError({ type });
+            }
+        }
+    }
+    return components;
+}
+
+/**
+ * Parses human-readable ABI into JSON {@link Abi}
+ *
+ * @param signatures - Human-Readable ABI
+ * @returns Parsed {@link Abi}
+ *
+ * @example
+ * const abi = parseAbi([
+ *   //  ^? const abi: readonly [{ name: "balanceOf"; type: "function"; stateMutability:...
+ *   'function balanceOf(address owner) view returns (uint256)',
+ *   'event Transfer(address indexed from, address indexed to, uint256 amount)',
+ * ])
+ */
+function parseAbi(signatures) {
+    const structs = parseStructs(signatures);
+    const abi = [];
+    const length = signatures.length;
+    for (let i = 0; i < length; i++) {
+        const signature = signatures[i];
+        if (isStructSignature(signature))
+            continue;
+        abi.push(parseSignature(signature, structs));
+    }
+    return abi;
+}
+
+function formatAbiItem(abiItem, { includeName = false } = {}) {
+    if (abiItem.type !== 'function' &&
+        abiItem.type !== 'event' &&
+        abiItem.type !== 'error')
+        throw new InvalidDefinitionTypeError(abiItem.type);
+    return `${abiItem.name}(${formatAbiParams(abiItem.inputs, { includeName })})`;
+}
+function formatAbiParams(params, { includeName = false } = {}) {
+    if (!params)
+        return '';
+    return params
+        .map((param) => formatAbiParam(param, { includeName }))
+        .join(includeName ? ', ' : ',');
+}
+function formatAbiParam(param, { includeName }) {
+    if (param.type.startsWith('tuple')) {
+        return `(${formatAbiParams(param.components, { includeName })})${param.type.slice('tuple'.length)}`;
+    }
+    return param.type + (includeName && param.name ? ` ${param.name}` : '');
+}
+
+function isHex(value, { strict = true } = {}) {
+    if (!value)
+        return false;
+    if (typeof value !== 'string')
+        return false;
+    return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith('0x');
+}
+
+/**
+ * @description Retrieves the size of the value (in bytes).
+ *
+ * @param value The value (hex or byte array) to retrieve the size of.
+ * @returns The size of the value (in bytes).
+ */
+function size(value) {
+    if (isHex(value, { strict: false }))
+        return Math.ceil((value.length - 2) / 2);
+    return value.length;
+}
+
+const version = '2.47.10';
+
+let errorConfig = {
+    getDocsUrl: ({ docsBaseUrl, docsPath = '', docsSlug, }) => docsPath
+        ? `${docsBaseUrl ?? 'https://viem.sh'}${docsPath}${docsSlug ? `#${docsSlug}` : ''}`
+        : undefined,
+    version: `viem@${version}`,
+};
+class BaseError extends Error {
+    constructor(shortMessage, args = {}) {
+        const details = (() => {
+            if (args.cause instanceof BaseError)
+                return args.cause.details;
+            if (args.cause?.message)
+                return args.cause.message;
+            return args.details;
+        })();
+        const docsPath = (() => {
+            if (args.cause instanceof BaseError)
+                return args.cause.docsPath || args.docsPath;
+            return args.docsPath;
+        })();
+        const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath });
+        const message = [
+            shortMessage || 'An error occurred.',
+            '',
+            ...(args.metaMessages ? [...args.metaMessages, ''] : []),
+            ...(docsUrl ? [`Docs: ${docsUrl}`] : []),
+            ...(details ? [`Details: ${details}`] : []),
+            ...(errorConfig.version ? [`Version: ${errorConfig.version}`] : []),
+        ].join('\n');
+        super(message, args.cause ? { cause: args.cause } : undefined);
+        Object.defineProperty(this, "details", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "docsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metaMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "shortMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "version", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'BaseError'
+        });
+        this.details = details;
+        this.docsPath = docsPath;
+        this.metaMessages = args.metaMessages;
+        this.name = args.name ?? this.name;
+        this.shortMessage = shortMessage;
+        this.version = version;
+    }
+    walk(fn) {
+        return walk(this, fn);
+    }
+}
+function walk(err, fn) {
+    if (fn?.(err))
+        return err;
+    if (err &&
+        typeof err === 'object' &&
+        'cause' in err &&
+        err.cause !== undefined)
+        return walk(err.cause, fn);
+    return fn ? null : err;
+}
+
+class AbiEncodingArrayLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength, type, }) {
+        super([
+            `ABI encoding array length mismatch for type ${type}.`,
+            `Expected length: ${expectedLength}`,
+            `Given length: ${givenLength}`,
+        ].join('\n'), { name: 'AbiEncodingArrayLengthMismatchError' });
+    }
+}
+class AbiEncodingBytesSizeMismatchError extends BaseError {
+    constructor({ expectedSize, value }) {
+        super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: 'AbiEncodingBytesSizeMismatchError' });
+    }
+}
+class AbiEncodingLengthMismatchError extends BaseError {
+    constructor({ expectedLength, givenLength, }) {
+        super([
+            'ABI encoding params/values length mismatch.',
+            `Expected length (params): ${expectedLength}`,
+            `Given length (values): ${givenLength}`,
+        ].join('\n'), { name: 'AbiEncodingLengthMismatchError' });
+    }
+}
+class AbiFunctionNotFoundError extends BaseError {
+    constructor(functionName, { docsPath } = {}) {
+        super([
+            `Function ${functionName ? `"${functionName}" ` : ''}not found on ABI.`,
+            'Make sure you are using the correct ABI and that the function exists on it.',
+        ].join('\n'), {
+            docsPath,
+            name: 'AbiFunctionNotFoundError',
+        });
+    }
+}
+class AbiItemAmbiguityError extends BaseError {
+    constructor(x, y) {
+        super('Found ambiguous types in overloaded ABI items.', {
+            metaMessages: [
+                `\`${x.type}\` in \`${formatAbiItem(x.abiItem)}\`, and`,
+                `\`${y.type}\` in \`${formatAbiItem(y.abiItem)}\``,
+                '',
+                'These types encode differently and cannot be distinguished at runtime.',
+                'Remove one of the ambiguous items in the ABI.',
+            ],
+            name: 'AbiItemAmbiguityError',
+        });
+    }
+}
+class InvalidAbiEncodingTypeError extends BaseError {
+    constructor(type, { docsPath }) {
+        super([
+            `Type "${type}" is not a valid encoding type.`,
+            'Please provide a valid ABI type.',
+        ].join('\n'), { docsPath, name: 'InvalidAbiEncodingType' });
+    }
+}
+class InvalidArrayError extends BaseError {
+    constructor(value) {
+        super([`Value "${value}" is not a valid array.`].join('\n'), {
+            name: 'InvalidArrayError',
+        });
+    }
+}
+class InvalidDefinitionTypeError extends BaseError {
+    constructor(type) {
+        super([
+            `"${type}" is not a valid definition type.`,
+            'Valid types: "function", "event", "error"',
+        ].join('\n'), { name: 'InvalidDefinitionTypeError' });
+    }
+}
+
+class SliceOffsetOutOfBoundsError extends BaseError {
+    constructor({ offset, position, size, }) {
+        super(`Slice ${position === 'start' ? 'starting' : 'ending'} at offset "${offset}" is out-of-bounds (size: ${size}).`, { name: 'SliceOffsetOutOfBoundsError' });
+    }
+}
+class SizeExceedsPaddingSizeError extends BaseError {
+    constructor({ size, targetSize, type, }) {
+        super(`${type.charAt(0).toUpperCase()}${type
+            .slice(1)
+            .toLowerCase()} size (${size}) exceeds padding size (${targetSize}).`, { name: 'SizeExceedsPaddingSizeError' });
+    }
+}
+
+function pad(hexOrBytes, { dir, size = 32 } = {}) {
+    if (typeof hexOrBytes === 'string')
+        return padHex(hexOrBytes, { dir, size });
+    return padBytes(hexOrBytes, { dir, size });
+}
+function padHex(hex_, { dir, size = 32 } = {}) {
+    if (size === null)
+        return hex_;
+    const hex = hex_.replace('0x', '');
+    if (hex.length > size * 2)
+        throw new SizeExceedsPaddingSizeError({
+            size: Math.ceil(hex.length / 2),
+            targetSize: size,
+            type: 'hex',
+        });
+    return `0x${hex[dir === 'right' ? 'padEnd' : 'padStart'](size * 2, '0')}`;
+}
+function padBytes(bytes, { dir, size = 32 } = {}) {
+    if (size === null)
+        return bytes;
+    if (bytes.length > size)
+        throw new SizeExceedsPaddingSizeError({
+            size: bytes.length,
+            targetSize: size,
+            type: 'bytes',
+        });
+    const paddedBytes = new Uint8Array(size);
+    for (let i = 0; i < size; i++) {
+        const padEnd = dir === 'right';
+        paddedBytes[padEnd ? i : size - i - 1] =
+            bytes[padEnd ? i : bytes.length - i - 1];
+    }
+    return paddedBytes;
+}
+
+class IntegerOutOfRangeError extends BaseError {
+    constructor({ max, min, signed, size, value, }) {
+        super(`Number "${value}" is not in safe ${size ? `${size * 8}-bit ${signed ? 'signed' : 'unsigned'} ` : ''}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: 'IntegerOutOfRangeError' });
+    }
+}
+class SizeOverflowError extends BaseError {
+    constructor({ givenSize, maxSize }) {
+        super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: 'SizeOverflowError' });
+    }
+}
+
+function assertSize(hexOrBytes, { size: size$1 }) {
+    if (size(hexOrBytes) > size$1)
+        throw new SizeOverflowError({
+            givenSize: size(hexOrBytes),
+            maxSize: size$1,
+        });
+}
+
+const hexes = /*#__PURE__*/ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, '0'));
+/**
+ * Encodes a string, number, bigint, or ByteArray into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex
+ * - Example: https://viem.sh/docs/utilities/toHex#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world')
+ * // '0x48656c6c6f20776f726c6421'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world', { size: 32 })
+ * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
+ */
+function toHex(value, opts = {}) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return numberToHex(value, opts);
+    if (typeof value === 'string') {
+        return stringToHex(value, opts);
+    }
+    if (typeof value === 'boolean')
+        return boolToHex(value, opts);
+    return bytesToHex(value, opts);
+}
+/**
+ * Encodes a boolean into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#booltohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true)
+ * // '0x1'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(false)
+ * // '0x0'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true, { size: 32 })
+ * // '0x0000000000000000000000000000000000000000000000000000000000000001'
+ */
+function boolToHex(value, opts = {}) {
+    const hex = `0x${Number(value)}`;
+    if (typeof opts.size === 'number') {
+        assertSize(hex, { size: opts.size });
+        return pad(hex, { size: opts.size });
+    }
+    return hex;
+}
+/**
+ * Encodes a bytes array into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#bytestohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+function bytesToHex(value, opts = {}) {
+    let string = '';
+    for (let i = 0; i < value.length; i++) {
+        string += hexes[value[i]];
+    }
+    const hex = `0x${string}`;
+    if (typeof opts.size === 'number') {
+        assertSize(hex, { size: opts.size });
+        return pad(hex, { dir: 'right', size: opts.size });
+    }
+    return hex;
+}
+/**
+ * Encodes a number or bigint into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#numbertohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420, { size: 32 })
+ * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
+ */
+function numberToHex(value_, opts = {}) {
+    const { signed, size } = opts;
+    const value = BigInt(value_);
+    let maxValue;
+    if (size) {
+        if (signed)
+            maxValue = (1n << (BigInt(size) * 8n - 1n)) - 1n;
+        else
+            maxValue = 2n ** (BigInt(size) * 8n) - 1n;
+    }
+    else if (typeof value_ === 'number') {
+        maxValue = BigInt(Number.MAX_SAFE_INTEGER);
+    }
+    const minValue = typeof maxValue === 'bigint' && signed ? -maxValue - 1n : 0;
+    if ((maxValue && value > maxValue) || value < minValue) {
+        const suffix = typeof value_ === 'bigint' ? 'n' : '';
+        throw new IntegerOutOfRangeError({
+            max: maxValue ? `${maxValue}${suffix}` : undefined,
+            min: `${minValue}${suffix}`,
+            signed,
+            size,
+            value: `${value_}${suffix}`,
+        });
+    }
+    const hex = `0x${(signed && value < 0 ? (1n << BigInt(size * 8)) + BigInt(value) : value).toString(16)}`;
+    if (size)
+        return pad(hex, { size });
+    return hex;
+}
+const encoder$1 = /*#__PURE__*/ new TextEncoder();
+/**
+ * Encodes a UTF-8 string into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex#stringtohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!')
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!', { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+function stringToHex(value_, opts = {}) {
+    const value = encoder$1.encode(value_);
+    return bytesToHex(value, opts);
+}
+
+const encoder = /*#__PURE__*/ new TextEncoder();
+/**
+ * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes
+ * - Example: https://viem.sh/docs/utilities/toBytes#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes('Hello world')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+function toBytes$1(value, opts = {}) {
+    if (typeof value === 'number' || typeof value === 'bigint')
+        return numberToBytes(value, opts);
+    if (typeof value === 'boolean')
+        return boolToBytes(value, opts);
+    if (isHex(value))
+        return hexToBytes(value, opts);
+    return stringToBytes(value, opts);
+}
+/**
+ * Encodes a boolean into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#booltobytes
+ *
+ * @param value Boolean value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true)
+ * // Uint8Array([1])
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true, { size: 32 })
+ * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+ */
+function boolToBytes(value, opts = {}) {
+    const bytes = new Uint8Array(1);
+    bytes[0] = Number(value);
+    if (typeof opts.size === 'number') {
+        assertSize(bytes, { size: opts.size });
+        return pad(bytes, { size: opts.size });
+    }
+    return bytes;
+}
+// We use very optimized technique to convert hex string to byte array
+const charCodeMap = {
+    zero: 48,
+    nine: 57,
+    A: 65,
+    F: 70,
+    a: 97,
+    f: 102,
+};
+function charCodeToBase16(char) {
+    if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+        return char - charCodeMap.zero;
+    if (char >= charCodeMap.A && char <= charCodeMap.F)
+        return char - (charCodeMap.A - 10);
+    if (char >= charCodeMap.a && char <= charCodeMap.f)
+        return char - (charCodeMap.a - 10);
+    return undefined;
+}
+/**
+ * Encodes a hex string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#hextobytes
+ *
+ * @param hex Hex string to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+function hexToBytes(hex_, opts = {}) {
+    let hex = hex_;
+    if (opts.size) {
+        assertSize(hex, { size: opts.size });
+        hex = pad(hex, { dir: 'right', size: opts.size });
+    }
+    let hexString = hex.slice(2);
+    if (hexString.length % 2)
+        hexString = `0${hexString}`;
+    const length = hexString.length / 2;
+    const bytes = new Uint8Array(length);
+    for (let index = 0, j = 0; index < length; index++) {
+        const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
+        const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+        if (nibbleLeft === undefined || nibbleRight === undefined) {
+            throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+        }
+        bytes[index] = nibbleLeft * 16 + nibbleRight;
+    }
+    return bytes;
+}
+/**
+ * Encodes a number into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#numbertobytes
+ *
+ * @param value Number to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+function numberToBytes(value, opts) {
+    const hex = numberToHex(value, opts);
+    return hexToBytes(hex);
+}
+/**
+ * Encodes a UTF-8 string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes#stringtobytes
+ *
+ * @param value String to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+function stringToBytes(value, opts = {}) {
+    const bytes = encoder.encode(value);
+    if (typeof opts.size === 'number') {
+        assertSize(bytes, { size: opts.size });
+        return pad(bytes, { dir: 'right', size: opts.size });
+    }
+    return bytes;
+}
+
+/**
+ * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.
+ * @todo re-check https://issues.chromium.org/issues/42212588
+ * @module
+ */
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+    if (le)
+        return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };
+    return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split(lst, le = false) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+
+/**
+ * Utilities for hex, bytes, CSPRNG.
+ * @module
+ */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
+function isBytes(a) {
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+}
+/** Asserts something is positive integer. */
+function anumber(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error('positive integer expected, got ' + n);
+}
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
+}
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
+    if (instance.destroyed)
+        throw new Error('Hash instance has been destroyed');
+    if (checkFinished && instance.finished)
+        throw new Error('Hash#digest() has already been called');
+}
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error('digestInto() expects output buffer of length at least ' + min);
+    }
+}
+/** Cast u8 / u16 / u32 to u32. */
+function u32(arr) {
+    return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
+const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();
+/** The byte swap operation for uint32 */
+function byteSwap(word) {
+    return (((word << 24) & 0xff000000) |
+        ((word << 8) & 0xff0000) |
+        ((word >>> 8) & 0xff00) |
+        ((word >>> 24) & 0xff));
+}
+/** In place byte swap for Uint32Array */
+function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = byteSwap(arr[i]);
+    }
+    return arr;
+}
+const swap32IfBE = isLE
+    ? (u) => u
+    : byteSwap32;
+/**
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error('string expected');
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    abytes(data);
+    return data;
+}
+/** For runtime check if class implements interface */
+class Hash {
+}
+/** Wraps hash function, creating an interface on top of it */
+function createHasher(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+
+/**
+ * SHA3 (keccak) hash function, based on a new "Sponge function" design.
+ * Different from older hashes, the internal state is bigger than output size.
+ *
+ * Check out [FIPS-202](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.202.pdf),
+ * [Website](https://keccak.team/keccak.html),
+ * [the differences between SHA-3 and Keccak](https://crypto.stackexchange.com/questions/15727/what-are-the-key-differences-between-the-draft-sha-3-standard-and-the-keccak-sub).
+ *
+ * Check out `sha3-addons` module for cSHAKE, k12, and others.
+ * @module
+ */
+// No __PURE__ annotations in sha3 header:
+// EVERYTHING is in fact used on every export.
+// Various per round constants calculations
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+const _7n = BigInt(7);
+const _256n = BigInt(256);
+const _0x71n = BigInt(0x71);
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+    // Pi
+    [x, y] = [y, (2 * x + 3 * y) % 5];
+    SHA3_PI.push(2 * (5 * y + x));
+    // Rotational
+    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);
+    // Iota
+    let t = _0n;
+    for (let j = 0; j < 7; j++) {
+        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;
+        if (R & _2n)
+            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);
+    }
+    _SHA3_IOTA.push(t);
+}
+const IOTAS = split(_SHA3_IOTA, true);
+const SHA3_IOTA_H = IOTAS[0];
+const SHA3_IOTA_L = IOTAS[1];
+// Left rotation (without 0, 32, 64)
+const rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));
+const rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));
+/** `keccakf1600` internal function, additionally allows to adjust round count. */
+function keccakP(s, rounds = 24) {
+    const B = new Uint32Array(5 * 2);
+    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)
+    for (let round = 24 - rounds; round < 24; round++) {
+        // Theta θ
+        for (let x = 0; x < 10; x++)
+            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+        for (let x = 0; x < 10; x += 2) {
+            const idx1 = (x + 8) % 10;
+            const idx0 = (x + 2) % 10;
+            const B0 = B[idx0];
+            const B1 = B[idx0 + 1];
+            const Th = rotlH(B0, B1, 1) ^ B[idx1];
+            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+            for (let y = 0; y < 50; y += 10) {
+                s[x + y] ^= Th;
+                s[x + y + 1] ^= Tl;
+            }
+        }
+        // Rho (ρ) and Pi (π)
+        let curH = s[2];
+        let curL = s[3];
+        for (let t = 0; t < 24; t++) {
+            const shift = SHA3_ROTL[t];
+            const Th = rotlH(curH, curL, shift);
+            const Tl = rotlL(curH, curL, shift);
+            const PI = SHA3_PI[t];
+            curH = s[PI];
+            curL = s[PI + 1];
+            s[PI] = Th;
+            s[PI + 1] = Tl;
+        }
+        // Chi (χ)
+        for (let y = 0; y < 50; y += 10) {
+            for (let x = 0; x < 10; x++)
+                B[x] = s[y + x];
+            for (let x = 0; x < 10; x++)
+                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+        }
+        // Iota (ι)
+        s[0] ^= SHA3_IOTA_H[round];
+        s[1] ^= SHA3_IOTA_L[round];
+    }
+    clean(B);
+}
+/** Keccak sponge function. */
+class Keccak extends Hash {
+    // NOTE: we accept arguments in bytes instead of bits here.
+    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+        super();
+        this.pos = 0;
+        this.posOut = 0;
+        this.finished = false;
+        this.destroyed = false;
+        this.enableXOF = false;
+        this.blockLen = blockLen;
+        this.suffix = suffix;
+        this.outputLen = outputLen;
+        this.enableXOF = enableXOF;
+        this.rounds = rounds;
+        // Can be passed from user as dkLen
+        anumber(outputLen);
+        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes
+        // 0 < blockLen < 200
+        if (!(0 < blockLen && blockLen < 200))
+            throw new Error('only keccak-f1600 function is supported');
+        this.state = new Uint8Array(200);
+        this.state32 = u32(this.state);
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    keccak() {
+        swap32IfBE(this.state32);
+        keccakP(this.state32, this.rounds);
+        swap32IfBE(this.state32);
+        this.posOut = 0;
+        this.pos = 0;
+    }
+    update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(data);
+        const { blockLen, state } = this;
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            for (let i = 0; i < take; i++)
+                state[this.pos++] ^= data[pos++];
+            if (this.pos === blockLen)
+                this.keccak();
+        }
+        return this;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        const { state, suffix, pos, blockLen } = this;
+        // Do the padding
+        state[pos] ^= suffix;
+        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)
+            this.keccak();
+        state[blockLen - 1] ^= 0x80;
+        this.keccak();
+    }
+    writeInto(out) {
+        aexists(this, false);
+        abytes(out);
+        this.finish();
+        const bufferOut = this.state;
+        const { blockLen } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.keccak();
+            const take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    }
+    xofInto(out) {
+        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible for this instance');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        anumber(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        aoutput(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+    destroy() {
+        this.destroyed = true;
+        clean(this.state);
+    }
+    _cloneInto(to) {
+        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+        to.state32.set(this.state32);
+        to.pos = this.pos;
+        to.posOut = this.posOut;
+        to.finished = this.finished;
+        to.rounds = rounds;
+        // Suffix can change in cSHAKE
+        to.suffix = suffix;
+        to.outputLen = outputLen;
+        to.enableXOF = enableXOF;
+        to.destroyed = this.destroyed;
+        return to;
+    }
+}
+const gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
+/** keccak-256 hash function. Different from SHA3-256. */
+const keccak_256 = /* @__PURE__ */ (() => gen(0x01, 136, 256 / 8))();
+
+function keccak256(value, to_) {
+    const to = to_ || 'hex';
+    const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes$1(value) : value);
+    if (to === 'bytes')
+        return bytes;
+    return toHex(bytes);
+}
+
+const hash = (value) => keccak256(toBytes$1(value));
+function hashSignature(sig) {
+    return hash(sig);
+}
+
+function normalizeSignature(signature) {
+    let active = true;
+    let current = '';
+    let level = 0;
+    let result = '';
+    let valid = false;
+    for (let i = 0; i < signature.length; i++) {
+        const char = signature[i];
+        // If the character is a separator, we want to reactivate.
+        if (['(', ')', ','].includes(char))
+            active = true;
+        // If the character is a "level" token, we want to increment/decrement.
+        if (char === '(')
+            level++;
+        if (char === ')')
+            level--;
+        // If we aren't active, we don't want to mutate the result.
+        if (!active)
+            continue;
+        // If level === 0, we are at the definition level.
+        if (level === 0) {
+            if (char === ' ' && ['event', 'function', ''].includes(result))
+                result = '';
+            else {
+                result += char;
+                // If we are at the end of the definition, we must be finished.
+                if (char === ')') {
+                    valid = true;
+                    break;
+                }
+            }
+            continue;
+        }
+        // Ignore spaces
+        if (char === ' ') {
+            // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
+            if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+                current = '';
+                active = false;
+            }
+            continue;
+        }
+        result += char;
+        current += char;
+    }
+    if (!valid)
+        throw new BaseError('Unable to normalize signature.');
+    return result;
+}
+
+/**
+ * Returns the signature for a given function or event definition.
+ *
+ * @example
+ * const signature = toSignature('function ownerOf(uint256 tokenId)')
+ * // 'ownerOf(uint256)'
+ *
+ * @example
+ * const signature_3 = toSignature({
+ *   name: 'ownerOf',
+ *   type: 'function',
+ *   inputs: [{ name: 'tokenId', type: 'uint256' }],
+ *   outputs: [],
+ *   stateMutability: 'view',
+ * })
+ * // 'ownerOf(uint256)'
+ */
+const toSignature = (def) => {
+    const def_ = (() => {
+        if (typeof def === 'string')
+            return def;
+        return formatAbiItem$1(def);
+    })();
+    return normalizeSignature(def_);
+};
+
+/**
+ * Returns the hash (of the function/event signature) for a given event or function definition.
+ */
+function toSignatureHash(fn) {
+    return hashSignature(toSignature(fn));
+}
+
+/**
+ * Returns the event selector for a given event definition.
+ *
+ * @example
+ * const selector = toEventSelector('Transfer(address indexed from, address indexed to, uint256 amount)')
+ * // 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef
+ */
+const toEventSelector = toSignatureHash;
+
+class InvalidAddressError extends BaseError {
+    constructor({ address }) {
+        super(`Address "${address}" is invalid.`, {
+            metaMessages: [
+                '- Address must be a hex value of 20 bytes (40 hex characters).',
+                '- Address must match its checksum counterpart.',
+            ],
+            name: 'InvalidAddressError',
+        });
+    }
+}
+
+/**
+ * Map with a LRU (Least recently used) policy.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+class LruMap extends Map {
+    constructor(size) {
+        super();
+        Object.defineProperty(this, "maxSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.maxSize = size;
+    }
+    get(key) {
+        const value = super.get(key);
+        if (super.has(key)) {
+            super.delete(key);
+            super.set(key, value);
+        }
+        return value;
+    }
+    set(key, value) {
+        if (super.has(key))
+            super.delete(key);
+        super.set(key, value);
+        if (this.maxSize && this.size > this.maxSize) {
+            const firstKey = super.keys().next().value;
+            if (firstKey !== undefined)
+                super.delete(firstKey);
+        }
+        return this;
+    }
+}
+
+const checksumAddressCache = /*#__PURE__*/ new LruMap(8192);
+function checksumAddress(address_, 
+/**
+ * Warning: EIP-1191 checksum addresses are generally not backwards compatible with the
+ * wider Ethereum ecosystem, meaning it will break when validated against an application/tool
+ * that relies on EIP-55 checksum encoding (checksum without chainId).
+ *
+ * It is highly recommended to not use this feature unless you
+ * know what you are doing.
+ *
+ * See more: https://github.com/ethereum/EIPs/issues/1121
+ */
+chainId) {
+    if (checksumAddressCache.has(`${address_}.${chainId}`))
+        return checksumAddressCache.get(`${address_}.${chainId}`);
+    const hexAddress = address_.substring(2).toLowerCase();
+    const hash = keccak256(stringToBytes(hexAddress), 'bytes');
+    const address = (hexAddress).split('');
+    for (let i = 0; i < 40; i += 2) {
+        if (hash[i >> 1] >> 4 >= 8 && address[i]) {
+            address[i] = address[i].toUpperCase();
+        }
+        if ((hash[i >> 1] & 0x0f) >= 8 && address[i + 1]) {
+            address[i + 1] = address[i + 1].toUpperCase();
+        }
+    }
+    const result = `0x${address.join('')}`;
+    checksumAddressCache.set(`${address_}.${chainId}`, result);
+    return result;
+}
+
+const addressRegex = /^0x[a-fA-F0-9]{40}$/;
+/** @internal */
+const isAddressCache = /*#__PURE__*/ new LruMap(8192);
+function isAddress(address, options) {
+    const { strict = true } = options ?? {};
+    const cacheKey = `${address}.${strict}`;
+    if (isAddressCache.has(cacheKey))
+        return isAddressCache.get(cacheKey);
+    const result = (() => {
+        if (!addressRegex.test(address))
+            return false;
+        if (address.toLowerCase() === address)
+            return true;
+        if (strict)
+            return checksumAddress(address) === address;
+        return true;
+    })();
+    isAddressCache.set(cacheKey, result);
+    return result;
+}
+
+function concat(values) {
+    if (typeof values[0] === 'string')
+        return concatHex(values);
+    return concatBytes(values);
+}
+function concatBytes(values) {
+    let length = 0;
+    for (const arr of values) {
+        length += arr.length;
+    }
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const arr of values) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+function concatHex(values) {
+    return `0x${values.reduce((acc, x) => acc + x.replace('0x', ''), '')}`;
+}
+
+/**
+ * @description Returns a section of the hex or byte array given a start/end bytes offset.
+ *
+ * @param value The hex or byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function slice(value, start, end, { strict } = {}) {
+    if (isHex(value, { strict: false }))
+        return sliceHex(value, start, end, {
+            strict,
+        });
+    return sliceBytes(value, start, end, {
+        strict,
+    });
+}
+function assertStartOffset(value, start) {
+    if (typeof start === 'number' && start > 0 && start > size(value) - 1)
+        throw new SliceOffsetOutOfBoundsError({
+            offset: start,
+            position: 'start',
+            size: size(value),
+        });
+}
+function assertEndOffset(value, start, end) {
+    if (typeof start === 'number' &&
+        typeof end === 'number' &&
+        size(value) !== end - start) {
+        throw new SliceOffsetOutOfBoundsError({
+            offset: end,
+            position: 'end',
+            size: size(value),
+        });
+    }
+}
+/**
+ * @description Returns a section of the byte array given a start/end bytes offset.
+ *
+ * @param value The byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function sliceBytes(value_, start, end, { strict } = {}) {
+    assertStartOffset(value_, start);
+    const value = value_.slice(start, end);
+    if (strict)
+        assertEndOffset(value, start, end);
+    return value;
+}
+/**
+ * @description Returns a section of the hex value given a start/end bytes offset.
+ *
+ * @param value The hex value to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+function sliceHex(value_, start, end, { strict } = {}) {
+    assertStartOffset(value_, start);
+    const value = `0x${value_
+        .replace('0x', '')
+        .slice((start ?? 0) * 2, (end ?? value_.length) * 2)}`;
+    if (strict)
+        assertEndOffset(value, start, end);
+    return value;
+}
+
+// `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+// https://regexr.com/6v8hp
+const integerRegex = /^(u?int)(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;
+
+/**
+ * @description Encodes a list of primitive values into an ABI-encoded hex value.
+ *
+ * - Docs: https://viem.sh/docs/abi/encodeAbiParameters#encodeabiparameters
+ *
+ *   Generates ABI encoded data using the [ABI specification](https://docs.soliditylang.org/en/latest/abi-spec), given a set of ABI parameters (inputs/outputs) and their corresponding values.
+ *
+ * @param params - a set of ABI Parameters (params), that can be in the shape of the inputs or outputs attribute of an ABI Item.
+ * @param values - a set of values (values) that correspond to the given params.
+ * @example
+ * ```typescript
+ * import { encodeAbiParameters } from 'viem'
+ *
+ * const encodedData = encodeAbiParameters(
+ *   [
+ *     { name: 'x', type: 'string' },
+ *     { name: 'y', type: 'uint' },
+ *     { name: 'z', type: 'bool' }
+ *   ],
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ *
+ * You can also pass in Human Readable parameters with the parseAbiParameters utility.
+ *
+ * @example
+ * ```typescript
+ * import { encodeAbiParameters, parseAbiParameters } from 'viem'
+ *
+ * const encodedData = encodeAbiParameters(
+ *   parseAbiParameters('string x, uint y, bool z'),
+ *   ['wagmi', 420n, true]
+ * )
+ * ```
+ */
+function encodeAbiParameters(params, values) {
+    if (params.length !== values.length)
+        throw new AbiEncodingLengthMismatchError({
+            expectedLength: params.length,
+            givenLength: values.length,
+        });
+    // Prepare the parameters to determine dynamic types to encode.
+    const preparedParams = prepareParams({
+        params: params,
+        values: values,
+    });
+    const data = encodeParams(preparedParams);
+    if (data.length === 0)
+        return '0x';
+    return data;
+}
+function prepareParams({ params, values, }) {
+    const preparedParams = [];
+    for (let i = 0; i < params.length; i++) {
+        preparedParams.push(prepareParam({ param: params[i], value: values[i] }));
+    }
+    return preparedParams;
+}
+function prepareParam({ param, value, }) {
+    const arrayComponents = getArrayComponents(param.type);
+    if (arrayComponents) {
+        const [length, type] = arrayComponents;
+        return encodeArray(value, { length, param: { ...param, type } });
+    }
+    if (param.type === 'tuple') {
+        return encodeTuple(value, {
+            param: param,
+        });
+    }
+    if (param.type === 'address') {
+        return encodeAddress(value);
+    }
+    if (param.type === 'bool') {
+        return encodeBool(value);
+    }
+    if (param.type.startsWith('uint') || param.type.startsWith('int')) {
+        const signed = param.type.startsWith('int');
+        const [, , size = '256'] = integerRegex.exec(param.type) ?? [];
+        return encodeNumber(value, {
+            signed,
+            size: Number(size),
+        });
+    }
+    if (param.type.startsWith('bytes')) {
+        return encodeBytes(value, { param });
+    }
+    if (param.type === 'string') {
+        return encodeString(value);
+    }
+    throw new InvalidAbiEncodingTypeError(param.type, {
+        docsPath: '/docs/contract/encodeAbiParameters',
+    });
+}
+function encodeParams(preparedParams) {
+    // 1. Compute the size of the static part of the parameters.
+    let staticSize = 0;
+    for (let i = 0; i < preparedParams.length; i++) {
+        const { dynamic, encoded } = preparedParams[i];
+        if (dynamic)
+            staticSize += 32;
+        else
+            staticSize += size(encoded);
+    }
+    // 2. Split the parameters into static and dynamic parts.
+    const staticParams = [];
+    const dynamicParams = [];
+    let dynamicSize = 0;
+    for (let i = 0; i < preparedParams.length; i++) {
+        const { dynamic, encoded } = preparedParams[i];
+        if (dynamic) {
+            staticParams.push(numberToHex(staticSize + dynamicSize, { size: 32 }));
+            dynamicParams.push(encoded);
+            dynamicSize += size(encoded);
+        }
+        else {
+            staticParams.push(encoded);
+        }
+    }
+    // 3. Concatenate static and dynamic parts.
+    return concat([...staticParams, ...dynamicParams]);
+}
+function encodeAddress(value) {
+    if (!isAddress(value))
+        throw new InvalidAddressError({ address: value });
+    return { dynamic: false, encoded: padHex(value.toLowerCase()) };
+}
+function encodeArray(value, { length, param, }) {
+    const dynamic = length === null;
+    if (!Array.isArray(value))
+        throw new InvalidArrayError(value);
+    if (!dynamic && value.length !== length)
+        throw new AbiEncodingArrayLengthMismatchError({
+            expectedLength: length,
+            givenLength: value.length,
+            type: `${param.type}[${length}]`,
+        });
+    let dynamicChild = false;
+    const preparedParams = [];
+    for (let i = 0; i < value.length; i++) {
+        const preparedParam = prepareParam({ param, value: value[i] });
+        if (preparedParam.dynamic)
+            dynamicChild = true;
+        preparedParams.push(preparedParam);
+    }
+    if (dynamic || dynamicChild) {
+        const data = encodeParams(preparedParams);
+        if (dynamic) {
+            const length = numberToHex(preparedParams.length, { size: 32 });
+            return {
+                dynamic: true,
+                encoded: preparedParams.length > 0 ? concat([length, data]) : length,
+            };
+        }
+        if (dynamicChild)
+            return { dynamic: true, encoded: data };
+    }
+    return {
+        dynamic: false,
+        encoded: concat(preparedParams.map(({ encoded }) => encoded)),
+    };
+}
+function encodeBytes(value, { param }) {
+    const [, paramSize] = param.type.split('bytes');
+    const bytesSize = size(value);
+    if (!paramSize) {
+        let value_ = value;
+        // If the size is not divisible by 32 bytes, pad the end
+        // with empty bytes to the ceiling 32 bytes.
+        if (bytesSize % 32 !== 0)
+            value_ = padHex(value_, {
+                dir: 'right',
+                size: Math.ceil((value.length - 2) / 2 / 32) * 32,
+            });
+        return {
+            dynamic: true,
+            encoded: concat([padHex(numberToHex(bytesSize, { size: 32 })), value_]),
+        };
+    }
+    if (bytesSize !== Number.parseInt(paramSize, 10))
+        throw new AbiEncodingBytesSizeMismatchError({
+            expectedSize: Number.parseInt(paramSize, 10),
+            value,
+        });
+    return { dynamic: false, encoded: padHex(value, { dir: 'right' }) };
+}
+function encodeBool(value) {
+    if (typeof value !== 'boolean')
+        throw new BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+    return { dynamic: false, encoded: padHex(boolToHex(value)) };
+}
+function encodeNumber(value, { signed, size = 256 }) {
+    if (typeof size === 'number') {
+        const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;
+        const min = signed ? -max - 1n : 0n;
+        if (value > max || value < min)
+            throw new IntegerOutOfRangeError({
+                max: max.toString(),
+                min: min.toString(),
+                signed,
+                size: size / 8,
+                value: value.toString(),
+            });
+    }
+    return {
+        dynamic: false,
+        encoded: numberToHex(value, {
+            size: 32,
+            signed,
+        }),
+    };
+}
+function encodeString(value) {
+    const hexValue = stringToHex(value);
+    const partsLength = Math.ceil(size(hexValue) / 32);
+    const parts = [];
+    for (let i = 0; i < partsLength; i++) {
+        parts.push(padHex(slice(hexValue, i * 32, (i + 1) * 32), {
+            dir: 'right',
+        }));
+    }
+    return {
+        dynamic: true,
+        encoded: concat([
+            padHex(numberToHex(size(hexValue), { size: 32 })),
+            ...parts,
+        ]),
+    };
+}
+function encodeTuple(value, { param }) {
+    let dynamic = false;
+    const preparedParams = [];
+    for (let i = 0; i < param.components.length; i++) {
+        const param_ = param.components[i];
+        const index = Array.isArray(value) ? i : param_.name;
+        const preparedParam = prepareParam({
+            param: param_,
+            value: value[index],
+        });
+        preparedParams.push(preparedParam);
+        if (preparedParam.dynamic)
+            dynamic = true;
+    }
+    return {
+        dynamic,
+        encoded: dynamic
+            ? encodeParams(preparedParams)
+            : concat(preparedParams.map(({ encoded }) => encoded)),
+    };
+}
+function getArrayComponents(type) {
+    const matches = type.match(/^(.*)\[(\d+)?\]$/);
+    return matches
+        ? // Return `null` if the array is dynamic.
+            [matches[2] ? Number(matches[2]) : null, matches[1]]
+        : undefined;
+}
+
+/**
+ * Returns the function selector for a given function definition.
+ *
+ * @example
+ * const selector = toFunctionSelector('function ownerOf(uint256 tokenId)')
+ * // 0x6352211e
+ */
+const toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
+
+function getAbiItem(parameters) {
+    const { abi, args = [], name } = parameters;
+    const isSelector = isHex(name, { strict: false });
+    const abiItems = abi.filter((abiItem) => {
+        if (isSelector) {
+            if (abiItem.type === 'function')
+                return toFunctionSelector(abiItem) === name;
+            if (abiItem.type === 'event')
+                return toEventSelector(abiItem) === name;
+            return false;
+        }
+        return 'name' in abiItem && abiItem.name === name;
+    });
+    if (abiItems.length === 0)
+        return undefined;
+    if (abiItems.length === 1)
+        return abiItems[0];
+    let matchedAbiItem;
+    for (const abiItem of abiItems) {
+        if (!('inputs' in abiItem))
+            continue;
+        if (!args || args.length === 0) {
+            if (!abiItem.inputs || abiItem.inputs.length === 0)
+                return abiItem;
+            continue;
+        }
+        if (!abiItem.inputs)
+            continue;
+        if (abiItem.inputs.length === 0)
+            continue;
+        if (abiItem.inputs.length !== args.length)
+            continue;
+        const matched = args.every((arg, index) => {
+            const abiParameter = 'inputs' in abiItem && abiItem.inputs[index];
+            if (!abiParameter)
+                return false;
+            return isArgOfType(arg, abiParameter);
+        });
+        if (matched) {
+            // Check for ambiguity against already matched parameters (e.g. `address` vs `bytes20`).
+            if (matchedAbiItem &&
+                'inputs' in matchedAbiItem &&
+                matchedAbiItem.inputs) {
+                const ambiguousTypes = getAmbiguousTypes(abiItem.inputs, matchedAbiItem.inputs, args);
+                if (ambiguousTypes)
+                    throw new AbiItemAmbiguityError({
+                        abiItem,
+                        type: ambiguousTypes[0],
+                    }, {
+                        abiItem: matchedAbiItem,
+                        type: ambiguousTypes[1],
+                    });
+            }
+            matchedAbiItem = abiItem;
+        }
+    }
+    if (matchedAbiItem)
+        return matchedAbiItem;
+    return abiItems[0];
+}
+/** @internal */
+function isArgOfType(arg, abiParameter) {
+    const argType = typeof arg;
+    const abiParameterType = abiParameter.type;
+    switch (abiParameterType) {
+        case 'address':
+            return isAddress(arg, { strict: false });
+        case 'bool':
+            return argType === 'boolean';
+        case 'function':
+            return argType === 'string';
+        case 'string':
+            return argType === 'string';
+        default: {
+            if (abiParameterType === 'tuple' && 'components' in abiParameter)
+                return Object.values(abiParameter.components).every((component, index) => {
+                    return (argType === 'object' &&
+                        isArgOfType(Object.values(arg)[index], component));
+                });
+            // `(u)int<M>`: (un)signed integer type of `M` bits, `0 < M <= 256`, `M % 8 == 0`
+            // https://regexr.com/6v8hp
+            if (/^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/.test(abiParameterType))
+                return argType === 'number' || argType === 'bigint';
+            // `bytes<M>`: binary type of `M` bytes, `0 < M <= 32`
+            // https://regexr.com/6va55
+            if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
+                return argType === 'string' || arg instanceof Uint8Array;
+            // fixed-length (`<type>[M]`) and dynamic (`<type>[]`) arrays
+            // https://regexr.com/6va6i
+            if (/[a-z]+[1-9]{0,3}(\[[0-9]{0,}\])+$/.test(abiParameterType)) {
+                return (Array.isArray(arg) &&
+                    arg.every((x) => isArgOfType(x, {
+                        ...abiParameter,
+                        // Pop off `[]` or `[M]` from end of type
+                        type: abiParameterType.replace(/(\[[0-9]{0,}\])$/, ''),
+                    })));
+            }
+            return false;
+        }
+    }
+}
+/** @internal */
+function getAmbiguousTypes(sourceParameters, targetParameters, args) {
+    for (const parameterIndex in sourceParameters) {
+        const sourceParameter = sourceParameters[parameterIndex];
+        const targetParameter = targetParameters[parameterIndex];
+        if (sourceParameter.type === 'tuple' &&
+            targetParameter.type === 'tuple' &&
+            'components' in sourceParameter &&
+            'components' in targetParameter)
+            return getAmbiguousTypes(sourceParameter.components, targetParameter.components, args[parameterIndex]);
+        const types = [sourceParameter.type, targetParameter.type];
+        const ambiguous = (() => {
+            if (types.includes('address') && types.includes('bytes20'))
+                return true;
+            if (types.includes('address') && types.includes('string'))
+                return isAddress(args[parameterIndex], { strict: false });
+            if (types.includes('address') && types.includes('bytes'))
+                return isAddress(args[parameterIndex], { strict: false });
+            return false;
+        })();
+        if (ambiguous)
+            return types;
+    }
+    return;
+}
+
+const docsPath = '/docs/contract/encodeFunctionData';
+function prepareEncodeFunctionData(parameters) {
+    const { abi, args, functionName } = parameters;
+    let abiItem = abi[0];
+    if (functionName) {
+        const item = getAbiItem({
+            abi,
+            args,
+            name: functionName,
+        });
+        if (!item)
+            throw new AbiFunctionNotFoundError(functionName, { docsPath });
+        abiItem = item;
+    }
+    if (abiItem.type !== 'function')
+        throw new AbiFunctionNotFoundError(undefined, { docsPath });
+    return {
+        abi: [abiItem],
+        functionName: toFunctionSelector(formatAbiItem(abiItem)),
+    };
+}
+
+function encodeFunctionData(parameters) {
+    const { args } = parameters;
+    const { abi, functionName } = (() => {
+        if (parameters.abi.length === 1 &&
+            parameters.functionName?.startsWith('0x'))
+            return parameters;
+        return prepareEncodeFunctionData(parameters);
+    })();
+    const abiItem = abi[0];
+    const signature = functionName;
+    const data = 'inputs' in abiItem && abiItem.inputs
+        ? encodeAbiParameters(abiItem.inputs, args ?? [])
+        : undefined;
+    return concatHex([signature, data ?? '0x']);
+}
+
+const ZERO_ADDRESS$1 = "0x0000000000000000000000000000000000000000";
+const PAYMENT_ABI = parseAbi([
+    "function createPayment(bytes32 paymentId, string vendorId, address token, uint256 amount, uint256 deadline, bytes backendSignature) external payable",
+]);
+const ERC20_ABI = parseAbi([
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function approve(address spender, uint256 amount) returns (bool)",
+]);
+function ensure0x(hex) {
+    return (hex.startsWith("0x") ? hex : `0x${hex}`);
+}
+class ContractService {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async getAddress() {
+        const accounts = (await this.provider.request({
+            method: "eth_requestAccounts",
+        }));
+        if (!accounts[0]) {
+            throw new KwesPayError("No wallet account available", "WALLET_REJECTED");
+        }
+        return accounts[0];
+    }
+    async waitForReceipt(txHash, timeoutMs = 120000) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const receipt = (await this.provider.request({
+                method: "eth_getTransactionReceipt",
+                params: [txHash],
+            }));
+            if (receipt) {
+                return {
+                    blockNumber: parseInt(receipt.blockNumber, 16),
+                    status: parseInt(receipt.status, 16),
+                };
+            }
+            await new Promise((r) => setTimeout(r, 2000));
+        }
+        throw new KwesPayError("Transaction receipt timeout — check wallet or block explorer", "CONTRACT_ERROR");
+    }
+    async ensureApproval(tokenAddress, amountBaseUnits, contractAddress, chainId, onStatus) {
+        if (tokenAddress === ZERO_ADDRESS$1)
+            return;
+        onStatus?.("Checking approval", "Verifying token allowance…");
+        const owner = await this.getAddress();
+        const amount = BigInt(amountBaseUnits);
+        const allowanceData = encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: "allowance",
+            args: [owner, ensure0x(contractAddress)],
+        });
+        const rawAllowance = (await this.provider.request({
+            method: "eth_call",
+            params: [{ to: ensure0x(tokenAddress), data: allowanceData }, "latest"],
+        }));
+        const allowance = rawAllowance && rawAllowance !== "0x" ? BigInt(rawAllowance) : 0n;
+        if (allowance >= amount)
+            return;
+        onStatus?.("Approve token", "Please approve in your wallet");
+        const approveData = encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: "approve",
+            args: [ensure0x(contractAddress), amount * 2n],
+        });
+        let txHash;
+        try {
+            txHash = (await this.provider.request({
+                method: "eth_sendTransaction",
+                params: [
+                    { from: owner, to: ensure0x(tokenAddress), data: approveData },
+                ],
+            }));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("rejected") ||
+                msg.includes("denied") ||
+                msg.includes("ACTION_REJECTED")) {
+                throw new KwesPayError("Token approval cancelled by user", "APPROVAL_REJECTED", err);
+            }
+            throw new KwesPayError(`Token approval failed: ${msg}`, "CONTRACT_ERROR", err);
+        }
+        onStatus?.("Waiting for approval", `Tx: ${txHash.slice(0, 10)}…`);
+        const receipt = await this.waitForReceipt(txHash);
+        if (receipt.status !== 1) {
+            throw new KwesPayError("Approval transaction reverted", "CONTRACT_ERROR");
+        }
+        await new Promise((r) => setTimeout(r, 1000));
+    }
+    async createPayment(params, onStatus) {
+        const from = await this.getAddress();
+        const amount = BigInt(params.amountBaseUnits);
+        const isNative = params.tokenAddress === ZERO_ADDRESS$1;
+        const data = encodeFunctionData({
+            abi: PAYMENT_ABI,
+            functionName: "createPayment",
+            args: [
+                ensure0x(params.paymentIdBytes32),
+                params.vendorIdentifier,
+                ensure0x(params.tokenAddress),
+                amount,
+                BigInt(params.deadline),
+                ensure0x(params.backendSignature),
+            ],
+        });
+        onStatus?.("Confirm payment", "Please approve in your wallet");
+        const txParams = {
+            from,
+            to: ensure0x(params.contractAddress),
+            data,
+        };
+        if (isNative)
+            txParams["value"] = `0x${(amount + (amount * 50n) / 10000n).toString(16)}`;
+        let txHash;
+        try {
+            txHash = (await this.provider.request({
+                method: "eth_sendTransaction",
+                params: [txParams],
+            }));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("rejected") ||
+                msg.includes("denied") ||
+                msg.includes("ACTION_REJECTED") ||
+                msg.includes("User denied")) {
+                throw new KwesPayError("Transaction cancelled by user", "WALLET_REJECTED", err);
+            }
+            throw new KwesPayError(`Contract call failed: ${msg}`, "CONTRACT_ERROR", err);
+        }
+        onStatus?.("Waiting for confirmation", `Tx: ${txHash.slice(0, 10)}…`);
+        const receipt = await this.waitForReceipt(txHash);
+        if (receipt.status !== 1) {
+            throw new KwesPayError("Payment transaction reverted", "CONTRACT_ERROR");
+        }
+        return { txHash, blockNumber: receipt.blockNumber };
+    }
+}
+
+const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+const GAS_BUFFER = 300000n * 2000000000n;
+class PaymentService {
+    constructor(provider) {
+        this.provider = provider;
+        this.contractService = new ContractService(provider);
+    }
+    async ensureCorrectNetwork(expectedChainId, expectedNetwork, onStatus) {
+        const raw = (await this.provider.request({
+            method: "eth_chainId",
+        }));
+        const current = parseInt(raw, 16);
+        if (current === expectedChainId)
+            return;
+        onStatus?.("Switching network", `Switching to ${expectedNetwork} (chain ${expectedChainId})…`);
+        try {
+            await this.provider.request({
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId: "0x" + expectedChainId.toString(16) }],
+            });
+        }
+        catch (switchErr) {
+            const errAny = switchErr;
+            if (errAny?.code === 4902) {
+                throw new KwesPayError(`Network ${expectedNetwork} (chain ${expectedChainId}) is not added to your wallet. Please add it manually and retry.`, "WRONG_NETWORK");
+            }
+            const msg = errAny?.message ?? String(switchErr);
+            if (msg.includes("rejected") ||
+                msg.includes("denied") ||
+                msg.includes("ACTION_REJECTED")) {
+                throw new KwesPayError(`Network switch to ${expectedNetwork} was rejected. Please switch manually and retry.`, "WRONG_NETWORK");
+            }
+            throw new KwesPayError(`Failed to switch to ${expectedNetwork}: ${msg}`, "WRONG_NETWORK");
+        }
+        const confirmedRaw = (await this.provider.request({
+            method: "eth_chainId",
+        }));
+        const confirmed = parseInt(confirmedRaw, 16);
+        if (confirmed !== expectedChainId) {
+            throw new KwesPayError(`Wallet is on chain ${confirmed} but payment requires chain ${expectedChainId} (${expectedNetwork}). Please switch your network and retry.`, "WRONG_NETWORK");
+        }
+    }
+    async ensureSufficientBalance(walletAddress, tokenAddress, totalBaseUnits, onStatus) {
+        const total = BigInt(totalBaseUnits);
+        const isNative = tokenAddress === ZERO_ADDRESS;
+        onStatus?.("Checking balance", "Verifying wallet balance…");
+        const nativeRaw = (await this.provider.request({
+            method: "eth_getBalance",
+            params: [walletAddress, "latest"],
+        }));
+        const nativeBalance = nativeRaw && nativeRaw !== "0x" ? BigInt(nativeRaw) : 0n;
+        if (isNative) {
+            const required = total + GAS_BUFFER;
+            if (nativeBalance < required) {
+                throw new KwesPayError(`Insufficient native balance. Required ~${(Number(required) / 1e18).toFixed(8)} (payment + fee + gas), available: ${(Number(nativeBalance) / 1e18).toFixed(8)}.`, "INSUFFICIENT_BALANCE");
+            }
+            return;
+        }
+        if (nativeBalance < GAS_BUFFER) {
+            throw new KwesPayError(`Insufficient gas balance. Need at least ${(Number(GAS_BUFFER) / 1e18).toFixed(8)} for gas, available: ${(Number(nativeBalance) / 1e18).toFixed(8)}.`, "INSUFFICIENT_BALANCE");
+        }
+        const balanceData = "0x70a08231" + walletAddress.slice(2).toLowerCase().padStart(64, "0");
+        const raw = (await this.provider.request({
+            method: "eth_call",
+            params: [{ to: tokenAddress, data: balanceData }, "latest"],
+        }));
+        const tokenBalance = raw && raw !== "0x" ? BigInt(raw) : 0n;
+        if (tokenBalance < total) {
+            throw new KwesPayError(`Insufficient token balance. Required: ${total.toString()} (amount + fee), available: ${tokenBalance.toString()} (base units).`, "INSUFFICIENT_BALANCE");
+        }
+    }
+    async pay(params) {
+        const { payload, onStatus } = params;
+        if (!payload.paymentIdBytes32 || !payload.backendSignature) {
+            throw new KwesPayError("Invalid transaction payload — missing paymentIdBytes32 or backendSignature", "TRANSACTION_FAILED");
+        }
+        if (!payload.vendorIdentifier) {
+            throw new KwesPayError("Invalid transaction payload — missing vendorIdentifier", "TRANSACTION_FAILED");
+        }
+        if (!payload.totalBaseUnits) {
+            throw new KwesPayError("Invalid transaction payload — missing totalBaseUnits", "TRANSACTION_FAILED");
+        }
+        if (!payload.deadline) {
+            throw new KwesPayError("Invalid transaction payload — missing deadline", "TRANSACTION_FAILED");
+        }
+        if (BigInt(payload.totalBaseUnits) < BigInt(payload.amountBaseUnits)) {
+            throw new KwesPayError("Invalid transaction payload — totalBaseUnits cannot be less than amountBaseUnits", "TRANSACTION_FAILED");
+        }
+        await this.ensureCorrectNetwork(payload.chainId, payload.network, onStatus);
+        const accounts = (await this.provider.request({
+            method: "eth_requestAccounts",
+        }));
+        const walletAddress = accounts[0];
+        await this.ensureSufficientBalance(walletAddress, payload.tokenAddress, payload.totalBaseUnits, onStatus);
+        const contractAddress = resolveContractAddress(payload.network);
+        await this.contractService.ensureApproval(payload.tokenAddress, payload.totalBaseUnits, contractAddress, payload.chainId, onStatus);
+        const { txHash, blockNumber } = await this.contractService.createPayment({
+            paymentIdBytes32: payload.paymentIdBytes32,
+            vendorIdentifier: payload.vendorIdentifier,
+            tokenAddress: payload.tokenAddress,
+            amountBaseUnits: payload.amountBaseUnits,
+            totalBaseUnits: payload.totalBaseUnits,
+            backendSignature: payload.backendSignature,
+            contractAddress,
+            deadline: payload.deadline,
+            chainId: payload.chainId,
+        }, onStatus);
+        return {
+            txHash,
+            blockNumber,
+            transactionReference: payload.transactionReference,
+            paymentIdBytes32: payload.paymentIdBytes32,
+        };
+    }
+}
+
+const PLATFORM_FEE_BPS = 50n; // 0.5%
+const BASIS_POINTS = 10000n;
+function computeFee(amountBaseUnits) {
+    return (BigInt(amountBaseUnits) * PLATFORM_FEE_BPS) / BASIS_POINTS;
+}
+function computeTotal(amountBaseUnits) {
+    return (BigInt(amountBaseUnits) + computeFee(amountBaseUnits)).toString();
+}
+class KwesPayClient {
+    constructor(config) {
+        if (!config.apiKey)
+            throw new KwesPayError("apiKey is required", "INVALID_KEY");
+        this.apiKey = config.apiKey;
+    }
+    async validateKey() {
+        const data = await gqlRequest(GQL_VALIDATE_KEY, {
+            accessKey: this.apiKey,
+        });
+        const r = data.validateAccessKey;
+        if (!r.isValid) {
+            return {
+                isValid: false,
+                error: r.error ?? "Invalid access key",
+            };
+        }
+        return {
+            isValid: true,
+            keyId: r.keyId,
+            keyLabel: r.keyLabel,
+            activeFlag: r.activeFlag,
+            expirationDate: r.expirationDate,
+            vendorInfo: r.vendorInfo,
+            scope: {
+                allowedVendors: r.allowedVendors ?? null,
+                allowedNetworks: r.allowedNetworks ?? null,
+                allowedTokens: r.allowedTokens ?? null,
+            },
+        };
+    }
+    // getQuote (price preview only — no transaction created)
+    async getQuote(params) {
+        const data = await gqlRequest(GQL_CREATE_QUOTE, {
+            input: {
+                vendorIdentifier: params.vendorIdentifier,
+                fiatAmount: params.fiatAmount,
+                fiatCurrency: params.fiatCurrency ?? "USD",
+                cryptoCurrency: params.cryptoCurrency,
+                network: params.network,
+            },
+        }, this.apiKey);
+        const q = data.createQuote;
+        if (!q.success) {
+            const msg = q.message ?? "Quote creation failed";
+            throw new KwesPayError(msg, _quoteErrCode(msg));
+        }
+        return {
+            quoteId: q.quoteId,
+            cryptoCurrency: q.cryptoCurrency,
+            tokenAddress: q.tokenAddress,
+            amountBaseUnits: q.amountBaseUnits,
+            // totalBaseUnits = amountBaseUnits + fee — safe to compute here for UI
+            totalBaseUnits: computeTotal(q.amountBaseUnits),
+            displayAmount: q.displayAmount,
+            network: q.network,
+            chainId: q.chainId,
+            expiresAt: q.expiresAt,
+        };
+    }
+    //  quote() — full flow: price + transaction, returns wallet-ready payload 
+    async quote(params) {
+        // Step 1 — get price & lock quote
+        const quoteData = await gqlRequest(GQL_CREATE_QUOTE, {
+            input: {
+                vendorIdentifier: params.vendorIdentifier,
+                fiatAmount: params.fiatAmount,
+                fiatCurrency: params.fiatCurrency ?? "USD",
+                cryptoCurrency: params.cryptoCurrency,
+                network: params.network,
+            },
+        }, this.apiKey);
+        const q = quoteData.createQuote;
+        if (!q.success) {
+            const msg = q.message ?? "Quote creation failed";
+            throw new KwesPayError(msg, _quoteErrCode(msg));
+        }
+        // Step 2 — create transaction (backend signs payment params incl. deadline)
+        const txData = await gqlRequest(GQL_CREATE_TRANSACTION, {
+            input: {
+                quoteId: q.quoteId,
+                payerWalletAddress: params.payerWalletAddress,
+            },
+        }, this.apiKey);
+        const t = txData.createTransaction;
+        if (!t.success) {
+            const msg = t.message ?? "Transaction creation failed";
+            throw new KwesPayError(msg, _txErrCode(msg));
+        }
+        // deadline must be present — it's part of the on-chain signature
+        if (!t.deadline) {
+            throw new KwesPayError("Backend did not return a deadline. Cannot construct a valid payment.", "TRANSACTION_FAILED");
+        }
+        // totalBaseUnits: what the customer must actually send (amount + fee).
+        // We compute this from the signed amountBaseUnits using the same formula
+        // the contract uses: (amount * 50) / 10000.  We do NOT trust a
+        // client-side totalBaseUnits for security — but computing it here is safe
+        // because amountBaseUnits came from the backend-signed response.
+        const amountBaseUnits = t.amountBaseUnits;
+        const totalBaseUnits = computeTotal(amountBaseUnits);
+        return {
+            paymentIdBytes32: t.paymentIdBytes32,
+            backendSignature: t.backendSignature,
+            tokenAddress: t.tokenAddress,
+            amountBaseUnits,
+            totalBaseUnits,
+            chainId: t.chainId,
+            deadline: t.deadline, // ← from backend, part of signed hash
+            expiresAt: t.expiresAt,
+            transactionReference: t.transaction.transactionReference,
+            transactionStatus: t.transaction.transactionStatus,
+            network: params.network,
+            vendorIdentifier: params.vendorIdentifier,
+        };
+    }
+    // pay()
+    async pay(params) {
+        return new PaymentService(params.provider).pay(params);
+    }
+    //  status polling
+    async getTransactionStatus(transactionReference) {
+        const data = await gqlRequest(GQL_TRANSACTION_STATUS, { transactionReference });
+        const r = data.getTransactionStatus;
+        return {
+            transactionReference: r.transactionReference,
+            transactionStatus: r.transactionStatus,
+            blockchainHash: r.blockchainHash,
+            blockchainNetwork: r.blockchainNetwork,
+            displayAmount: r.displayAmount,
+            cryptoCurrency: r.cryptoCurrency,
+            payerWalletAddress: r.payerWalletAddress,
+            initiatedAt: r.initiatedAt,
+        };
+    }
+    async pollTransactionStatus(transactionReference, options = {}) {
+        const { onStatus, intervalMs = 4000, maxAttempts = 60 } = options;
+        let attempts = 0;
+        const terminal = [
+            "completed",
+            "failed",
+            "expired",
+            "underpaid",
+            "overpaid",
+            "refunded",
+        ];
+        return new Promise((resolve, reject) => {
+            const id = setInterval(async () => {
+                attempts++;
+                try {
+                    const status = await this.getTransactionStatus(transactionReference);
+                    onStatus?.(status.transactionStatus);
+                    if (terminal.includes(status.transactionStatus)) {
+                        clearInterval(id);
+                        resolve(status);
+                    }
+                    else if (attempts >= maxAttempts) {
+                        clearInterval(id);
+                        reject(new KwesPayError("Status polling timed out", "UNKNOWN"));
+                    }
+                }
+                catch (err) {
+                    if (attempts >= maxAttempts) {
+                        clearInterval(id);
+                        reject(err);
+                    }
+                }
+            }, intervalMs);
+        });
+    }
+}
+//  Error code helpers 
+function _quoteErrCode(msg) {
+    const m = msg.toLowerCase();
+    if (m.includes("expired"))
+        return "QUOTE_EXPIRED";
+    if (m.includes("key"))
+        return "INVALID_KEY";
+    return "UNKNOWN";
+}
+function _txErrCode(msg) {
+    const m = msg.toLowerCase();
+    if (m.includes("expired"))
+        return "QUOTE_EXPIRED";
+    if (m.includes("already been used"))
+        return "QUOTE_USED";
+    if (m.includes("not found"))
+        return "QUOTE_NOT_FOUND";
+    if (m.includes("key"))
+        return "INVALID_KEY";
+    return "UNKNOWN";
+}
+
+export { KwesPayClient, KwesPayError };