@eco-foundation/routes-sdk
Version:
Eco Routes SDK
1,566 lines (1,529 loc) • 72.7 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/abitype/dist/esm/regex.js
function execTyped(regex, string) {
const match = regex.exec(string);
return match?.groups;
}
var init_regex = __esm({
"node_modules/abitype/dist/esm/regex.js"() {
"use strict";
}
});
// node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js
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;
}
var tupleRegex;
var init_formatAbiParameter = __esm({
"node_modules/abitype/dist/esm/human-readable/formatAbiParameter.js"() {
"use strict";
init_regex();
tupleRegex = /^tuple(?<array>(\[(\d*)\])*)$/;
}
});
// node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js
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;
}
var init_formatAbiParameters = __esm({
"node_modules/abitype/dist/esm/human-readable/formatAbiParameters.js"() {
"use strict";
init_formatAbiParameter();
}
});
// node_modules/abitype/dist/esm/human-readable/formatAbiItem.js
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";
}
var init_formatAbiItem = __esm({
"node_modules/abitype/dist/esm/human-readable/formatAbiItem.js"() {
"use strict";
init_formatAbiParameters();
}
});
// node_modules/abitype/dist/esm/exports/index.js
var init_exports = __esm({
"node_modules/abitype/dist/esm/exports/index.js"() {
"use strict";
init_formatAbiItem();
}
});
// node_modules/viem/_esm/utils/abi/formatAbiItem.js
function formatAbiItem2(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}` : "");
}
var init_formatAbiItem2 = __esm({
"node_modules/viem/_esm/utils/abi/formatAbiItem.js"() {
"use strict";
init_abi();
}
});
// node_modules/viem/_esm/utils/data/isHex.js
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");
}
var init_isHex = __esm({
"node_modules/viem/_esm/utils/data/isHex.js"() {
"use strict";
}
});
// node_modules/viem/_esm/utils/data/size.js
function size(value) {
if (isHex(value, { strict: false }))
return Math.ceil((value.length - 2) / 2);
return value.length;
}
var init_size = __esm({
"node_modules/viem/_esm/utils/data/size.js"() {
"use strict";
init_isHex();
}
});
// node_modules/viem/_esm/errors/version.js
var version;
var init_version = __esm({
"node_modules/viem/_esm/errors/version.js"() {
"use strict";
version = "2.22.12";
}
});
// node_modules/viem/_esm/errors/base.js
function walk(err, fn) {
if (fn?.(err))
return err;
if (err && typeof err === "object" && "cause" in err && err.cause !== void 0)
return walk(err.cause, fn);
return fn ? null : err;
}
var errorConfig, BaseError;
var init_base = __esm({
"node_modules/viem/_esm/errors/base.js"() {
"use strict";
init_version();
errorConfig = {
getDocsUrl: ({ docsBaseUrl, docsPath: docsPath2 = "", docsSlug }) => docsPath2 ? `${docsBaseUrl ?? "https://viem.sh"}${docsPath2}${docsSlug ? `#${docsSlug}` : ""}` : void 0,
version: `viem@${version}`
};
BaseError = 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 docsPath2 = (() => {
if (args.cause instanceof _BaseError)
return args.cause.docsPath || args.docsPath;
return args.docsPath;
})();
const docsUrl = errorConfig.getDocsUrl?.({ ...args, docsPath: docsPath2 });
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 } : void 0);
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 = docsPath2;
this.metaMessages = args.metaMessages;
this.name = args.name ?? this.name;
this.shortMessage = shortMessage;
this.version = version;
}
walk(fn) {
return walk(this, fn);
}
};
}
});
// node_modules/viem/_esm/errors/abi.js
var AbiEncodingArrayLengthMismatchError, AbiEncodingBytesSizeMismatchError, AbiEncodingLengthMismatchError, AbiFunctionNotFoundError, AbiItemAmbiguityError, InvalidAbiEncodingTypeError, InvalidArrayError, InvalidDefinitionTypeError;
var init_abi = __esm({
"node_modules/viem/_esm/errors/abi.js"() {
"use strict";
init_formatAbiItem2();
init_size();
init_base();
AbiEncodingArrayLengthMismatchError = class 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" });
}
};
AbiEncodingBytesSizeMismatchError = class extends BaseError {
constructor({ expectedSize, value }) {
super(`Size of bytes "${value}" (bytes${size(value)}) does not match expected size (bytes${expectedSize}).`, { name: "AbiEncodingBytesSizeMismatchError" });
}
};
AbiEncodingLengthMismatchError = class extends BaseError {
constructor({ expectedLength, givenLength }) {
super([
"ABI encoding params/values length mismatch.",
`Expected length (params): ${expectedLength}`,
`Given length (values): ${givenLength}`
].join("\n"), { name: "AbiEncodingLengthMismatchError" });
}
};
AbiFunctionNotFoundError = class extends BaseError {
constructor(functionName, { docsPath: docsPath2 } = {}) {
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: docsPath2,
name: "AbiFunctionNotFoundError"
});
}
};
AbiItemAmbiguityError = class extends BaseError {
constructor(x, y) {
super("Found ambiguous types in overloaded ABI items.", {
metaMessages: [
`\`${x.type}\` in \`${formatAbiItem2(x.abiItem)}\`, and`,
`\`${y.type}\` in \`${formatAbiItem2(y.abiItem)}\``,
"",
"These types encode differently and cannot be distinguished at runtime.",
"Remove one of the ambiguous items in the ABI."
],
name: "AbiItemAmbiguityError"
});
}
};
InvalidAbiEncodingTypeError = class extends BaseError {
constructor(type, { docsPath: docsPath2 }) {
super([
`Type "${type}" is not a valid encoding type.`,
"Please provide a valid ABI type."
].join("\n"), { docsPath: docsPath2, name: "InvalidAbiEncodingType" });
}
};
InvalidArrayError = class extends BaseError {
constructor(value) {
super([`Value "${value}" is not a valid array.`].join("\n"), {
name: "InvalidArrayError"
});
}
};
InvalidDefinitionTypeError = class extends BaseError {
constructor(type) {
super([
`"${type}" is not a valid definition type.`,
'Valid types: "function", "event", "error"'
].join("\n"), { name: "InvalidDefinitionTypeError" });
}
};
}
});
// node_modules/viem/_esm/errors/data.js
var SliceOffsetOutOfBoundsError, SizeExceedsPaddingSizeError;
var init_data = __esm({
"node_modules/viem/_esm/errors/data.js"() {
"use strict";
init_base();
SliceOffsetOutOfBoundsError = class extends BaseError {
constructor({ offset, position, size: size2 }) {
super(`Slice ${position === "start" ? "starting" : "ending"} at offset "${offset}" is out-of-bounds (size: ${size2}).`, { name: "SliceOffsetOutOfBoundsError" });
}
};
SizeExceedsPaddingSizeError = class extends BaseError {
constructor({ size: size2, targetSize, type }) {
super(`${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size2}) exceeds padding size (${targetSize}).`, { name: "SizeExceedsPaddingSizeError" });
}
};
}
});
// node_modules/viem/_esm/utils/data/pad.js
function pad(hexOrBytes, { dir, size: size2 = 32 } = {}) {
if (typeof hexOrBytes === "string")
return padHex(hexOrBytes, { dir, size: size2 });
return padBytes(hexOrBytes, { dir, size: size2 });
}
function padHex(hex_, { dir, size: size2 = 32 } = {}) {
if (size2 === null)
return hex_;
const hex = hex_.replace("0x", "");
if (hex.length > size2 * 2)
throw new SizeExceedsPaddingSizeError({
size: Math.ceil(hex.length / 2),
targetSize: size2,
type: "hex"
});
return `0x${hex[dir === "right" ? "padEnd" : "padStart"](size2 * 2, "0")}`;
}
function padBytes(bytes, { dir, size: size2 = 32 } = {}) {
if (size2 === null)
return bytes;
if (bytes.length > size2)
throw new SizeExceedsPaddingSizeError({
size: bytes.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] = bytes[padEnd ? i : bytes.length - i - 1];
}
return paddedBytes;
}
var init_pad = __esm({
"node_modules/viem/_esm/utils/data/pad.js"() {
"use strict";
init_data();
}
});
// node_modules/viem/_esm/errors/encoding.js
var IntegerOutOfRangeError, SizeOverflowError;
var init_encoding = __esm({
"node_modules/viem/_esm/errors/encoding.js"() {
"use strict";
init_base();
IntegerOutOfRangeError = class extends BaseError {
constructor({ max, min, signed, size: size2, value }) {
super(`Number "${value}" is not in safe ${size2 ? `${size2 * 8}-bit ${signed ? "signed" : "unsigned"} ` : ""}integer range ${max ? `(${min} to ${max})` : `(above ${min})`}`, { name: "IntegerOutOfRangeError" });
}
};
SizeOverflowError = class extends BaseError {
constructor({ givenSize, maxSize }) {
super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`, { name: "SizeOverflowError" });
}
};
}
});
// node_modules/viem/_esm/utils/encoding/fromHex.js
function assertSize(hexOrBytes, { size: size2 }) {
if (size(hexOrBytes) > size2)
throw new SizeOverflowError({
givenSize: size(hexOrBytes),
maxSize: size2
});
}
var init_fromHex = __esm({
"node_modules/viem/_esm/utils/encoding/fromHex.js"() {
"use strict";
init_encoding();
init_size();
}
});
// node_modules/viem/_esm/utils/encoding/toHex.js
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);
}
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;
}
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;
}
function numberToHex(value_, opts = {}) {
const { signed, size: size2 } = opts;
const value = BigInt(value_);
let maxValue;
if (size2) {
if (signed)
maxValue = (1n << BigInt(size2) * 8n - 1n) - 1n;
else
maxValue = 2n ** (BigInt(size2) * 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}` : void 0,
min: `${minValue}${suffix}`,
signed,
size: size2,
value: `${value_}${suffix}`
});
}
const hex = `0x${(signed && value < 0 ? (1n << BigInt(size2 * 8)) + BigInt(value) : value).toString(16)}`;
if (size2)
return pad(hex, { size: size2 });
return hex;
}
function stringToHex(value_, opts = {}) {
const value = encoder.encode(value_);
return bytesToHex(value, opts);
}
var hexes, encoder;
var init_toHex = __esm({
"node_modules/viem/_esm/utils/encoding/toHex.js"() {
"use strict";
init_encoding();
init_pad();
init_fromHex();
hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
encoder = /* @__PURE__ */ new TextEncoder();
}
});
// node_modules/viem/_esm/utils/encoding/toBytes.js
function toBytes(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);
}
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;
}
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 void 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 === void 0 || nibbleRight === void 0) {
throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
}
bytes[index] = nibbleLeft * 16 + nibbleRight;
}
return bytes;
}
function numberToBytes(value, opts) {
const hex = numberToHex(value, opts);
return hexToBytes(hex);
}
function stringToBytes(value, opts = {}) {
const bytes = encoder2.encode(value);
if (typeof opts.size === "number") {
assertSize(bytes, { size: opts.size });
return pad(bytes, { dir: "right", size: opts.size });
}
return bytes;
}
var encoder2, charCodeMap;
var init_toBytes = __esm({
"node_modules/viem/_esm/utils/encoding/toBytes.js"() {
"use strict";
init_base();
init_isHex();
init_pad();
init_fromHex();
init_toHex();
encoder2 = /* @__PURE__ */ new TextEncoder();
charCodeMap = {
zero: 48,
nine: 57,
A: 65,
F: 70,
a: 97,
f: 102
};
}
});
// node_modules/@noble/hashes/esm/_assert.js
function anumber(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error("positive integer expected, got " + n);
}
function isBytes(a) {
return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "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);
}
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");
}
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);
}
}
var init_assert = __esm({
"node_modules/@noble/hashes/esm/_assert.js"() {
"use strict";
}
});
// node_modules/@noble/hashes/esm/_u64.js
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) {
let Ah = new Uint32Array(lst.length);
let Al = new Uint32Array(lst.length);
for (let i = 0; i < lst.length; i++) {
const { h, l } = fromBig(lst[i], le);
[Ah[i], Al[i]] = [h, l];
}
return [Ah, Al];
}
var U32_MASK64, _32n, rotlSH, rotlSL, rotlBH, rotlBL;
var init_u64 = __esm({
"node_modules/@noble/hashes/esm/_u64.js"() {
"use strict";
U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
_32n = /* @__PURE__ */ BigInt(32);
rotlSH = (h, l, s) => h << s | l >>> 32 - s;
rotlSL = (h, l, s) => l << s | h >>> 32 - s;
rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
}
});
// node_modules/@noble/hashes/esm/utils.js
function byteSwap32(arr) {
for (let i = 0; i < arr.length; i++) {
arr[i] = byteSwap(arr[i]);
}
}
function utf8ToBytes(str) {
if (typeof str !== "string")
throw new Error("utf8ToBytes expected string, got " + typeof str);
return new Uint8Array(new TextEncoder().encode(str));
}
function toBytes2(data) {
if (typeof data === "string")
data = utf8ToBytes(data);
abytes(data);
return data;
}
function wrapConstructor(hashCons) {
const hashC = (msg) => hashCons().update(toBytes2(msg)).digest();
const tmp = hashCons();
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = () => hashCons();
return hashC;
}
function wrapXOFConstructorWithOpts(hashCons) {
const hashC = (msg, opts) => hashCons(opts).update(toBytes2(msg)).digest();
const tmp = hashCons({});
hashC.outputLen = tmp.outputLen;
hashC.blockLen = tmp.blockLen;
hashC.create = (opts) => hashCons(opts);
return hashC;
}
var u32, isLE, byteSwap, Hash;
var init_utils = __esm({
"node_modules/@noble/hashes/esm/utils.js"() {
"use strict";
init_assert();
u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
Hash = class {
// Safe version that clones internal state
clone() {
return this._cloneInto();
}
};
}
});
// node_modules/@noble/hashes/esm/sha3.js
function keccakP(s, rounds = 24) {
const B = new Uint32Array(5 * 2);
for (let round = 24 - rounds; round < 24; round++) {
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;
}
}
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;
}
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];
}
s[0] ^= SHA3_IOTA_H[round];
s[1] ^= SHA3_IOTA_L[round];
}
B.fill(0);
}
var SHA3_PI, SHA3_ROTL, _SHA3_IOTA, _0n, _1n, _2n, _7n, _256n, _0x71n, SHA3_IOTA_H, SHA3_IOTA_L, rotlH, rotlL, Keccak, gen, sha3_224, sha3_256, sha3_384, sha3_512, keccak_224, keccak_256, keccak_384, keccak_512, genShake, shake128, shake256;
var init_sha3 = __esm({
"node_modules/@noble/hashes/esm/sha3.js"() {
"use strict";
init_assert();
init_u64();
init_utils();
SHA3_PI = [];
SHA3_ROTL = [];
_SHA3_IOTA = [];
_0n = /* @__PURE__ */ BigInt(0);
_1n = /* @__PURE__ */ BigInt(1);
_2n = /* @__PURE__ */ BigInt(2);
_7n = /* @__PURE__ */ BigInt(7);
_256n = /* @__PURE__ */ BigInt(256);
_0x71n = /* @__PURE__ */ BigInt(113);
for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
[x, y] = [y, (2 * x + 3 * y) % 5];
SHA3_PI.push(2 * (5 * y + x));
SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
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);
}
[SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
Keccak = class _Keccak extends Hash {
// NOTE: we accept arguments in bytes instead of bits here.
constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
super();
this.blockLen = blockLen;
this.suffix = suffix;
this.outputLen = outputLen;
this.enableXOF = enableXOF;
this.rounds = rounds;
this.pos = 0;
this.posOut = 0;
this.finished = false;
this.destroyed = false;
anumber(outputLen);
if (0 >= this.blockLen || this.blockLen >= 200)
throw new Error("Sha3 supports only keccak-f1600 function");
this.state = new Uint8Array(200);
this.state32 = u32(this.state);
}
keccak() {
if (!isLE)
byteSwap32(this.state32);
keccakP(this.state32, this.rounds);
if (!isLE)
byteSwap32(this.state32);
this.posOut = 0;
this.pos = 0;
}
update(data) {
aexists(this);
const { blockLen, state } = this;
data = toBytes2(data);
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;
state[pos] ^= suffix;
if ((suffix & 128) !== 0 && pos === blockLen - 1)
this.keccak();
state[blockLen - 1] ^= 128;
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) {
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;
this.state.fill(0);
}
_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;
to.suffix = suffix;
to.outputLen = outputLen;
to.enableXOF = enableXOF;
to.destroyed = this.destroyed;
return to;
}
};
gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
sha3_224 = /* @__PURE__ */ gen(6, 144, 224 / 8);
sha3_256 = /* @__PURE__ */ gen(6, 136, 256 / 8);
sha3_384 = /* @__PURE__ */ gen(6, 104, 384 / 8);
sha3_512 = /* @__PURE__ */ gen(6, 72, 512 / 8);
keccak_224 = /* @__PURE__ */ gen(1, 144, 224 / 8);
keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
keccak_384 = /* @__PURE__ */ gen(1, 104, 384 / 8);
keccak_512 = /* @__PURE__ */ gen(1, 72, 512 / 8);
genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
shake128 = /* @__PURE__ */ genShake(31, 168, 128 / 8);
shake256 = /* @__PURE__ */ genShake(31, 136, 256 / 8);
}
});
// node_modules/viem/_esm/utils/hash/keccak256.js
function keccak256(value, to_) {
const to = to_ || "hex";
const bytes = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
if (to === "bytes")
return bytes;
return toHex(bytes);
}
var init_keccak256 = __esm({
"node_modules/viem/_esm/utils/hash/keccak256.js"() {
"use strict";
init_sha3();
init_isHex();
init_toBytes();
init_toHex();
}
});
// node_modules/viem/_esm/utils/hash/hashSignature.js
function hashSignature(sig) {
return hash(sig);
}
var hash;
var init_hashSignature = __esm({
"node_modules/viem/_esm/utils/hash/hashSignature.js"() {
"use strict";
init_toBytes();
init_keccak256();
hash = (value) => keccak256(toBytes(value));
}
});
// node_modules/viem/_esm/utils/hash/normalizeSignature.js
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 (["(", ")", ","].includes(char))
active = true;
if (char === "(")
level++;
if (char === ")")
level--;
if (!active)
continue;
if (level === 0) {
if (char === " " && ["event", "function", ""].includes(result))
result = "";
else {
result += char;
if (char === ")") {
valid = true;
break;
}
}
continue;
}
if (char === " ") {
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;
}
var init_normalizeSignature = __esm({
"node_modules/viem/_esm/utils/hash/normalizeSignature.js"() {
"use strict";
init_base();
}
});
// node_modules/viem/_esm/utils/hash/toSignature.js
var toSignature;
var init_toSignature = __esm({
"node_modules/viem/_esm/utils/hash/toSignature.js"() {
"use strict";
init_exports();
init_normalizeSignature();
toSignature = (def) => {
const def_ = (() => {
if (typeof def === "string")
return def;
return formatAbiItem(def);
})();
return normalizeSignature(def_);
};
}
});
// node_modules/viem/_esm/utils/hash/toSignatureHash.js
function toSignatureHash(fn) {
return hashSignature(toSignature(fn));
}
var init_toSignatureHash = __esm({
"node_modules/viem/_esm/utils/hash/toSignatureHash.js"() {
"use strict";
init_hashSignature();
init_toSignature();
}
});
// node_modules/viem/_esm/utils/hash/toEventSelector.js
var toEventSelector;
var init_toEventSelector = __esm({
"node_modules/viem/_esm/utils/hash/toEventSelector.js"() {
"use strict";
init_toSignatureHash();
toEventSelector = toSignatureHash;
}
});
// node_modules/viem/_esm/errors/address.js
var InvalidAddressError;
var init_address = __esm({
"node_modules/viem/_esm/errors/address.js"() {
"use strict";
init_base();
InvalidAddressError = class 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"
});
}
};
}
});
// node_modules/viem/_esm/utils/lru.js
var LruMap;
var init_lru = __esm({
"node_modules/viem/_esm/utils/lru.js"() {
"use strict";
LruMap = class extends Map {
constructor(size2) {
super();
Object.defineProperty(this, "maxSize", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.maxSize = size2;
}
get(key) {
const value = super.get(key);
if (super.has(key) && value !== void 0) {
this.delete(key);
super.set(key, value);
}
return value;
}
set(key, value) {
super.set(key, value);
if (this.maxSize && this.size > this.maxSize) {
const firstKey = this.keys().next().value;
if (firstKey)
this.delete(firstKey);
}
return this;
}
};
}
});
// node_modules/viem/_esm/utils/address/getAddress.js
function checksumAddress(address_, chainId) {
if (checksumAddressCache.has(`${address_}.${chainId}`))
return checksumAddressCache.get(`${address_}.${chainId}`);
const hexAddress = chainId ? `${chainId}${address_.toLowerCase()}` : address_.substring(2).toLowerCase();
const hash2 = keccak256(stringToBytes(hexAddress), "bytes");
const address = (chainId ? hexAddress.substring(`${chainId}0x`.length) : hexAddress).split("");
for (let i = 0; i < 40; i += 2) {
if (hash2[i >> 1] >> 4 >= 8 && address[i]) {
address[i] = address[i].toUpperCase();
}
if ((hash2[i >> 1] & 15) >= 8 && address[i + 1]) {
address[i + 1] = address[i + 1].toUpperCase();
}
}
const result = `0x${address.join("")}`;
checksumAddressCache.set(`${address_}.${chainId}`, result);
return result;
}
var checksumAddressCache;
var init_getAddress = __esm({
"node_modules/viem/_esm/utils/address/getAddress.js"() {
"use strict";
init_toBytes();
init_keccak256();
init_lru();
checksumAddressCache = /* @__PURE__ */ new LruMap(8192);
}
});
// node_modules/viem/_esm/utils/address/isAddress.js
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;
}
var addressRegex, isAddressCache;
var init_isAddress = __esm({
"node_modules/viem/_esm/utils/address/isAddress.js"() {
"use strict";
init_lru();
init_getAddress();
addressRegex = /^0x[a-fA-F0-9]{40}$/;
isAddressCache = /* @__PURE__ */ new LruMap(8192);
}
});
// node_modules/viem/_esm/utils/data/concat.js
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", ""), "")}`;
}
var init_concat = __esm({
"node_modules/viem/_esm/utils/data/concat.js"() {
"use strict";
}
});
// node_modules/viem/_esm/utils/data/slice.js
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)
});
}
}
function sliceBytes(value_, start, end, { strict } = {}) {
assertStartOffset(value_, start);
const value = value_.slice(start, end);
if (strict)
assertEndOffset(value, start, end);
return value;
}
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;
}
var init_slice = __esm({
"node_modules/viem/_esm/utils/data/slice.js"() {
"use strict";
init_data();
init_isHex();
init_size();
}
});
// node_modules/viem/_esm/utils/regex.js
var integerRegex;
var init_regex2 = __esm({
"node_modules/viem/_esm/utils/regex.js"() {
"use strict";
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)?$/;
}
});
// node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
function encodeAbiParameters(params, values) {
if (params.length !== values.length)
throw new AbiEncodingLengthMismatchError({
expectedLength: params.length,
givenLength: values.length
});
const preparedParams = prepareParams({
params,
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
});
}
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 [, , size2 = "256"] = integerRegex.exec(param.type) ?? [];
return encodeNumber(value, {
signed,
size: Number(size2)
});
}
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) {
let staticSize = 0;
for (let i = 0; i < preparedParams.length; i++) {
const { dynamic, encoded } = preparedParams[i];
if (dynamic)
staticSize += 32;
else
staticSize += size(encoded);
}
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);
}
}
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 length2 = numberToHex(preparedParams.length, { size: 32 });
return {
dynamic: true,
encoded: preparedParams.length > 0 ? concat([length2, data]) : length2
};
}
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 (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))
throw new AbiEncodingBytesSizeMismatchError({
expectedSize: Number.parseInt(paramSize),
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: size2 = 256 }) {
if (typeof size2 === "number") {
const max = 2n ** (BigInt(size2) - (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: size2 / 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]]
) : void 0;
}
var init_encodeAbiParameters = __esm({
"node_modules/viem/_esm/utils/abi/encodeAbiParameters.js"() {
"use strict";
init_abi();
init_address();
init_base();
init_encoding();
init_isAddress();
init_concat();
init_pad();
init_size();
init_slice();
init_toHex();
init_regex2();
}
});
// node_modules/viem/_esm/utils/hash/toFunctionSelector.js
var toFunctionSelector;
var init_toFunctionSelector = __esm({
"node_modules/viem/_esm/utils/hash/toFunctionSelector.js"() {
"use strict";
init_slice();
init_toSignatureHash();
toFunctionSelector = (fn) => slice(toSignatureHash(fn), 0, 4);
}
});
// node_modules/viem/_esm/utils/abi/getAbiItem.js
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 void 0;
if (abiItems.length === 1)
return abiItems[0];
let matchedAbiItem = void 0;
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) {
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];
}
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 isArgOfType(Object.values(arg)[index], component);
});
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";
if (/^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/.test(abiParameterType))
return argType === "string" || arg instanceof Uint8Array;
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(/(\