@kwespay/widget 1.0.3 → 1.0.5

package/dist/{kwespay-widget.esm.js → esm/index.js}

@@ -805,3045 +805,6 @@ class WalletService {
   }
 }
 
-class KwesPayError extends Error {
-    constructor(message, code, cause) {
-        super(message);
-        this.name = "KwesPayError";
-        this.code = code;
-        this.cause = cause;
-    }
-}
-
-const ENDPOINT = "https://d502-154-161-98-26.ngrok-free.app/graphql";
-const TESTNET_CONTRACTS = {
-    sepolia: "0x39bE436D6A34d0990cb71c9cBD24a5361d85e00B",
-    baseSepolia: "0x7515b1b1BcA33E7a9ccBd5E2b93771884654De77",
-    polygonAmoy: "0xD31dF3eBd220Fd3e190A346F8927819295d28980",
-    liskTestnet: "0xd04A78a998146EBAD04c2b68E020C06Dc3b3717f",
-};
-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
-    }
-  }
-`;
-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, 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,
-                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.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;
-let PaymentService$1 = 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, amountBaseUnits, onStatus) {
-        const amount = BigInt(amountBaseUnits);
-        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 = amount + GAS_BUFFER;
-            if (nativeBalance < required) {
-                throw new KwesPayError(`Insufficient native balance. Required ~${(Number(required) / 1e18).toFixed(8)} ETH (payment + gas), available: ${(Number(nativeBalance) / 1e18).toFixed(8)} ETH.`, "INSUFFICIENT_BALANCE");
-            }
-            return;
-        }
-        if (nativeBalance < GAS_BUFFER) {
-            throw new KwesPayError(`Insufficient gas balance. Need at least ${(Number(GAS_BUFFER) / 1e18).toFixed(8)} ETH for gas, available: ${(Number(nativeBalance) / 1e18).toFixed(8)} ETH.`, "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 < amount) {
-            throw new KwesPayError(`Insufficient token balance. Required: ${amount.toString()}, available: ${tokenBalance.toString()} (base units).`, "INSUFFICIENT_BALANCE");
-        }
-    }
-    async pay(params) {
-        const { provider, 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");
-        }
-        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.amountBaseUnits, onStatus);
-        const contractAddress = resolveContractAddress(payload.network);
-        await this.contractService.ensureApproval(payload.tokenAddress, payload.amountBaseUnits, contractAddress, payload.chainId, onStatus);
-        const { txHash, blockNumber } = await this.contractService.createPayment({
-            paymentIdBytes32: payload.paymentIdBytes32,
-            vendorIdentifier: payload.vendorIdentifier,
-            tokenAddress: payload.tokenAddress,
-            amountBaseUnits: payload.amountBaseUnits,
-            backendSignature: payload.backendSignature,
-            contractAddress,
-            chainId: payload.chainId,
-        }, onStatus);
-        return {
-            txHash,
-            blockNumber,
-            transactionReference: payload.transactionReference,
-            paymentIdBytes32: payload.paymentIdBytes32,
-        };
-    }
-};
-
-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,
-            },
-        };
-    }
-    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";
-            const code = msg.toLowerCase().includes("expired")
-                ? "QUOTE_EXPIRED"
-                : msg.toLowerCase().includes("key")
-                    ? "INVALID_KEY"
-                    : "UNKNOWN";
-            throw new KwesPayError(msg, code);
-        }
-        return {
-            quoteId: q.quoteId,
-            cryptoCurrency: q.cryptoCurrency,
-            tokenAddress: q.tokenAddress,
-            amountBaseUnits: q.amountBaseUnits,
-            displayAmount: q.displayAmount,
-            network: q.network,
-            chainId: q.chainId,
-            expiresAt: q.expiresAt,
-        };
-    }
-    async quote(params) {
-        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";
-            const code = msg.toLowerCase().includes("expired")
-                ? "QUOTE_EXPIRED"
-                : msg.toLowerCase().includes("key")
-                    ? "INVALID_KEY"
-                    : "UNKNOWN";
-            throw new KwesPayError(msg, code);
-        }
-        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";
-            const code = msg.toLowerCase().includes("expired")
-                ? "QUOTE_EXPIRED"
-                : msg.toLowerCase().includes("already been used")
-                    ? "QUOTE_USED"
-                    : msg.toLowerCase().includes("not found")
-                        ? "QUOTE_NOT_FOUND"
-                        : msg.toLowerCase().includes("key")
-                            ? "INVALID_KEY"
-                            : "UNKNOWN";
-            throw new KwesPayError(msg, code);
-        }
-        return {
-            paymentIdBytes32: t.paymentIdBytes32,
-            backendSignature: t.backendSignature,
-            tokenAddress: t.tokenAddress,
-            amountBaseUnits: t.amountBaseUnits,
-            chainId: t.chainId,
-            expiresAt: t.expiresAt,
-            transactionReference: t.transaction.transactionReference,
-            transactionStatus: t.transaction.transactionStatus,
-            network: params.network,
-            vendorIdentifier: params.vendorIdentifier,
-        };
-    }
-    async pay(params) {
-        return new PaymentService$1(params.provider).pay(params);
-    }
-    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);
-        });
-    }
-}
-
 class PaymentService {
   constructor(apiKey, graphqlEndpoint) {
     this.apiKey = apiKey;
@@ -3855,10 +816,13 @@ class PaymentService {
     });
   }
 
-  _initClient() {
+  async _initClient() {
     if (this.client) return;
 
     console.log("[KwesPay] Initializing SDK client...");
+
+    const { KwesPayClient } = await import('./index-338l55OY.js');
+
     this.client = new KwesPayClient({ apiKey: this.apiKey });
 
     console.log("[KwesPay] SDK client ready");
@@ -3866,7 +830,7 @@ class PaymentService {
 
   async validateAPIKey() {
     try {
-      this._initClient();
+      await this._initClient();
 
       const result = await this.client.validateKey();
 
@@ -3890,7 +854,7 @@ class PaymentService {
   }
 
   async getQuote(params) {
-    this._initClient();
+    await this._initClient();
 
     console.log("[KwesPay] Requesting quote...", params);
 
@@ -3909,7 +873,7 @@ class PaymentService {
   }
 
   async createPayment({ payload, walletProvider, onStatusUpdate }) {
-    this._initClient();
+    await this._initClient();
 
     console.log("[KwesPay] 💳 createPayment called", {
       payloadKeys: payload ? Object.keys(payload) : null,
@@ -3970,7 +934,7 @@ class PaymentService {
   }
 
   async getTransactionStatus(transactionReference) {
-    this._initClient();
+    await this._initClient();
 
     console.log("[KwesPay] Fetching transaction status:", transactionReference);
 
@@ -3985,7 +949,7 @@ class PaymentService {
     transactionReference,
     { onStatus, intervalMs = 4000, maxAttempts = 60 } = {}
   ) {
-    this._initClient();
+    await this._initClient();
 
     console.log("[KwesPay] Starting polling...", {
       transactionReference,