@etherspot/remote-signer
Version:
Etherspot Permissioned Signer SDK - signs the UserOp with SessionKey and sends it to the Bundler
2,082 lines • 67.7 kB
JavaScript
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/version.js
var version;
var init_version = __esm({
"node_modules/abitype/dist/esm/version.js"() {
version = "1.0.4";
}
});
// node_modules/abitype/dist/esm/errors.js
var BaseError;
var init_errors = __esm({
"node_modules/abitype/dist/esm/errors.js"() {
init_version();
BaseError = 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}`
].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;
}
};
}
});
// node_modules/abitype/dist/esm/regex.js
function execTyped(regex, string) {
const match = regex.exec(string);
return match?.groups;
}
var bytesRegex, integerRegex, isTupleRegex;
var init_regex = __esm({
"node_modules/abitype/dist/esm/regex.js"() {
bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;
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)?$/;
isTupleRegex = /^\(.+?\).*?$/;
}
});
// node_modules/abitype/dist/esm/human-readable/runtime/signatures.js
function isErrorSignature(signature) {
return errorSignatureRegex.test(signature);
}
function execErrorSignature(signature) {
return execTyped(errorSignatureRegex, signature);
}
function isEventSignature(signature) {
return eventSignatureRegex.test(signature);
}
function execEventSignature(signature) {
return execTyped(eventSignatureRegex, signature);
}
function isFunctionSignature(signature) {
return functionSignatureRegex.test(signature);
}
function execFunctionSignature(signature) {
return execTyped(functionSignatureRegex, signature);
}
function isStructSignature(signature) {
return structSignatureRegex.test(signature);
}
function execStructSignature(signature) {
return execTyped(structSignatureRegex, signature);
}
function isConstructorSignature(signature) {
return constructorSignatureRegex.test(signature);
}
function execConstructorSignature(signature) {
return execTyped(constructorSignatureRegex, signature);
}
function isFallbackSignature(signature) {
return fallbackSignatureRegex.test(signature);
}
function isReceiveSignature(signature) {
return receiveSignatureRegex.test(signature);
}
var errorSignatureRegex, eventSignatureRegex, functionSignatureRegex, structSignatureRegex, constructorSignatureRegex, fallbackSignatureRegex, receiveSignatureRegex, eventModifiers, functionModifiers;
var init_signatures = __esm({
"node_modules/abitype/dist/esm/human-readable/runtime/signatures.js"() {
init_regex();
errorSignatureRegex = /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
eventSignatureRegex = /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/;
functionSignatureRegex = /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/;
structSignatureRegex = /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/;
constructorSignatureRegex = /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/;
fallbackSignatureRegex = /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/;
receiveSignatureRegex = /^receive\(\) external payable$/;
eventModifiers = /* @__PURE__ */ new Set(["indexed"]);
functionModifiers = /* @__PURE__ */ new Set([
"calldata",
"memory",
"storage"
]);
}
});
// node_modules/abitype/dist/esm/human-readable/errors/abiItem.js
var UnknownTypeError, UnknownSolidityTypeError;
var init_abiItem = __esm({
"node_modules/abitype/dist/esm/human-readable/errors/abiItem.js"() {
init_errors();
UnknownTypeError = class extends BaseError {
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"
});
}
};
UnknownSolidityTypeError = class extends BaseError {
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"
});
}
};
}
});
// node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js
var InvalidParameterError, SolidityProtectedKeywordError, InvalidModifierError, InvalidFunctionModifierError, InvalidAbiTypeParameterError;
var init_abiParameter = __esm({
"node_modules/abitype/dist/esm/human-readable/errors/abiParameter.js"() {
init_errors();
InvalidParameterError = class extends BaseError {
constructor({ param }) {
super("Invalid ABI parameter.", {
details: param
});
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "InvalidParameterError"
});
}
};
SolidityProtectedKeywordError = class extends BaseError {
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"
});
}
};
InvalidModifierError = class extends BaseError {
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"
});
}
};
InvalidFunctionModifierError = class extends BaseError {
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"
});
}
};
InvalidAbiTypeParameterError = class extends BaseError {
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"
});
}
};
}
});
// node_modules/abitype/dist/esm/human-readable/errors/signature.js
var InvalidSignatureError, UnknownSignatureError, InvalidStructSignatureError;
var init_signature = __esm({
"node_modules/abitype/dist/esm/human-readable/errors/signature.js"() {
init_errors();
InvalidSignatureError = class extends BaseError {
constructor({ signature, type }) {
super(`Invalid ${type} signature.`, {
details: signature
});
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "InvalidSignatureError"
});
}
};
UnknownSignatureError = class extends BaseError {
constructor({ signature }) {
super("Unknown signature.", {
details: signature
});
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "UnknownSignatureError"
});
}
};
InvalidStructSignatureError = class extends BaseError {
constructor({ signature }) {
super("Invalid struct signature.", {
details: signature,
metaMessages: ["No properties exist."]
});
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "InvalidStructSignatureError"
});
}
};
}
});
// node_modules/abitype/dist/esm/human-readable/errors/struct.js
var CircularReferenceError;
var init_struct = __esm({
"node_modules/abitype/dist/esm/human-readable/errors/struct.js"() {
init_errors();
CircularReferenceError = class extends BaseError {
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"
});
}
};
}
});
// node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js
var InvalidParenthesisError;
var init_splitParameters = __esm({
"node_modules/abitype/dist/esm/human-readable/errors/splitParameters.js"() {
init_errors();
InvalidParenthesisError = class extends BaseError {
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"
});
}
};
}
});
// node_modules/abitype/dist/esm/human-readable/runtime/cache.js
function getParameterCacheKey(param, type) {
if (type)
return `${type}:${param}`;
return param;
}
var parameterCache;
var init_cache = __esm({
"node_modules/abitype/dist/esm/human-readable/runtime/cache.js"() {
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", { 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 }
]
]);
}
});
// node_modules/abitype/dist/esm/human-readable/runtime/utils.js
function parseSignature(signature, structs = {}) {
if (isFunctionSignature(signature)) {
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
};
}
if (isEventSignature(signature)) {
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 };
}
if (isErrorSignature(signature)) {
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 };
}
if (isConstructorSignature(signature)) {
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
};
}
if (isFallbackSignature(signature))
return { type: "fallback" };
if (isReceiveSignature(signature))
return {
type: "receive",
stateMutability: "payable"
};
throw new UnknownSignatureError({ signature });
}
function parseAbiParameter(param, options) {
const parameterCacheKey = getParameterCacheKey(param, options?.type);
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++) {
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 {
type = match.type;
if (!(options?.type === "struct") && !isSolidityType(type))
throw new UnknownSolidityTypeError({ type });
}
if (match.modifier) {
if (!options?.modifiers?.has?.(match.modifier))
throw new InvalidModifierError({
param,
type: options?.type,
modifier: match.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;
}
function splitParameters(params, result = [], current = "", depth = 0) {
const length = params.trim().length;
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.test(type);
}
function isSolidityKeyword(name) {
return name === "address" || name === "bool" || name === "function" || name === "string" || name === "tuple" || bytesRegex.test(name) || integerRegex.test(name) || protectedKeywordsRegex.test(name);
}
function isValidDataLocation(type, isArray) {
return isArray || type === "bytes" || type === "string" || type === "tuple";
}
var abiParameterWithoutTupleRegex, abiParameterWithTupleRegex, dynamicIntegerRegex, protectedKeywordsRegex;
var init_utils = __esm({
"node_modules/abitype/dist/esm/human-readable/runtime/utils.js"() {
init_regex();
init_abiItem();
init_abiParameter();
init_signature();
init_splitParameters();
init_cache();
init_signatures();
abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
abiParameterWithTupleRegex = /^\((?<type>.+?)\)(?<array>(?:\[\d*?\])+?)?(?:\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\s(?<name>[a-zA-Z$_][a-zA-Z0-9$_]*))?$/;
dynamicIntegerRegex = /^u?int$/;
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)$/;
}
});
// node_modules/abitype/dist/esm/human-readable/runtime/structs.js
function parseStructs(signatures) {
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;
}
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;
}
function resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ 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, /* @__PURE__ */ new Set([...ancestors, type]))
});
} else {
if (isSolidityType(type))
components.push(abiParameter);
else
throw new UnknownTypeError({ type });
}
}
}
return components;
}
var typeWithoutTupleRegex;
var init_structs = __esm({
"node_modules/abitype/dist/esm/human-readable/runtime/structs.js"() {
init_regex();
init_abiItem();
init_abiParameter();
init_signature();
init_struct();
init_signatures();
init_utils();
typeWithoutTupleRegex = /^(?<type>[a-zA-Z$_][a-zA-Z0-9$_]*)(?<array>(?:\[\d*?\])+?)?$/;
}
});
// node_modules/abitype/dist/esm/human-readable/parseAbi.js
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;
}
var init_parseAbi = __esm({
"node_modules/abitype/dist/esm/human-readable/parseAbi.js"() {
init_signatures();
init_structs();
init_utils();
}
});
// node_modules/abitype/dist/esm/exports/index.js
var init_exports = __esm({
"node_modules/abitype/dist/esm/exports/index.js"() {
init_parseAbi();
}
});
// 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"() {
}
});
// 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"() {
init_isHex();
}
});
// node_modules/viem/_esm/errors/version.js
var version2;
var init_version2 = __esm({
"node_modules/viem/_esm/errors/version.js"() {
version2 = "2.16.3";
}
});
// node_modules/viem/_esm/errors/utils.js
var getVersion;
var init_utils2 = __esm({
"node_modules/viem/_esm/errors/utils.js"() {
init_version2();
getVersion = () => `viem@${version2}`;
}
});
// node_modules/viem/_esm/errors/base.js
function walk(err, fn) {
if (fn?.(err))
return err;
if (err && typeof err === "object" && "cause" in err)
return walk(err.cause, fn);
return fn ? null : err;
}
var BaseError2;
var init_base = __esm({
"node_modules/viem/_esm/errors/base.js"() {
init_utils2();
BaseError2 = class _BaseError extends Error {
constructor(shortMessage, args = {}) {
super();
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: "ViemError"
});
Object.defineProperty(this, "version", {
enumerable: true,
configurable: true,
writable: true,
value: getVersion()
});
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;
this.message = [
shortMessage || "An error occurred.",
"",
...args.metaMessages ? [...args.metaMessages, ""] : [],
...docsPath ? [
`Docs: ${args.docsBaseUrl ?? "https://viem.sh"}${docsPath}${args.docsSlug ? `#${args.docsSlug}` : ""}`
] : [],
...details ? [`Details: ${details}`] : [],
`Version: ${this.version}`
].join("\n");
if (args.cause)
this.cause = args.cause;
this.details = details;
this.docsPath = docsPath;
this.metaMessages = args.metaMessages;
this.shortMessage = shortMessage;
}
walk(fn) {
return walk(this, fn);
}
};
}
});
// node_modules/viem/_esm/errors/data.js
var SizeExceedsPaddingSizeError;
var init_data = __esm({
"node_modules/viem/_esm/errors/data.js"() {
init_base();
SizeExceedsPaddingSizeError = class extends BaseError2 {
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: "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(bytes2, { dir, size: size2 = 32 } = {}) {
if (size2 === null)
return bytes2;
if (bytes2.length > size2)
throw new SizeExceedsPaddingSizeError({
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;
}
var init_pad = __esm({
"node_modules/viem/_esm/utils/data/pad.js"() {
init_data();
}
});
// node_modules/viem/_esm/errors/encoding.js
var IntegerOutOfRangeError, SizeOverflowError;
var init_encoding = __esm({
"node_modules/viem/_esm/errors/encoding.js"() {
init_base();
IntegerOutOfRangeError = class extends BaseError2 {
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})`}`);
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "IntegerOutOfRangeError"
});
}
};
SizeOverflowError = class extends BaseError2 {
constructor({ givenSize, maxSize }) {
super(`Size cannot exceed ${maxSize} bytes. Given size: ${givenSize} bytes.`);
Object.defineProperty(this, "name", {
enumerable: true,
configurable: true,
writable: true,
value: "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"() {
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"() {
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 bytes2 = new Uint8Array(1);
bytes2[0] = Number(value);
if (typeof opts.size === "number") {
assertSize(bytes2, { size: opts.size });
return pad(bytes2, { size: opts.size });
}
return bytes2;
}
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 bytes2 = 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 BaseError2(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
}
bytes2[index] = nibbleLeft * 16 + nibbleRight;
}
return bytes2;
}
function numberToBytes(value, opts) {
const hex = numberToHex(value, opts);
return hexToBytes(hex);
}
function stringToBytes(value, opts = {}) {
const bytes2 = encoder2.encode(value);
if (typeof opts.size === "number") {
assertSize(bytes2, { size: opts.size });
return pad(bytes2, { dir: "right", size: opts.size });
}
return bytes2;
}
var encoder2, charCodeMap;
var init_toBytes = __esm({
"node_modules/viem/_esm/utils/encoding/toBytes.js"() {
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 number(n) {
if (!Number.isSafeInteger(n) || n < 0)
throw new Error(`Wrong positive integer: ${n}`);
}
function bytes(b, ...lengths) {
if (!(b instanceof Uint8Array))
throw new Error("Expected Uint8Array");
if (lengths.length > 0 && !lengths.includes(b.length))
throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
}
function exists(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 output(out, instance) {
bytes(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"() {
}
});
// 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"() {
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 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);
if (!u8a(data))
throw new Error(`expected Uint8Array, got ${typeof 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 u8a, u32, isLE, Hash, toStr;
var init_utils3 = __esm({
"node_modules/@noble/hashes/esm/utils.js"() {
u8a = (a) => a instanceof Uint8Array;
u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
if (!isLE)
throw new Error("Non little-endian hardware is not supported");
Hash = class {
// Safe version that clones internal state
clone() {
return this._cloneInto();
}
};
toStr = {}.toString;
}
});
// 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"() {
init_assert();
init_u64();
init_utils3();
[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;
number(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() {
keccakP(this.state32, this.rounds);
this.posOut = 0;
this.pos = 0;
}
update(data) {
exists(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) {
exists(this, false);
bytes(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(bytes2) {
number(bytes2);
return this.xofInto(new Uint8Array(bytes2));
}
digestInto(out) {
output(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 bytes2 = keccak_256(isHex(value, { strict: false }) ? toBytes(value) : value);
if (to === "bytes")
return bytes2;
return toHex(bytes2);
}
var init_keccak256 = __esm({
"node_modules/viem/_esm/utils/hash/keccak256.js"() {
init_sha3();
init_isHex();
init_toBytes();
init_toHex();
}
});
// src/sdk/session-keys/erc20-sessionkey-onchain.ts
var erc20_sessionkey_onchain_exports = {};
__export(erc20_sessionkey_onchain_exports, {
getOnchainSessionKeyData: () => getOnchainSessionKeyData,
isSessionKeyLiveOnChain: () => isSessionKeyLiveOnChain
});
module.exports = __toCommonJS(erc20_sessionkey_onchain_exports);
// node_modules/viem/_esm/index.js
init_exports();
// node_modules/viem/_esm/utils/chain/defineChain.js
function defineChain(chain) {
return {
formatters: void 0,
fees: void 0,
serializers: void 0,
...chain
};
}
// node_modules/viem/_esm/index.js
init_keccak256();
// src/sdk/common/ERC4337Utils.ts
var import_buffer = require("buffer");
// src/sdk/types/bignumber.ts
var import_bn = __toESM(require("bn.js"));
// src/sdk/types/bignumber-logger.ts
var _permanentCensorErrors = false;
var _censorErrors = false;
var LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
var _logLevel = LogLevels["default"];
var version3 = "logger/5.7.0";
var _globalLogger = null;
function _checkNormalize() {
try {
const missing = [];
["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
try {
if ("test".normalize(form) !== "test") {
throw new Error("bad normalize");
}
;
} catch (error) {
missing.push(form);
}
});
if (missing.length) {
throw new Error("missing " + missing.join(", "));
}
if (String.fromCharCode(233).normalize("NFD") !== String.fromCharCode(101, 769)) {
throw new Error("broken implementation");
}
} catch (error) {
return error.message;
}
return null;
}
var _normalizeError = _checkNormalize();
var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
LogLevel2["DEBUG"] = "DEBUG";
LogLevel2["INFO"] = "INFO";
LogLevel2["WARNING"] = "WARNING";
LogLevel2["ERROR"] = "ERROR";
LogLevel2["OFF"] = "OFF";
return LogLevel2;
})(LogLevel || {});
var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
ErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
ErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
ErrorCode2["TIMEOUT"] = "TIMEOUT";
ErrorCode2["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
ErrorCode2["NUMERIC_FAULT"] = "NUMERIC_FAULT";
ErrorCode2["MISSING_NEW"] = "MISSING_NEW";
ErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
ErrorCode2["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
ErrorCode2["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
ErrorCode2["CALL_EXCEPTION"] = "CALL_EXCEPTION";
ErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
ErrorCode2["NONCE_EXPIRED"] = "NONCE_EXPIRED";
ErrorCode2["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
ErrorCode2["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
ErrorCode2["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
ErrorCode2["ACTION_REJECTED"] = "ACTION_REJECTED";
return ErrorCode2;
})(ErrorCode || {});
var HEX = "0123456789abcdef";
var _Logger = class _Logger {
constructor(version5) {
Object.defineProperty(this, "version", {
enumerable: true,
value: version5,
writable: false
});
}
_log(logLevel, args) {
const level = logLevel.toLowerCase();
if (LogLevels[level] == null) {
this.throwArgumentError("invalid log level name", "logLevel", logLevel);
}
if (_logLevel > LogLevels[level]) {
return;
}
console.log.apply(console, args);
}
debug(...args) {
this._log(_Logger.levels.DEBUG, args);
}
info(...args) {
this._log(_Logger.levels.INFO, args);
}
warn(...args) {
this._log(_Logger.levels.WARNING, args);
}
makeError(message, code, params) {
if (_censorErrors) {
return this.makeError("censored error", code, {});
}
if (!code) {
code = _Logger.errors.UNKNOWN_ERROR;
}
if (!params) {
params = {};
}
const messageDetails = [];
Object.keys(params).forEach((key) => {
const value = params[key];
try {
if (value instanceof Uint8Array) {
let hex = "";
for (let i = 0; i < value.length; i++) {
hex += HEX[value[i] >> 4];
hex += HEX[value[i] & 15];
}
messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
} else {
messageDetails.push(key + "=" + JSON.stringify(value));
}
} catch (error2) {
messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
}
});
messageDetails.push(`code=${code}`);
messageDetails.push(`version=${this.version}`);
const reason = message;
let url = "";
switch (code) {
case "NUMERIC_FAULT" /* NUMERIC_FAULT */: {
url = "NUMERIC_FAULT";
const fault = message;
switch (fault) {
case "overflow":
case "underflow":
case "division-by-zero":
url += "-" + fault;
break;
case "negative-power":
case "negative-width":
url += "-unsupported";
break;
case "unbound-bitwise-result":
url += "-unbound-result";
break;
}
break;
}
case "CALL_EXCEPTION" /* CALL_EXCEPTION */:
case "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */:
case "MISSING_NEW" /* MISSING_NEW */:
case "NONCE_EXPIRED" /* NONCE_EXPIRED */:
case "REPLACEMENT_UNDERPRICED" /* REPLACEMENT_UNDERPRICED */:
case "TRANSACTION_REPLACED" /* TRANSACTION_REPLACED */:
case "UNPREDICTABLE_GAS_LIMIT" /* UNPREDICTABLE_GAS_LIMIT */:
url = code;
break;
}
if (url) {
message += " [ See: https://links.ethers.org/v5-errors-" + url + " ]";
}
if (messageDetails.length) {
message += " (" + messageDetails.join(", ") + ")";
}
const error = new Error(message);
error.reason = reason;
error.code = code;
Object.keys(params).forEach(function(key) {
error[key] = params[key];
});
return error;
}
throwError(message, code, params) {
throw this.makeError(message, code, params);
}
throwArgumentError(message, name, value) {
return this.throwError(message, _Logger.errors.INVALID_ARGUMENT, {
argument: name,
value
});
}
assert(condition, message, code, params) {
if (!!condition) {
return;
}
this.throwError(message, code, params);
}
assertArgument(condition, message, name, value) {
if (!!condition) {
return;
}
this.throwArgumentError(message, name, value);
}
checkNormalize(message) {
if (message == null) {
message = "platform missing String.prototype.normalize";
}
if (_normalizeError) {
this.throwError("platform missing String.prototype.normalize", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "String.prototype.normalize",
form: _normalizeError
});
}
}
checkSafeUint53(value, message) {
if (typeof value !== "number") {
return;
}
if (message == null) {
message = "value not safe";
}
if (value < 0 || value >= 9007199254740991) {
this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "out-of-safe-range",
value
});
}
if (value % 1) {
this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "non-integer",
value
});
}
}
checkArgumentCount(count, expectedCount, message) {
if (message) {
message = ": " + message;
} else {
message = "";
}
if (count < expectedCount) {
this.throwError("missing argument" + message, _Logger.errors.MISSING_ARGUMENT, {
count,
expectedCount
});
}
if (count > expectedCount) {
this.throwError("too many arguments" + message, _Logger.errors.UNEXPECTED_ARGUMENT, {
count,
expectedCount
});
}
}
checkNew(target, kind) {
if (target === Object || target == null) {
this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
}
}
checkAbstract(target, kind) {
if (target === kind) {
this.throwError(
"cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class",
_Logger.errors.UNSUPPORTED_OPERATION,
{ name: target.name, operation: "new" }
);
} else if (target === Object || target == null) {
this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
}
}
static globalLogger() {
if (!_globalLogger) {
_globalLogger = new _Logger(version3);
}
return _globalLogger;
}
static setCensorship(censorship, permanent) {
if (!censorship && permanent) {
this.globalLogger().throwError("cannot permanently disable censorship", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "setCensorship"
});
}
if (_permanentCensorErrors) {
if (!censorship) {
return;
}
this.globalLogger().throwError("error censorship permanent", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "setCensorship"
});
}
_censorErrors = !!censorship;
_permanentCensorErrors = !!permanent;
}
static setLogLevel(logLevel) {
const level = LogLevels[logLevel.toLowerCase()];
if (level == null) {
_Logger.globalLogger().warn("invalid log level - " + logLevel);
return;
}
_logLevel = level;
}
static from(version5) {
return new _Logger(version5);
}
};
_Logger.errors = ErrorCode;
_Logger.levels = LogLevel;
var Logger = _Logger;
// src/sdk/types/bignumber.ts
var version4 = "logger/5.7.0";
var logger = new Logger(version4);
// src/sdk/common/ERC4337Utils.ts
var ErrorSig = keccak256(import_buffer.Buffer.from("Error(string)")).slice(0, 10);
var FailedOpSig = keccak256(import_buffer.Buffer.from("FailedOp(uint256,string)")).slice(0, 10);
// src/sdk/network/ViemChainConfig.ts
var sourceId = 1;
var optimism = /* @__PURE__ */ defineChain({
id: 10,
name: "OP Mainnet",
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://mainnet.optimism.io"]
}
},
blockExplorers: {
default: {
name: "Optimism Explorer",
url: "https://optimistic.etherscan.io",
apiUrl: "https://api-optimistic.etherscan.io/api"
}
},
contracts: {
disputeGameFactory: {
[sourceId]: {
address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9"
}
},
l2OutputOracle: {
[sourceId]: {
address: "0xdfe97868233d1aa22e815a266982f2cf17685a27"
}
},
multicall3: {
address: "0xca11bde05977b3631167028862be2a173976ca11",
blockCreated: 4286263
},
portal: {
[sourceId]: {
address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed"
}
},
l1StandardBridge: {
[sourceId]: {
address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1"
}
}
},
sourceId
});
var base = /* @__PURE__ */ defineChain({
id: 8453,
name: "Base",
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://mainnet.base.org"]
}
},
blockExplorers: {
default: {
name: "Basescan",
url: "https://basescan.org",
apiUrl: "https://api.basescan.org/api"
}
},
contracts: {
l2OutputOracle: {
[sourceId]: {
address: "0x56315b90c40730925ec5485cf004d835058518A0"
}
},
multicall3: {
address: "0xca11bde05977b3631167028862be2a173976ca11",
blockCreated: 5022
},
portal: {
[sourceId]: {
address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e",
blockCreated: 17482143
}
},
l1StandardBridge: {
[sourceId]: {
address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35",
blockCreated: 17482143
}
}
},
sourceId
});
var ancient8 = /* @__PURE__ */ defineChain({
id: 888888888,
name: "Ancient8",
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://rpc.ancient8.gg"]
}
},
blockExplorers: {
default: {
name: "Ancient8 explorer",
url: "https://scan.ancient8.gg",
apiUrl: "https://scan.ancient8.gg/api"
}
},
contracts: {
l2OutputOracle: {
[sourceId]: {
address: "0xB09DC08428C8b4EFB4ff9C0827386CDF34277996"
}
},
portal: {
[sourceId]: {
address: "0x639F2AECE398Aa76b07e59eF6abe2cFe32bacb68",
blockCreated: 19070571
}
},
l1StandardBridge: {
[sourceId]: {
address: "0xd5e3eDf5b68135D559D572E26bF863FBC1950033",
blockCreated: 19070571
}
}
},
sourceId
});
sourceId = 11155111;
var optimismSepolia = /* @__PURE__ */ defineChain({
id: 11155420,
name: "OP Sepolia",
nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://sepolia.optimism.io"]
}
},
blockExplorers: {
default: {
name: "Blockscout",
url: "https://optimism-sepolia.blockscout.com",
apiUrl: "https://optimism-sepolia.blockscout.com/api"
}
},
contracts: {
disputeGameFactory: {
[sourceId]: {
address: "0x05F9613aDB30026FFd634f38e5C4dFd30a197Fa1"
}
},
l2OutputOracle: {
[sourceId]: {
address: "0x90E9c4f8a994a250F6aEfd61CAFb4F2e895D458F"
}
},
multicall3: {
address: "0xca11bde05977b3631167028862be2a173976ca11",
blockCreated: 1620204
},
portal: {
[sourceId]: {
address: "0x16Fc5058F25648194471939df75CF27A2fdC48BC"
}
},
l1StandardBridge: {
[sourceId]: {
address: "0xFBb0621E0B23b5478B630BD55a5f21f67730B0F1"
}
}
},
testnet: true,
sourceId
});
var ancient8Sepolia = /* @__PURE__ */ defineChain({
id: 28122024,
name: "Ancient8 Testnet",
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: {
http: ["https://rpcv2-testnet.ancient8.gg"]
}
},
blockExplorers: {
default: {
name: "Ancient8 Celestia Testnet explorer",
url: "https://scanv2-testnet.ancient8.gg",
apiUrl: "https://scanv2-testnet.ancient8.gg/api"
}
},
contracts: {
l2OutputOracle: {
[sourceId]: {
address: "0x942fD5017c0F60575930D8574Eaca13BEcD6e1bB"
}
},
portal: {
[sourceId]: {
address: "0xfa1d9E26A6aCD7b22115D27572c1221B9803c960",
blockCreated: 4972908
}
},
l1StandardBridge: {
[sourceId]: {
address: "0xF6Bc0146d3c74D48306e79Ae134A260E418C9335",
blockCreated: 4972908
}
}
},
sourceId
});
// src/sdk/network/constants.ts
var NETWORK_NAME_TO_CHAIN_ID = {
["baseSepolia" /* BaseSepolia */]: 84532,
["sepolia" /* Sepolia */]: 11155111,
["optimism" /* Optimism */]: 10,
["polygon" /* Polygon */]: 137,
["arbitrum" /* Arbitrum */]: 42161,
["arbitrumSepolia" /* ArbitrumSepolia */]: 421614,
["chiado" /* Chiado */]: 10200,
["fuse" /* Fuse */]: 122,
["fuseSparknet" /* FuseSparknet */]: 123,
["gnosis" /* Gnosis */]: 100,
["kromaTestnet" /* KromaTestnet */]: 2357,
["mainnet" /* Mainnet */]: 1,
["optimismSepolia" /* OptimismSepolia */]: 11155420,
["rootstock" /* Rootstock */]: 30,
["rootstockTestnet" /* RootstockTestnet */]: 31,
["Mantle" /* Mantle */]: 5e3,
["MantleSepolia" /* MantleSepolia */]: 5003,
["avalanche" /* Avalanche */]: 43114,
["base" /* Base */]: 8453,
["bsc" /* Bsc */]: 56,
["bscTestnet" /* BscTestnet */]: 97,
["fuji" /* Fuji */]: 43113,
["linea" /* Linea */]: 59144,
["lineaTestnet" /* LineaTestnet */]: 59140,
["flareTestnet" /* FlareTestnet */]: 114,
["flare" /* Flare */]: 14,
["scrollSepolia" /* ScrollSepolia */]: 534351,
["scroll" /* Scroll */]: 534352,
["ancient8Testnet" /* Ancient8Testnet */]: 28122024,
["ancient8" /* Ancient8 */]: 888888888,
["amoy" /* Amoy */]: 80002,
["xdcTestnet" /* XDCTestnet */]: 51,
["xdcMainnet" /* XDCMainnet */]: 50
};
var CHAIN_ID_TO_NETWORK_NAME = Object.entries(
NETWORK_NAME_TO_CHAIN_ID
).reduce(
(result, [networkName, chainId]) => ({
...result,
[chainId]: networkName
}),
{}
);
// src/sdk/common/abis.ts
var sessionKeyValidatorAbi = [
"function enableSessionKey(bytes calldata _sessionData)",
"function disableSessionKey(address _session)",
"function rotateSessionKey(address _oldSessionKey,bytes calldata _newSessionData)",
"function getAssociatedSessionKeys() returns (address[] memory keys)",
"function isSessionKeyLive(address _sessionKey) returns (bool)",
"function getSessionKeyData(address _sessionKey) returns (address token,bytes4 funcSelector,uint256 spendingLimit,uint48 validAfter,uint48 validUntil, bool live)"
];
// src/sdk/session-keys/erc20-sessionkey-onchain.ts
var getOnchainSessionKeyData = async (etherspotWalletAddress, publicClient, sesssionKeyValidatorAddress, sessionKey) => {
const data = await publicClient.simulateContract({
account: etherspotWalletAddress,
address: sesssionKeyValidatorAddress,
abi: parseAbi(sessionKeyValidatorAbi),
functionName: "sessionData",
args: [sessionKey, etherspotWalletAddress]
});
if (!data.result || data.result == null) {
throw new Error("Session data not found");
}
const { token, funcSelector, spendingLimit, validAfter, validUntil, live } = data.result;
return {
account: etherspotWalletAddress,
token,
funcSelector,
spendingLimit,
validAfter,
validUntil,
live
};
};
var isSessionKeyLiveOnChain = async (etherspotWalletAddress, publicClient, sesssionKeyValidatorAddress, sessionKey) => {
const data = await publicClient.simulateContract({
account: etherspotWalletAddress,
address: sesssionKeyValidatorAddress,
abi: parseAbi(sessionKeyValidatorAbi),
functionName: "isSessionKeyLive",
args: [sessionKey]
});
if (!data.result || data.result == null) {
throw new Error("Session data not found");
}
return data.result;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
getOnchainSessionKeyData,
isSessionKeyLiveOnChain
});
/*! Bundled license information:
@noble/hashes/esm/utils.js:
(*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
*/
//# sourceMappingURL=erc20-sessionkey-onchain.js.map