coinley-checkout
Version:
A React SDK for Coinley cryptocurrency payment processing with multi-network support
1,422 lines • 687 kB
JavaScript
import { B, _, c as clsx, h, y } from "./hooks.module-69e9d77d.mjs";
import { a as assertSize$3, b as padRight$2, B as BaseError$2, d as getChainContractAddress, e as encodeFunctionData, f as addressResolverAbi, n as namehash, u as universalResolverResolveAbi, t as toHex$2, h as packetToBytes, l as localBatchGatewayUrl, i as getAction, r as readContract, j as decodeFunctionResult, k as trim, m as isNullUniversalResolverError, o as assertRequest, q as numberToHex, s as formatTransactionRequest, v as extract, w as getCallError, x as parseAccount, y as BaseError$3, z as getAbiItem, A as AbiEventNotFoundError, C as formatAbiItem$1, D as toEventSelector, E as keccak256$1, F as toBytes$4, G as encodeAbiParameters, H as estimateGas, I as getContractError$1, J as hexToNumber$1, K as AbiEventSignatureEmptyTopicsError, L as AbiEventSignatureNotFoundError, M as DecodeLogTopicsMismatch, N as decodeAbiParameters, O as AbiDecodingDataSizeTooSmallError, P as PositionOutOfBoundsError, Q as DecodeLogDataMismatch, R as size$3, S as formatLog, T as TransactionNotFoundError, U as formatTransaction, V as TransactionReceiptNotFoundError, W as formatTransactionReceipt, X as toRpc, Y as concat$1, Z as serializeStateOverride, _ as formatBlock, $ as AbiDecodingZeroDataError, a0 as RawContractError, a1 as getNodeError, a2 as UnknownNodeError, a3 as fromBytes$3, a4 as validate$3, a5 as slice$2, a6 as fromString$2, a7 as size$4, a8 as fromNumber$1, a9 as concat$2, aa as padLeft$1, ab as fromBoolean, ac as IntegerOutOfRangeError$1, ad as getTypesForEIP712Domain, ae as validateTypedData, af as AbiEncodingLengthMismatchError, ag as concatHex, ah as isAddress, ai as InvalidAddressError$1, aj as pad$2, ak as stringToHex, al as boolToHex, am as integerRegex$2, an as bytesRegex$2, ao as BytesSizeMismatchError$1, ap as arrayRegex$1, aq as UnsupportedPackedAbiType, ar as bytesToHex$2, as as sliceHex, at as hexToBytes$1, au as LruMap$1, av as deploylessCallViaBytecodeBytecode, aw as hexToBigInt, ax as wait, ay as stringify$1, az as getBlock, aA as InvalidInputRpcError, aB as receiptStatuses, aC as withResolvers, aD as withRetry, aE as WaitForTransactionReceiptTimeoutError, aF as BlockNotFoundError, aG as AccountNotFoundError, aH as getChainId, aI as getTransactionCount, aJ as call, aK as isHex, aL as universalSignatureValidatorAbi, aM as encodeDeployData, aN as universalSignatureValidatorByteCode, aO as hexToBool, aP as getAddress, aQ as recoverAddress, aR as CallExecutionError, aS as getBalance, aT as getEnsAvatar, aU as getEnsName, aV as getEnsText, aW as estimateFeesPerGas, aX as getGasPrice, aY as estimateMaxPriorityFeePerGas, aZ as multicall, a_ as prepareTransactionRequest, a$ as sendRawTransaction, b0 as createClient, b1 as parseAbi, b2 as prettyPrint, b3 as formatGwei, b4 as decodeErrorResult, b5 as ContractFunctionZeroDataError, b6 as ContractFunctionRevertedError, b7 as ContractFunctionExecutionError, b8 as EventEmitter, b9 as defineChain, ba as http, bb as slice$3, bc as stringToBytes, bd as decodeFunctionData, be as hexToString, bf as erc20Abi, bg as getAugmentedNamespace, g as getDefaultExportFromCjs } from "./index-1c96ce10.mjs";
import { B as Buffer } from "./index-2161e56b.mjs";
import { i as isAddressEqual } from "./isAddressEqual-dc4a956e.mjs";
import { secp256k1 } from "./secp256k1-2fbdf512.mjs";
import { c as createStore$1, g as get$1, d as del, s as set } from "./index-ad797676.mjs";
import "react";
/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
function isBytes$4(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
}
function anumber$1(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error("positive integer expected, got " + n);
}
function abytes$2(b, ...lengths) {
if (!isBytes$4(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);
}
function aexists$2(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");
}
function aoutput$2(out, instance) {
abytes$2(out);
const min = instance.outputLen;
if (out.length < min) {
throw new Error("digestInto() expects output buffer of length at least " + min);
}
}
function u32(arr) {
return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
}
function clean$2(...arrays) {
for (let i = 0; i < arrays.length; i++) {
arrays[i].fill(0);
}
}
const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
function byteSwap(word) {
return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
}
function byteSwap32(arr) {
for (let i = 0; i < arr.length; i++) {
arr[i] = byteSwap(arr[i]);
}
return arr;
}
const swap32IfBE = isLE ? (u) => u : byteSwap32;
function utf8ToBytes$3(str) {
if (typeof str !== "string")
throw new Error("string expected");
return new Uint8Array(new TextEncoder().encode(str));
}
function toBytes$3(data) {
if (typeof data === "string")
data = utf8ToBytes$3(data);
abytes$2(data);
return data;
}
let Hash$3 = class Hash {
};
function createHasher$2(hashCons) {
const hashC = (msg) => hashCons().update(toBytes$3(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function assertSize$2(bytes2, size_) {
if (size$2(bytes2) > size_)
throw new SizeOverflowError$2({
givenSize: size$2(bytes2),
maxSize: size_
});
}
const charCodeMap$1 = {
zero: 48,
nine: 57,
A: 65,
F: 70,
a: 97,
f: 102
};
function charCodeToBase16$1(char) {
if (char >= charCodeMap$1.zero && char <= charCodeMap$1.nine)
return char - charCodeMap$1.zero;
if (char >= charCodeMap$1.A && char <= charCodeMap$1.F)
return char - (charCodeMap$1.A - 10);
if (char >= charCodeMap$1.a && char <= charCodeMap$1.f)
return char - (charCodeMap$1.a - 10);
return void 0;
}
function pad$1(bytes2, options = {}) {
const { dir, size: size2 = 32 } = options;
if (size2 === 0)
return bytes2;
if (bytes2.length > size2)
throw new SizeExceedsPaddingSizeError$1({
size: bytes2.length,
targetSize: size2,
type: "Bytes"
});
const paddedBytes = new Uint8Array(size2);
for (let i = 0; i < size2; i++) {
const padEnd = dir === "right";
paddedBytes[padEnd ? i : size2 - i - 1] = bytes2[padEnd ? i : bytes2.length - i - 1];
}
return paddedBytes;
}
const encoder$1 = /* @__PURE__ */ new TextEncoder();
function from$6(value) {
if (value instanceof Uint8Array)
return value;
if (typeof value === "string")
return fromHex$4(value);
return fromArray$1(value);
}
function fromArray$1(value) {
return value instanceof Uint8Array ? value : new Uint8Array(value);
}
function fromHex$4(value, options = {}) {
const { size: size2 } = options;
let hex = value;
if (size2) {
assertSize$3(value, size2);
hex = padRight$2(value, size2);
}
let hexString = hex.slice(2);
if (hexString.length % 2)
hexString = `0${hexString}`;
const length = hexString.length / 2;
const bytes2 = new Uint8Array(length);
for (let index = 0, j = 0; index < length; index++) {
const nibbleLeft = charCodeToBase16$1(hexString.charCodeAt(j++));
const nibbleRight = charCodeToBase16$1(hexString.charCodeAt(j++));
if (nibbleLeft === void 0 || nibbleRight === void 0) {
throw new BaseError$2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
}
bytes2[index] = nibbleLeft * 16 + nibbleRight;
}
return bytes2;
}
function fromString$1(value, options = {}) {
const { size: size2 } = options;
const bytes2 = encoder$1.encode(value);
if (typeof size2 === "number") {
assertSize$2(bytes2, size2);
return padRight$1(bytes2, size2);
}
return bytes2;
}
function padRight$1(value, size2) {
return pad$1(value, { dir: "right", size: size2 });
}
function size$2(value) {
return value.length;
}
let SizeOverflowError$2 = class SizeOverflowError extends BaseError$2 {
constructor({ givenSize, maxSize }) {
super(`Size cannot exceed \`${maxSize}\` bytes. Given size: \`${givenSize}\` bytes.`);
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "Bytes.SizeOverflowError"
});
}
};
let SizeExceedsPaddingSizeError$1 = class SizeExceedsPaddingSizeError extends BaseError$2 {
constructor({ size: size2, targetSize, type }) {
super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (\`${size2}\`) exceeds padding size (\`${targetSize}\`).`);
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "Bytes.SizeExceedsPaddingSizeError"
});
}
};
async function getEnsAddress(client, parameters) {
const { blockNumber, blockTag, coinType, name, gatewayUrls, strict } = parameters;
const { chain } = client;
const universalResolverAddress = (() => {
if (parameters.universalResolverAddress)
return parameters.universalResolverAddress;
if (!chain)
throw new Error("client chain not configured. universalResolverAddress is required.");
return getChainContractAddress({
blockNumber,
chain,
contract: "ensUniversalResolver"
});
})();
const tlds = chain?.ensTlds;
if (tlds && !tlds.some((tld) => name.endsWith(tld)))
return null;
try {
const functionData = encodeFunctionData({
abi: addressResolverAbi,
functionName: "addr",
...coinType != null ? { args: [namehash(name), BigInt(coinType)] } : { args: [namehash(name)] }
});
const readContractParameters = {
address: universalResolverAddress,
abi: universalResolverResolveAbi,
functionName: "resolve",
args: [
toHex$2(packetToBytes(name)),
functionData,
gatewayUrls ?? [localBatchGatewayUrl]
],
blockNumber,
blockTag
};
const readContractAction = getAction(client, readContract, "readContract");
const res = await readContractAction(readContractParameters);
if (res[0] === "0x")
return null;
const address = decodeFunctionResult({
abi: addressResolverAbi,
args: coinType != null ? [namehash(name), BigInt(coinType)] : void 0,
functionName: "addr",
data: res[0]
});
if (address === "0x")
return null;
if (trim(address) === "0x00")
return null;
return address;
} catch (err) {
if (strict)
throw err;
if (isNullUniversalResolverError(err, "resolve"))
return null;
throw err;
}
}
async function getEnsResolver(client, parameters) {
const { blockNumber, blockTag, name } = parameters;
const { chain } = client;
const universalResolverAddress = (() => {
if (parameters.universalResolverAddress)
return parameters.universalResolverAddress;
if (!chain)
throw new Error("client chain not configured. universalResolverAddress is required.");
return getChainContractAddress({
blockNumber,
chain,
contract: "ensUniversalResolver"
});
})();
const tlds = chain?.ensTlds;
if (tlds && !tlds.some((tld) => name.endsWith(tld)))
throw new Error(`${name} is not a valid ENS TLD (${tlds?.join(", ")}) for chain "${chain.name}" (id: ${chain.id}).`);
const [resolverAddress] = await getAction(client, readContract, "readContract")({
address: universalResolverAddress,
abi: [
{
inputs: [{ type: "bytes" }],
name: "findResolver",
outputs: [{ type: "address" }, { type: "bytes32" }],
stateMutability: "view",
type: "function"
}
],
functionName: "findResolver",
args: [toHex$2(packetToBytes(name))],
blockNumber,
blockTag
});
return resolverAddress;
}
async function createAccessList(client, args) {
const { account: account_ = client.account, blockNumber, blockTag = "latest", blobs, data, gas, gasPrice, maxFeePerBlobGas, maxFeePerGas, maxPriorityFeePerGas, to, value, ...rest } = args;
const account2 = account_ ? parseAccount(account_) : void 0;
try {
assertRequest(args);
const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
const block = blockNumberHex || blockTag;
const chainFormat = client.chain?.formatters?.transactionRequest?.format;
const format = chainFormat || formatTransactionRequest;
const request = format({
// Pick out extra data that might exist on the chain's transaction request type.
...extract(rest, { format: chainFormat }),
from: account2?.address,
blobs,
data,
gas,
gasPrice,
maxFeePerBlobGas,
maxFeePerGas,
maxPriorityFeePerGas,
to,
value
});
const response = await client.request({
method: "eth_createAccessList",
params: [request, block]
});
return {
accessList: response.accessList,
gasUsed: BigInt(response.gasUsed)
};
} catch (err) {
throw getCallError(err, {
...args,
account: account2,
chain: client.chain
});
}
}
function createFilterRequestScope(client, { method }) {
const requestMap = {};
if (client.transport.type === "fallback")
client.transport.onResponse?.(({ method: method_, response: id, status, transport }) => {
if (status === "success" && method === method_)
requestMap[id] = transport.request;
});
return (id) => requestMap[id] || client.request;
}
async function createBlockFilter(client) {
const getRequest = createFilterRequestScope(client, {
method: "eth_newBlockFilter"
});
const id = await client.request({
method: "eth_newBlockFilter"
});
return { id, request: getRequest(id), type: "block" };
}
class FilterTypeNotSupportedError extends BaseError$3 {
constructor(type) {
super(`Filter type "${type}" is not supported.`, {
name: "FilterTypeNotSupportedError"
});
}
}
const docsPath$1 = "/docs/contract/encodeEventTopics";
function encodeEventTopics(parameters) {
const { abi: abi2, eventName, args } = parameters;
let abiItem = abi2[0];
if (eventName) {
const item = getAbiItem({ abi: abi2, name: eventName });
if (!item)
throw new AbiEventNotFoundError(eventName, { docsPath: docsPath$1 });
abiItem = item;
}
if (abiItem.type !== "event")
throw new AbiEventNotFoundError(void 0, { docsPath: docsPath$1 });
const definition = formatAbiItem$1(abiItem);
const signature = toEventSelector(definition);
let topics = [];
if (args && "inputs" in abiItem) {
const indexedInputs = abiItem.inputs?.filter((param) => "indexed" in param && param.indexed);
const args_ = Array.isArray(args) ? args : Object.values(args).length > 0 ? indexedInputs?.map((x) => args[x.name]) ?? [] : [];
if (args_.length > 0) {
topics = indexedInputs?.map((param, i) => {
if (Array.isArray(args_[i]))
return args_[i].map((_2, j) => encodeArg({ param, value: args_[i][j] }));
return typeof args_[i] !== "undefined" && args_[i] !== null ? encodeArg({ param, value: args_[i] }) : null;
}) ?? [];
}
}
return [signature, ...topics];
}
function encodeArg({ param, value }) {
if (param.type === "string" || param.type === "bytes")
return keccak256$1(toBytes$4(value));
if (param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
throw new FilterTypeNotSupportedError(param.type);
return encodeAbiParameters([param], [value]);
}
async function createContractEventFilter(client, parameters) {
const { address, abi: abi2, args, eventName, fromBlock, strict, toBlock } = parameters;
const getRequest = createFilterRequestScope(client, {
method: "eth_newFilter"
});
const topics = eventName ? encodeEventTopics({
abi: abi2,
args,
eventName
}) : void 0;
const id = await client.request({
method: "eth_newFilter",
params: [
{
address,
fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
topics
}
]
});
return {
abi: abi2,
args,
eventName,
id,
request: getRequest(id),
strict: Boolean(strict),
type: "event"
};
}
async function createEventFilter(client, { address, args, event, events: events_, fromBlock, strict, toBlock } = {}) {
const events = events_ ?? (event ? [event] : void 0);
const getRequest = createFilterRequestScope(client, {
method: "eth_newFilter"
});
let topics = [];
if (events) {
const encoded = events.flatMap((event2) => encodeEventTopics({
abi: [event2],
eventName: event2.name,
args
}));
topics = [encoded];
if (event)
topics = topics[0];
}
const id = await client.request({
method: "eth_newFilter",
params: [
{
address,
fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
...topics.length ? { topics } : {}
}
]
});
return {
abi: events,
args,
eventName: event ? event.name : void 0,
fromBlock,
id,
request: getRequest(id),
strict: Boolean(strict),
toBlock,
type: "event"
};
}
async function createPendingTransactionFilter(client) {
const getRequest = createFilterRequestScope(client, {
method: "eth_newPendingTransactionFilter"
});
const id = await client.request({
method: "eth_newPendingTransactionFilter"
});
return { id, request: getRequest(id), type: "transaction" };
}
async function estimateContractGas(client, parameters) {
const { abi: abi2, address, args, functionName, dataSuffix, ...request } = parameters;
const data = encodeFunctionData({
abi: abi2,
args,
functionName
});
try {
const gas = await getAction(client, estimateGas, "estimateGas")({
data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
to: address,
...request
});
return gas;
} catch (error) {
const account2 = request.account ? parseAccount(request.account) : void 0;
throw getContractError$1(error, {
abi: abi2,
address,
args,
docsPath: "/docs/contract/estimateContractGas",
functionName,
sender: account2?.address
});
}
}
async function getBlobBaseFee(client) {
const baseFee = await client.request({
method: "eth_blobBaseFee"
});
return BigInt(baseFee);
}
const promiseCache = /* @__PURE__ */ new Map();
const responseCache = /* @__PURE__ */ new Map();
function getCache(cacheKey2) {
const buildCache = (cacheKey3, cache) => ({
clear: () => cache.delete(cacheKey3),
get: () => cache.get(cacheKey3),
set: (data) => cache.set(cacheKey3, data)
});
const promise = buildCache(cacheKey2, promiseCache);
const response = buildCache(cacheKey2, responseCache);
return {
clear: () => {
promise.clear();
response.clear();
},
promise,
response
};
}
async function withCache(fn, { cacheKey: cacheKey2, cacheTime = Number.POSITIVE_INFINITY }) {
const cache = getCache(cacheKey2);
const response = cache.response.get();
if (response && cacheTime > 0) {
const age = (/* @__PURE__ */ new Date()).getTime() - response.created.getTime();
if (age < cacheTime)
return response.data;
}
let promise = cache.promise.get();
if (!promise) {
promise = fn();
cache.promise.set(promise);
}
try {
const data = await promise;
cache.response.set({ created: /* @__PURE__ */ new Date(), data });
return data;
} finally {
cache.promise.clear();
}
}
const cacheKey = (id) => `blockNumber.${id}`;
async function getBlockNumber(client, { cacheTime = client.cacheTime } = {}) {
const blockNumberHex = await withCache(() => client.request({
method: "eth_blockNumber"
}), { cacheKey: cacheKey(client.uid), cacheTime });
return BigInt(blockNumberHex);
}
async function getBlockTransactionCount(client, { blockHash, blockNumber, blockTag = "latest" } = {}) {
const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
let count;
if (blockHash) {
count = await client.request({
method: "eth_getBlockTransactionCountByHash",
params: [blockHash]
}, { dedupe: true });
} else {
count = await client.request({
method: "eth_getBlockTransactionCountByNumber",
params: [blockNumberHex || blockTag]
}, { dedupe: Boolean(blockNumberHex) });
}
return hexToNumber$1(count);
}
async function getCode(client, { address, blockNumber, blockTag = "latest" }) {
const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
const hex = await client.request({
method: "eth_getCode",
params: [address, blockNumberHex || blockTag]
}, { dedupe: Boolean(blockNumberHex) });
if (hex === "0x")
return void 0;
return hex;
}
const docsPath = "/docs/contract/decodeEventLog";
function decodeEventLog(parameters) {
const { abi: abi2, data, strict: strict_, topics } = parameters;
const strict = strict_ ?? true;
const [signature, ...argTopics] = topics;
if (!signature)
throw new AbiEventSignatureEmptyTopicsError({ docsPath });
const abiItem = abi2.find((x) => x.type === "event" && signature === toEventSelector(formatAbiItem$1(x)));
if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
throw new AbiEventSignatureNotFoundError(signature, { docsPath });
const { name, inputs } = abiItem;
const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
const args = isUnnamed ? [] : {};
const indexedInputs = inputs.map((x, i) => [x, i]).filter(([x]) => "indexed" in x && x.indexed);
for (let i = 0; i < indexedInputs.length; i++) {
const [param, argIndex] = indexedInputs[i];
const topic = argTopics[i];
if (!topic)
throw new DecodeLogTopicsMismatch({
abiItem,
param
});
args[isUnnamed ? argIndex : param.name || argIndex] = decodeTopic({
param,
value: topic
});
}
const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
if (nonIndexedInputs.length > 0) {
if (data && data !== "0x") {
try {
const decodedData = decodeAbiParameters(nonIndexedInputs, data);
if (decodedData) {
if (isUnnamed)
for (let i = 0; i < inputs.length; i++)
args[i] = args[i] ?? decodedData.shift();
else
for (let i = 0; i < nonIndexedInputs.length; i++)
args[nonIndexedInputs[i].name] = decodedData[i];
}
} catch (err) {
if (strict) {
if (err instanceof AbiDecodingDataSizeTooSmallError || err instanceof PositionOutOfBoundsError)
throw new DecodeLogDataMismatch({
abiItem,
data,
params: nonIndexedInputs,
size: size$3(data)
});
throw err;
}
}
} else if (strict) {
throw new DecodeLogDataMismatch({
abiItem,
data: "0x",
params: nonIndexedInputs,
size: 0
});
}
}
return {
eventName: name,
args: Object.values(args).length > 0 ? args : void 0
};
}
function decodeTopic({ param, value }) {
if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
return value;
const decodedArg = decodeAbiParameters([param], value) || [];
return decodedArg[0];
}
function parseEventLogs(parameters) {
const { abi: abi2, args, logs, strict = true } = parameters;
const eventName = (() => {
if (!parameters.eventName)
return void 0;
if (Array.isArray(parameters.eventName))
return parameters.eventName;
return [parameters.eventName];
})();
return logs.map((log) => {
try {
const abiItem = abi2.find((abiItem2) => abiItem2.type === "event" && log.topics[0] === toEventSelector(abiItem2));
if (!abiItem)
return null;
const event = decodeEventLog({
...log,
abi: [abiItem],
strict
});
if (eventName && !eventName.includes(event.eventName))
return null;
if (!includesArgs({
args: event.args,
inputs: abiItem.inputs,
matchArgs: args
}))
return null;
return { ...event, ...log };
} catch (err) {
let eventName2;
let isUnnamed;
if (err instanceof AbiEventSignatureNotFoundError)
return null;
if (err instanceof DecodeLogDataMismatch || err instanceof DecodeLogTopicsMismatch) {
if (strict)
return null;
eventName2 = err.abiItem.name;
isUnnamed = err.abiItem.inputs?.some((x) => !("name" in x && x.name));
}
return { ...log, args: isUnnamed ? [] : {}, eventName: eventName2 };
}
}).filter(Boolean);
}
function includesArgs(parameters) {
const { args, inputs, matchArgs } = parameters;
if (!matchArgs)
return true;
if (!args)
return false;
function isEqual(input, value, arg) {
try {
if (input.type === "address")
return isAddressEqual(value, arg);
if (input.type === "string" || input.type === "bytes")
return keccak256$1(toBytes$4(value)) === arg;
return value === arg;
} catch {
return false;
}
}
if (Array.isArray(args) && Array.isArray(matchArgs)) {
return matchArgs.every((value, index) => {
if (value === null || value === void 0)
return true;
const input = inputs[index];
if (!input)
return false;
const value_ = Array.isArray(value) ? value : [value];
return value_.some((value2) => isEqual(input, value2, args[index]));
});
}
if (typeof args === "object" && !Array.isArray(args) && typeof matchArgs === "object" && !Array.isArray(matchArgs))
return Object.entries(matchArgs).every(([key, value]) => {
if (value === null || value === void 0)
return true;
const input = inputs.find((input2) => input2.name === key);
if (!input)
return false;
const value_ = Array.isArray(value) ? value : [value];
return value_.some((value2) => isEqual(input, value2, args[key]));
});
return false;
}
async function getLogs(client, { address, blockHash, fromBlock, toBlock, event, events: events_, args, strict: strict_ } = {}) {
const strict = strict_ ?? false;
const events = events_ ?? (event ? [event] : void 0);
let topics = [];
if (events) {
const encoded = events.flatMap((event2) => encodeEventTopics({
abi: [event2],
eventName: event2.name,
args: events_ ? void 0 : args
}));
topics = [encoded];
if (event)
topics = topics[0];
}
let logs;
if (blockHash) {
logs = await client.request({
method: "eth_getLogs",
params: [{ address, topics, blockHash }]
});
} else {
logs = await client.request({
method: "eth_getLogs",
params: [
{
address,
topics,
fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
}
]
});
}
const formattedLogs = logs.map((log) => formatLog(log));
if (!events)
return formattedLogs;
return parseEventLogs({
abi: events,
args,
logs: formattedLogs,
strict
});
}
async function getContractEvents(client, parameters) {
const { abi: abi2, address, args, blockHash, eventName, fromBlock, toBlock, strict } = parameters;
const event = eventName ? getAbiItem({ abi: abi2, name: eventName }) : void 0;
const events = !event ? abi2.filter((x) => x.type === "event") : void 0;
return getAction(client, getLogs, "getLogs")({
address,
args,
blockHash,
event,
events,
fromBlock,
toBlock,
strict
});
}
class Eip712DomainNotFoundError extends BaseError$3 {
constructor({ address }) {
super(`No EIP-712 domain found on contract "${address}".`, {
metaMessages: [
"Ensure that:",
`- The contract is deployed at the address "${address}".`,
"- `eip712Domain()` function exists on the contract.",
"- `eip712Domain()` function matches signature to ERC-5267 specification."
],
name: "Eip712DomainNotFoundError"
});
}
}
async function getEip712Domain(client, parameters) {
const { address, factory, factoryData } = parameters;
try {
const [fields, name, version2, chainId, verifyingContract, salt, extensions] = await getAction(client, readContract, "readContract")({
abi: abi$3,
address,
functionName: "eip712Domain",
factory,
factoryData
});
return {
domain: {
name,
version: version2,
chainId: Number(chainId),
verifyingContract,
salt
},
extensions,
fields
};
} catch (e) {
const error = e;
if (error.name === "ContractFunctionExecutionError" && error.cause.name === "ContractFunctionZeroDataError") {
throw new Eip712DomainNotFoundError({ address });
}
throw error;
}
}
const abi$3 = [
{
inputs: [],
name: "eip712Domain",
outputs: [
{ name: "fields", type: "bytes1" },
{ name: "name", type: "string" },
{ name: "version", type: "string" },
{ name: "chainId", type: "uint256" },
{ name: "verifyingContract", type: "address" },
{ name: "salt", type: "bytes32" },
{ name: "extensions", type: "uint256[]" }
],
stateMutability: "view",
type: "function"
}
];
function formatFeeHistory(feeHistory) {
return {
baseFeePerGas: feeHistory.baseFeePerGas.map((value) => BigInt(value)),
gasUsedRatio: feeHistory.gasUsedRatio,
oldestBlock: BigInt(feeHistory.oldestBlock),
reward: feeHistory.reward?.map((reward) => reward.map((value) => BigInt(value)))
};
}
async function getFeeHistory(client, { blockCount, blockNumber, blockTag = "latest", rewardPercentiles }) {
const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
const feeHistory = await client.request({
method: "eth_feeHistory",
params: [
numberToHex(blockCount),
blockNumberHex || blockTag,
rewardPercentiles
]
}, { dedupe: Boolean(blockNumberHex) });
return formatFeeHistory(feeHistory);
}
async function getFilterChanges(_client, { filter }) {
const strict = "strict" in filter && filter.strict;
const logs = await filter.request({
method: "eth_getFilterChanges",
params: [filter.id]
});
if (typeof logs[0] === "string")
return logs;
const formattedLogs = logs.map((log) => formatLog(log));
if (!("abi" in filter) || !filter.abi)
return formattedLogs;
return parseEventLogs({
abi: filter.abi,
logs: formattedLogs,
strict
});
}
async function getFilterLogs(_client, { filter }) {
const strict = filter.strict ?? false;
const logs = await filter.request({
method: "eth_getFilterLogs",
params: [filter.id]
});
const formattedLogs = logs.map((log) => formatLog(log));
if (!filter.abi)
return formattedLogs;
return parseEventLogs({
abi: filter.abi,
logs: formattedLogs,
strict
});
}
async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
const data = await client.request({
method: "eth_getStorageAt",
params: [address, slot, blockNumberHex || blockTag]
});
return data;
}
async function getTransaction(client, { blockHash, blockNumber, blockTag: blockTag_, hash: hash2, index }) {
const blockTag = blockTag_ || "latest";
const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
let transaction = null;
if (hash2) {
transaction = await client.request({
method: "eth_getTransactionByHash",
params: [hash2]
}, { dedupe: true });
} else if (blockHash) {
transaction = await client.request({
method: "eth_getTransactionByBlockHashAndIndex",
params: [blockHash, numberToHex(index)]
}, { dedupe: true });
} else if (blockNumberHex || blockTag) {
transaction = await client.request({
method: "eth_getTransactionByBlockNumberAndIndex",
params: [blockNumberHex || blockTag, numberToHex(index)]
}, { dedupe: Boolean(blockNumberHex) });
}
if (!transaction)
throw new TransactionNotFoundError({
blockHash,
blockNumber,
blockTag,
hash: hash2,
index
});
const format = client.chain?.formatters?.transaction?.format || formatTransaction;
return format(transaction);
}
async function getTransactionConfirmations(client, { hash: hash2, transactionReceipt }) {
const [blockNumber, transaction] = await Promise.all([
getAction(client, getBlockNumber, "getBlockNumber")({}),
hash2 ? getAction(client, getTransaction, "getTransaction")({ hash: hash2 }) : void 0
]);
const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
if (!transactionBlockNumber)
return 0n;
return blockNumber - transactionBlockNumber + 1n;
}
async function getTransactionReceipt(client, { hash: hash2 }) {
const receipt = await client.request({
method: "eth_getTransactionReceipt",
params: [hash2]
}, { dedupe: true });
if (!receipt)
throw new TransactionReceiptNotFoundError({ hash: hash2 });
const format = client.chain?.formatters?.transactionReceipt?.format || formatTransactionReceipt;
return format(receipt);
}
async function simulateBlocks(client, parameters) {
const { blockNumber, blockTag = client.experimental_blockTag ?? "latest", blocks, returnFullTransactions, traceTransfers, validation } = parameters;
try {
const blockStateCalls = [];
for (const block2 of blocks) {
const blockOverrides = block2.blockOverrides ? toRpc(block2.blockOverrides) : void 0;
const calls = block2.calls.map((call_) => {
const call2 = call_;
const account2 = call2.account ? parseAccount(call2.account) : void 0;
const data = call2.abi ? encodeFunctionData(call2) : call2.data;
const request = {
...call2,
data: call2.dataSuffix ? concat$1([data || "0x", call2.dataSuffix]) : data,
from: call2.from ?? account2?.address
};
assertRequest(request);
return formatTransactionRequest(request);
});
const stateOverrides = block2.stateOverrides ? serializeStateOverride(block2.stateOverrides) : void 0;
blockStateCalls.push({
blockOverrides,
calls,
stateOverrides
});
}
const blockNumberHex = typeof blockNumber === "bigint" ? numberToHex(blockNumber) : void 0;
const block = blockNumberHex || blockTag;
const result = await client.request({
method: "eth_simulateV1",
params: [
{ blockStateCalls, returnFullTransactions, traceTransfers, validation },
block
]
});
return result.map((block2, i) => ({
...formatBlock(block2),
calls: block2.calls.map((call2, j) => {
const { abi: abi2, args, functionName, to } = blocks[i].calls[j];
const data = call2.error?.data ?? call2.returnData;
const gasUsed = BigInt(call2.gasUsed);
const logs = call2.logs?.map((log) => formatLog(log));
const status = call2.status === "0x1" ? "success" : "failure";
const result2 = abi2 && status === "success" && data !== "0x" ? decodeFunctionResult({
abi: abi2,
data,
functionName
}) : null;
const error = (() => {
if (status === "success")
return void 0;
let error2 = void 0;
if (call2.error?.data === "0x")
error2 = new AbiDecodingZeroDataError();
else if (call2.error)
error2 = new RawContractError(call2.error);
if (!error2)
return void 0;
return getContractError$1(error2, {
abi: abi2 ?? [],
address: to ?? "0x",
args,
functionName: functionName ?? "<unknown>"
});
})();
return {
data,
gasUsed,
logs,
status,
...status === "success" ? {
result: result2
} : {
error
}
};
})
}));
} catch (e) {
const cause = e;
const error = getNodeError(cause, {});
if (error instanceof UnknownNodeError)
throw cause;
throw error;
}
}
const version$1 = "1.0.8";
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 docsPath2 = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;
const message = [
shortMessage || "An error occurred.",
"",
...args.metaMessages ? [...args.metaMessages, ""] : [],
...docsPath2 ? [`Docs: https://abitype.dev${docsPath2}`] : [],
...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 = docsPath2;
this.metaMessages = args.metaMessages;
this.shortMessage = shortMessage;
}
};
function execTyped(regex, string) {
const match = regex.exec(string);
return match?.groups;
}
const bytesRegex$1 = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
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 = /^\(.+?\).*?$/;
const tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
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
});
}
if ("indexed" in abiParameter && abiParameter.indexed)
type = `${type} indexed`;
if (abiParameter.name)
return `${type} ${abiParameter.name}`;
return type;
}
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;
}
function formatAbiItem(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";
}
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);
}
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);
}
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);
}
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);
}
const constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
function isConstructorSignature(signature) {
return constructorSignatureRegex.test(signature);
}
function execConstructorSignature(signature) {
return execTyped(constructorSignatureRegex, signature);
}
const fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
function isFallbackSignature(signature) {
return fallbackSignatureRegex.test(signature);
}
function execFallbackSignature(signature) {
return execTyped(fallbackSignatureRegex, signature);
}
const receiveSignatureRegex = /^receive\(\) external payable$/;
function isReceiveSignature(signature) {
return receiveSignatureRegex.test(signature);
}
const eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
const functionModifiers = /* @__PURE__ */ new Set([
"calldata",
"memory",
"storage"
]);
class InvalidAbiItemError extends BaseError$1 {
constructor({ signature }) {
super("Failed to parse ABI item.", {
details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
docsPath: "/api/human#parseabiitem-1"
});
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "InvalidAbiItemError"
});
}
}
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"
});
}
}
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;
}
const parameterCache = /* @__PURE__ */ 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", { typ