@autogames/sdk 1.1.1

package/dist/index-HQNbtrlg.js

@@ -0,0 +1,341 @@
+function u(e) {
+  const t = new Uint8Array(e);
+  let n = "";
+  for (const r of t)
+    n += String.fromCharCode(r);
+  return btoa(n).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function g(e) {
+  const t = e.replace(/-/g, "+").replace(/_/g, "/"), n = (4 - t.length % 4) % 4, a = t.padEnd(t.length + n, "="), r = atob(a), l = new ArrayBuffer(r.length), d = new Uint8Array(l);
+  for (let o = 0; o < r.length; o++)
+    d[o] = r.charCodeAt(o);
+  return l;
+}
+function R() {
+  return S.stubThis(globalThis?.PublicKeyCredential !== void 0 && typeof globalThis.PublicKeyCredential == "function");
+}
+const S = {
+  stubThis: (e) => e
+};
+function m(e) {
+  const { id: t } = e;
+  return {
+    ...e,
+    id: g(t),
+    /**
+     * `descriptor.transports` is an array of our `AuthenticatorTransportFuture` that includes newer
+     * transports that TypeScript's DOM lib is ignorant of. Convince TS that our list of transports
+     * are fine to pass to WebAuthn since browsers will recognize the new value.
+     */
+    transports: e.transports
+  };
+}
+function y(e) {
+  return (
+    // Consider localhost valid as well since it's okay wrt Secure Contexts
+    e === "localhost" || /^([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}$/i.test(e)
+  );
+}
+class i extends Error {
+  constructor({ message: t, code: n, cause: a, name: r }) {
+    super(t, { cause: a }), Object.defineProperty(this, "code", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    }), this.name = r ?? a.name, this.code = n;
+  }
+}
+function I({ error: e, options: t }) {
+  const { publicKey: n } = t;
+  if (!n)
+    throw Error("options was missing required publicKey property");
+  if (e.name === "AbortError") {
+    if (t.signal instanceof AbortSignal)
+      return new i({
+        message: "Registration ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: e
+      });
+  } else if (e.name === "ConstraintError") {
+    if (n.authenticatorSelection?.requireResidentKey === !0)
+      return new i({
+        message: "Discoverable credentials were required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT",
+        cause: e
+      });
+    if (
+      // @ts-ignore: `mediation` doesn't yet exist on CredentialCreationOptions but it's possible as of Sept 2024
+      t.mediation === "conditional" && n.authenticatorSelection?.userVerification === "required"
+    )
+      return new i({
+        message: "User verification was required during automatic registration but it could not be performed",
+        code: "ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE",
+        cause: e
+      });
+    if (n.authenticatorSelection?.userVerification === "required")
+      return new i({
+        message: "User verification was required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT",
+        cause: e
+      });
+  } else {
+    if (e.name === "InvalidStateError")
+      return new i({
+        message: "The authenticator was previously registered",
+        code: "ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED",
+        cause: e
+      });
+    if (e.name === "NotAllowedError")
+      return new i({
+        message: e.message,
+        code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+        cause: e
+      });
+    if (e.name === "NotSupportedError")
+      return n.pubKeyCredParams.filter((r) => r.type === "public-key").length === 0 ? new i({
+        message: 'No entry in pubKeyCredParams was of type "public-key"',
+        code: "ERROR_MALFORMED_PUBKEYCREDPARAMS",
+        cause: e
+      }) : new i({
+        message: "No available authenticator supported any of the specified pubKeyCredParams algorithms",
+        code: "ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG",
+        cause: e
+      });
+    if (e.name === "SecurityError") {
+      const a = globalThis.location.hostname;
+      if (y(a)) {
+        if (n.rp.id !== a)
+          return new i({
+            message: `The RP ID "${n.rp.id}" is invalid for this domain`,
+            code: "ERROR_INVALID_RP_ID",
+            cause: e
+          });
+      } else return new i({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: e
+      });
+    } else if (e.name === "TypeError") {
+      if (n.user.id.byteLength < 1 || n.user.id.byteLength > 64)
+        return new i({
+          message: "User ID was not between 1 and 64 characters",
+          code: "ERROR_INVALID_USER_ID_LENGTH",
+          cause: e
+        });
+    } else if (e.name === "UnknownError")
+      return new i({
+        message: "The authenticator was unable to process the specified options, or could not create a new credential",
+        code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+        cause: e
+      });
+  }
+  return e;
+}
+class T {
+  constructor() {
+    Object.defineProperty(this, "controller", {
+      enumerable: !0,
+      configurable: !0,
+      writable: !0,
+      value: void 0
+    });
+  }
+  createNewAbortSignal() {
+    if (this.controller) {
+      const n = new Error("Cancelling existing WebAuthn API call for new one");
+      n.name = "AbortError", this.controller.abort(n);
+    }
+    const t = new AbortController();
+    return this.controller = t, t.signal;
+  }
+  cancelCeremony() {
+    if (this.controller) {
+      const t = new Error("Manually cancelling existing WebAuthn API call");
+      t.name = "AbortError", this.controller.abort(t), this.controller = void 0;
+    }
+  }
+}
+const O = new T(), P = ["cross-platform", "platform"];
+function _(e) {
+  if (e && !(P.indexOf(e) < 0))
+    return e;
+}
+async function D(e) {
+  !e.optionsJSON && e.challenge && (console.warn("startRegistration() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information."), e = { optionsJSON: e });
+  const { optionsJSON: t, useAutoRegister: n = !1 } = e;
+  if (!R())
+    throw new Error("WebAuthn is not supported in this browser");
+  const a = {
+    ...t,
+    challenge: g(t.challenge),
+    user: {
+      ...t.user,
+      id: g(t.user.id)
+    },
+    excludeCredentials: t.excludeCredentials?.map(m)
+  }, r = {};
+  n && (r.mediation = "conditional"), r.publicKey = a, r.signal = O.createNewAbortSignal();
+  let l;
+  try {
+    l = await navigator.credentials.create(r);
+  } catch (c) {
+    throw I({ error: c, options: r });
+  }
+  if (!l)
+    throw new Error("Registration was not completed");
+  const { id: d, rawId: o, response: s, type: w } = l;
+  let h;
+  typeof s.getTransports == "function" && (h = s.getTransports());
+  let p;
+  if (typeof s.getPublicKeyAlgorithm == "function")
+    try {
+      p = s.getPublicKeyAlgorithm();
+    } catch (c) {
+      A("getPublicKeyAlgorithm()", c);
+    }
+  let f;
+  if (typeof s.getPublicKey == "function")
+    try {
+      const c = s.getPublicKey();
+      c !== null && (f = u(c));
+    } catch (c) {
+      A("getPublicKey()", c);
+    }
+  let b;
+  if (typeof s.getAuthenticatorData == "function")
+    try {
+      b = u(s.getAuthenticatorData());
+    } catch (c) {
+      A("getAuthenticatorData()", c);
+    }
+  return {
+    id: d,
+    rawId: u(o),
+    response: {
+      attestationObject: u(s.attestationObject),
+      clientDataJSON: u(s.clientDataJSON),
+      transports: h,
+      publicKeyAlgorithm: p,
+      publicKey: f,
+      authenticatorData: b
+    },
+    type: w,
+    clientExtensionResults: l.getClientExtensionResults(),
+    authenticatorAttachment: _(l.authenticatorAttachment)
+  };
+}
+function A(e, t) {
+  console.warn(`The browser extension that intercepted this WebAuthn API call incorrectly implemented ${e}. You should report this error to them.
+`, t);
+}
+function C() {
+  if (!R())
+    return E.stubThis(new Promise((t) => t(!1)));
+  const e = globalThis.PublicKeyCredential;
+  return e?.isConditionalMediationAvailable === void 0 ? E.stubThis(new Promise((t) => t(!1))) : E.stubThis(e.isConditionalMediationAvailable());
+}
+const E = {
+  stubThis: (e) => e
+};
+function N({ error: e, options: t }) {
+  const { publicKey: n } = t;
+  if (!n)
+    throw Error("options was missing required publicKey property");
+  if (e.name === "AbortError") {
+    if (t.signal instanceof AbortSignal)
+      return new i({
+        message: "Authentication ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: e
+      });
+  } else {
+    if (e.name === "NotAllowedError")
+      return new i({
+        message: e.message,
+        code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+        cause: e
+      });
+    if (e.name === "SecurityError") {
+      const a = globalThis.location.hostname;
+      if (y(a)) {
+        if (n.rpId !== a)
+          return new i({
+            message: `The RP ID "${n.rpId}" is invalid for this domain`,
+            code: "ERROR_INVALID_RP_ID",
+            cause: e
+          });
+      } else return new i({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: e
+      });
+    } else if (e.name === "UnknownError")
+      return new i({
+        message: "The authenticator was unable to process the specified options, or could not create a new assertion signature",
+        code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+        cause: e
+      });
+  }
+  return e;
+}
+async function v(e) {
+  !e.optionsJSON && e.challenge && (console.warn("startAuthentication() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information."), e = { optionsJSON: e });
+  const { optionsJSON: t, useBrowserAutofill: n = !1, verifyBrowserAutofillInput: a = !0 } = e;
+  if (!R())
+    throw new Error("WebAuthn is not supported in this browser");
+  let r;
+  t.allowCredentials?.length !== 0 && (r = t.allowCredentials?.map(m));
+  const l = {
+    ...t,
+    challenge: g(t.challenge),
+    allowCredentials: r
+  }, d = {};
+  if (n) {
+    if (!await C())
+      throw Error("Browser does not support WebAuthn autofill");
+    if (document.querySelectorAll("input[autocomplete$='webauthn']").length < 1 && a)
+      throw Error('No <input> with "webauthn" as the only or last value in its `autocomplete` attribute was detected');
+    d.mediation = "conditional", l.allowCredentials = [];
+  }
+  d.publicKey = l, d.signal = O.createNewAbortSignal();
+  let o;
+  try {
+    o = await navigator.credentials.get(d);
+  } catch (b) {
+    throw N({ error: b, options: d });
+  }
+  if (!o)
+    throw new Error("Authentication was not completed");
+  const { id: s, rawId: w, response: h, type: p } = o;
+  let f;
+  return h.userHandle && (f = u(h.userHandle)), {
+    id: s,
+    rawId: u(w),
+    response: {
+      authenticatorData: u(h.authenticatorData),
+      clientDataJSON: u(h.clientDataJSON),
+      signature: u(h.signature),
+      userHandle: f
+    },
+    type: p,
+    clientExtensionResults: o.getClientExtensionResults(),
+    authenticatorAttachment: _(o.authenticatorAttachment)
+  };
+}
+function K() {
+  return R() ? PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable() : new Promise((e) => e(!1));
+}
+export {
+  O as WebAuthnAbortService,
+  i as WebAuthnError,
+  E as _browserSupportsWebAuthnAutofillInternals,
+  S as _browserSupportsWebAuthnInternals,
+  g as base64URLStringToBuffer,
+  R as browserSupportsWebAuthn,
+  C as browserSupportsWebAuthnAutofill,
+  u as bufferToBase64URLString,
+  K as platformAuthenticatorIsAvailable,
+  v as startAuthentication,
+  D as startRegistration
+};

package/dist/index-zA8BVXWW.js

@@ -0,0 +1,264 @@
+import { D as s, E as o, F as e, G as t, H as n, J as i, K as c, L as d, M as E, N as u, O as l, P as b, Q as p, R as T, T as g, V as h, ba as m, aL as y, aK as v, a4 as A, ar as F, a5 as S, a6 as R, aM as f, X as C, ab as I, aN as N, a7 as x, a8 as B, a9 as D, C as P, aa as U, ac as w, ad as H, ae as M, af as k, Y as L, Z as z, aO as q, as as V, an as O, ao as G, ap as j, aq as W, av as K, aw as J, ax as Z, bc as Q, au as X, aH as Y, ay as _, aj as $, aP as aa, az as ra, aA as sa, _ as oa, $ as ea, I as ta, a3 as na, a0 as ia, ak as ca, bm as da, a1 as Ea, bj as ua, a as la, al as ba, aQ as pa, b as Ta, c as ga, aR as ha, d as ma, bk as ya, aS as va, bd as Aa, e as Fa, f as Sa, bl as Ra, aT as fa, aU as Ca, at as Ia, aV as Na, aW as xa, aB as Ba, aC as Da, aD as Pa, aX as Ua, aY as wa, aZ as Ha, ag as Ma, a_ as ka, a$ as La, b0 as za, aI as qa, ah as Va, am as Oa, ai as Ga, S as ja, bb as Wa, b1 as Ka, aJ as Ja, aE as Za, be as Qa, bf as Xa, bg as Ya, b2 as _a, aF as $a, b3 as ar, b4 as rr, aG as sr, b5 as or, U as er, g as tr, b6 as nr, b7 as ir, a2 as cr, b8 as dr, bi as Er, b9 as ur, W as lr, bh as br, bL as pr, cI as Tr, bF as gr, bG as hr, c5 as mr, ca as yr, bZ as vr, b_ as Ar, cb as Fr, b$ as Sr, c0 as Rr, bB as fr, bI as Cr, bH as Ir, bN as Nr, bO as xr, bP as Br, h as Dr, i as Pr, l as Ur, j as wr, m as Hr, bn as Mr, bo as kr, bp as Lr, bq as zr, br as qr, t as Vr, u as Or, bs as Gr, bt as jr, bu as Wr, bv as Kr, bw as Jr, bx as Zr, o as Qr, q as Xr, v as Yr, s as _r, A as $r, cj as as, cN as rs, cO as ss, ck as os, cl as es, cn as ts, co as ns, cP as is, by as cs, bC as ds, bM as Es, ci as us, ct as ls, cu as bs, cv as ps, cu as Ts, cJ as gs, cK as hs, B as ms, cA as ys, cz as vs, cB as As, cC as Fs, c1 as Ss, c2 as Rs, c6 as fs, c3 as Cs, c4 as Is, n as Ns, bD as xs, bE as Bs, bQ as Ds, cq as Ps, cg as Us, x as ws, r as Hs, ch as Ms, c7 as ks, cc as Ls, bR as zs, bS as qs, bT as Vs, p as Os, cQ as Gs, bz as js, cR as Ws, bA as Ks, y as Js, k as Zs, cD as Qs, cE as Xs, cp as Ys, cF as _s, cL as $s, cr as ao, cF as ro, bU as so, bV as oo, bW as eo, bX as to, c8 as no, cd as io, cH as co, bJ as Eo, bK as uo, c9 as lo, cs as bo, ct as po, cu as To, cs as go, cv as ho, cu as mo, ce as yo, cG as vo, cf as Ao, cm as Fo, bY as So, q as Ro, v as fo, cM as Co, w as Io, cw as No, cx as xo, cy as Bo, z as Do } from "./bridge-mount-Bhf05oeO.js";
+import { f as Uo, s as wo } from "./core-CnCeDQAm.js";
+import { c as Mo, d as ko, e as Lo, p as zo, p as qo, s as Vo } from "./parseSignature-DFDCc7FD.js";
+import { ccipRequest as Go, ccipRequest as jo, offchainLookup as Wo, offchainLookupAbiItem as Ko, offchainLookupSignature as Jo } from "./ccip-Bg_nydEz.js";
+export {
+  s as AbiConstructorNotFoundError,
+  o as AbiConstructorParamsNotFoundError,
+  e as AbiDecodingDataSizeTooSmallError,
+  t as AbiDecodingZeroDataError,
+  n as AbiEncodingArrayLengthMismatchError,
+  i as AbiEncodingBytesSizeMismatchError,
+  c as AbiEncodingLengthMismatchError,
+  d as AbiErrorInputsNotFoundError,
+  E as AbiErrorNotFoundError,
+  u as AbiErrorSignatureNotFoundError,
+  l as AbiEventNotFoundError,
+  b as AbiEventSignatureEmptyTopicsError,
+  p as AbiEventSignatureNotFoundError,
+  T as AbiFunctionNotFoundError,
+  g as AbiFunctionOutputsNotFoundError,
+  h as AbiFunctionSignatureNotFoundError,
+  m as AccountStateConflictError,
+  y as AtomicReadyWalletRejectedUpgradeError,
+  v as AtomicityNotSupportedError,
+  A as BaseError,
+  F as BaseFeeScalarError,
+  S as BlockNotFoundError,
+  R as BundleFailedError,
+  f as BundleTooLargeError,
+  C as BytesSizeMismatchError,
+  I as CallExecutionError,
+  N as ChainDisconnectedError,
+  x as ChainDoesNotSupportContract,
+  B as ChainMismatchError,
+  D as ChainNotFoundError,
+  P as CircularReferenceError,
+  U as ClientChainNotConfiguredError,
+  w as ContractFunctionExecutionError,
+  H as ContractFunctionRevertedError,
+  M as ContractFunctionZeroDataError,
+  k as CounterfactualDeploymentFailedError,
+  L as DecodeLogDataMismatch,
+  z as DecodeLogTopicsMismatch,
+  q as DuplicateIdError,
+  V as Eip1559FeesNotSupportedError,
+  O as EnsAvatarInvalidNftUriError,
+  G as EnsAvatarUnsupportedNamespaceError,
+  j as EnsAvatarUriResolutionError,
+  W as EstimateGasExecutionError,
+  K as ExecutionRevertedError,
+  J as FeeCapTooHighError,
+  Z as FeeCapTooLowError,
+  Q as FeeConflictError,
+  X as FilterTypeNotSupportedError,
+  Y as HttpRequestError,
+  _ as InsufficientFundsError,
+  $ as IntegerOutOfRangeError,
+  aa as InternalRpcError,
+  ra as IntrinsicGasTooHighError,
+  sa as IntrinsicGasTooLowError,
+  oa as InvalidAbiDecodingTypeError,
+  ea as InvalidAbiEncodingTypeError,
+  ta as InvalidAbiTypeParameterError,
+  na as InvalidAddressError,
+  ia as InvalidArrayError,
+  ca as InvalidBytesBooleanError,
+  da as InvalidDecimalNumberError,
+  Ea as InvalidDefinitionTypeError,
+  ua as InvalidDomainError,
+  la as InvalidFunctionModifierError,
+  ba as InvalidHexBooleanError,
+  pa as InvalidInputRpcError,
+  Ta as InvalidModifierError,
+  ga as InvalidParameterError,
+  ha as InvalidParamsRpcError,
+  ma as InvalidParenthesisError,
+  ya as InvalidPrimaryTypeError,
+  va as InvalidRequestRpcError,
+  Aa as InvalidSerializableTransactionError,
+  Fa as InvalidSignatureError,
+  Sa as InvalidStructSignatureError,
+  Ra as InvalidStructTypeError,
+  fa as JsonRpcVersionUnsupportedError,
+  Ca as LimitExceededRpcError,
+  Ia as MaxFeePerGasTooLowError,
+  Na as MethodNotFoundRpcError,
+  xa as MethodNotSupportedRpcError,
+  Ba as NonceMaxValueError,
+  Da as NonceTooHighError,
+  Pa as NonceTooLowError,
+  Ua as ParseRpcError,
+  wa as ProviderDisconnectedError,
+  Ha as ProviderRpcError,
+  Ma as RawContractError,
+  ka as ResourceNotFoundRpcError,
+  La as ResourceUnavailableRpcError,
+  za as RpcError,
+  qa as RpcRequestError,
+  Va as SizeExceedsPaddingSizeError,
+  Oa as SizeOverflowError,
+  Ga as SliceOffsetOutOfBoundsError,
+  ja as SolidityProtectedKeywordError,
+  Wa as StateAssignmentConflictError,
+  Ka as SwitchChainError,
+  Ja as TimeoutError,
+  Za as TipAboveFeeCapError,
+  Qa as TransactionExecutionError,
+  Xa as TransactionNotFoundError,
+  Ya as TransactionReceiptNotFoundError,
+  _a as TransactionRejectedRpcError,
+  $a as TransactionTypeNotSupportedError,
+  ar as UnauthorizedProviderError,
+  rr as UnknownBundleIdError,
+  sr as UnknownNodeError,
+  or as UnknownRpcError,
+  er as UnknownSignatureError,
+  tr as UnknownTypeError,
+  nr as UnsupportedChainIdError,
+  ir as UnsupportedNonOptionalCapabilityError,
+  cr as UnsupportedPackedAbiType,
+  dr as UnsupportedProviderMethodError,
+  Er as UrlRequiredError,
+  ur as UserRejectedRequestError,
+  lr as WaitForCallsStatusTimeoutError,
+  br as WaitForTransactionReceiptTimeoutError,
+  pr as assertCurrentChain,
+  Tr as assertRequest,
+  gr as blobsToCommitments,
+  hr as blobsToProofs,
+  mr as boolToBytes,
+  yr as boolToHex,
+  vr as bytesToBigInt,
+  Ar as bytesToBool,
+  Fr as bytesToHex,
+  Sr as bytesToNumber,
+  Rr as bytesToString,
+  Go as ccipFetch,
+  jo as ccipRequest,
+  fr as checksumAddress,
+  Cr as commitmentToVersionedHash,
+  Ir as commitmentsToVersionedHashes,
+  Nr as concat,
+  xr as concatBytes,
+  Br as concatHex,
+  Dr as createClient,
+  Mo as createNonceManager,
+  Pr as createPublicClient,
+  Ur as createTransport,
+  wr as createWalletClient,
+  Hr as custom,
+  Mr as decodeAbiParameters,
+  kr as decodeErrorResult,
+  Lr as decodeEventLog,
+  zr as decodeFunctionData,
+  qr as decodeFunctionResult,
+  ko as defineChain,
+  Vr as deploylessCallViaBytecodeBytecode,
+  Or as deploylessCallViaFactoryBytecode,
+  Gr as encodeAbiParameters,
+  jr as encodeDeployData,
+  Wr as encodeErrorResult,
+  Kr as encodeEventTopics,
+  Jr as encodeFunctionData,
+  Zr as encodeFunctionResult,
+  Lo as encodePacked,
+  Qr as erc20Abi,
+  Xr as erc6492SignatureValidatorAbi,
+  Yr as erc6492SignatureValidatorByteCode,
+  _r as ethAddress,
+  $r as etherUnits,
+  Uo as fallback,
+  as as formatBlock,
+  rs as formatEther,
+  ss as formatGwei,
+  os as formatLog,
+  es as formatTransaction,
+  ts as formatTransactionReceipt,
+  ns as formatTransactionRequest,
+  is as formatUnits,
+  cs as getAbiItem,
+  ds as getAddress,
+  Es as getChainContractAddress,
+  us as getContractError,
+  ls as getEventSelector,
+  bs as getEventSignature,
+  ps as getFunctionSelector,
+  Ts as getFunctionSignature,
+  gs as getTransactionType,
+  hs as getTypesForEIP712Domain,
+  ms as gweiUnits,
+  ys as hashDomain,
+  vs as hashMessage,
+  As as hashStruct,
+  Fs as hashTypedData,
+  Ss as hexToBigInt,
+  Rs as hexToBool,
+  fs as hexToBytes,
+  Cs as hexToNumber,
+  zo as hexToSignature,
+  Is as hexToString,
+  Ns as http,
+  xs as isAddress,
+  Bs as isAddressEqual,
+  Ds as isHex,
+  Ps as keccak256,
+  Us as labelhash,
+  ws as maxUint256,
+  Hs as multicall3Abi,
+  Ms as namehash,
+  ks as numberToBytes,
+  Ls as numberToHex,
+  Wo as offchainLookup,
+  Ko as offchainLookupAbiItem,
+  Jo as offchainLookupSignature,
+  zs as pad,
+  qs as padBytes,
+  Vs as padHex,
+  Os as parseAbi,
+  Gs as parseEther,
+  js as parseEventLogs,
+  qo as parseSignature,
+  Ws as parseUnits,
+  Ks as prepareEncodeFunctionData,
+  Js as presignMessagePrefix,
+  Zs as publicActions,
+  Qs as recoverAddress,
+  Xs as recoverPublicKey,
+  Ys as rpcTransactionType,
+  Vo as serializeErc6492Signature,
+  _s as serializeSignature,
+  $s as serializeTypedData,
+  ao as sha256,
+  wo as shouldThrow,
+  ro as signatureToHex,
+  so as size,
+  oo as slice,
+  eo as sliceBytes,
+  to as sliceHex,
+  no as stringToBytes,
+  io as stringToHex,
+  co as stringify,
+  Eo as toBlobSidecars,
+  uo as toBlobs,
+  lo as toBytes,
+  bo as toEventHash,
+  po as toEventSelector,
+  To as toEventSignature,
+  go as toFunctionHash,
+  ho as toFunctionSelector,
+  mo as toFunctionSignature,
+  yo as toHex,
+  vo as toPrefixedMessage,
+  Ao as toRlp,
+  Fo as transactionType,
+  So as trim,
+  Ro as universalSignatureValidatorAbi,
+  fo as universalSignatureValidatorByteCode,
+  Co as validateTypedData,
+  Io as walletActions,
+  No as withCache,
+  xo as withRetry,
+  Bo as withTimeout,
+  Do as zeroAddress
+};