@metamask/utils 8.1.0 → 8.2.1

package/dist/chunk-OLLG4H35.js

@@ -0,0 +1,257 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk6ZDHSOUVjs = require('./chunk-6ZDHSOUV.js');
+
+
+var _chunkQVEKZRZ2js = require('./chunk-QVEKZRZ2.js');
+
+// src/json.ts
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _superstruct = require('superstruct');
+var object = (schema) => (
+  // The type is slightly different from a regular object struct, because we
+  // want to make properties with `undefined` in their type optional, but not
+  // `undefined` itself. This means that we need a type cast.
+  _superstruct.object.call(void 0, schema)
+);
+function hasOptional({ path, branch }) {
+  const field = path[path.length - 1];
+  return _chunkQVEKZRZ2js.hasProperty.call(void 0, branch[branch.length - 2], field);
+}
+function exactOptional(struct) {
+  return new (0, _superstruct.Struct)({
+    ...struct,
+    type: `optional ${struct.type}`,
+    validator: (value, context) => !hasOptional(context) || struct.validator(value, context),
+    refiner: (value, context) => !hasOptional(context) || struct.refiner(value, context)
+  });
+}
+var finiteNumber = () => _superstruct.define.call(void 0, "finite number", (value) => {
+  return _superstruct.is.call(void 0, value, _superstruct.number.call(void 0, )) && Number.isFinite(value);
+});
+var UnsafeJsonStruct = _superstruct.union.call(void 0, [
+  _superstruct.literal.call(void 0, null),
+  _superstruct.boolean.call(void 0, ),
+  finiteNumber(),
+  _superstruct.string.call(void 0, ),
+  _superstruct.array.call(void 0, _superstruct.lazy.call(void 0, () => UnsafeJsonStruct)),
+  _superstruct.record.call(void 0, 
+    _superstruct.string.call(void 0, ),
+    _superstruct.lazy.call(void 0, () => UnsafeJsonStruct)
+  )
+]);
+var JsonStruct = _superstruct.coerce.call(void 0, UnsafeJsonStruct, _superstruct.any.call(void 0, ), (value) => {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, value, UnsafeJsonStruct);
+  return JSON.parse(
+    JSON.stringify(value, (propKey, propValue) => {
+      if (propKey === "__proto__" || propKey === "constructor") {
+        return void 0;
+      }
+      return propValue;
+    })
+  );
+});
+function isValidJson(value) {
+  try {
+    getSafeJson(value);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function getSafeJson(value) {
+  return _superstruct.create.call(void 0, value, JsonStruct);
+}
+function getJsonSize(value) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, value, JsonStruct, "Invalid JSON value");
+  const json = JSON.stringify(value);
+  return new TextEncoder().encode(json).byteLength;
+}
+var jsonrpc2 = "2.0";
+var JsonRpcVersionStruct = _superstruct.literal.call(void 0, jsonrpc2);
+var JsonRpcIdStruct = _superstruct.nullable.call(void 0, _superstruct.union.call(void 0, [_superstruct.number.call(void 0, ), _superstruct.string.call(void 0, )]));
+var JsonRpcErrorStruct = object({
+  code: _superstruct.integer.call(void 0, ),
+  message: _superstruct.string.call(void 0, ),
+  data: exactOptional(JsonStruct),
+  stack: exactOptional(_superstruct.string.call(void 0, ))
+});
+var JsonRpcParamsStruct = _superstruct.union.call(void 0, [_superstruct.record.call(void 0, _superstruct.string.call(void 0, ), JsonStruct), _superstruct.array.call(void 0, JsonStruct)]);
+var JsonRpcRequestStruct = object({
+  id: JsonRpcIdStruct,
+  jsonrpc: JsonRpcVersionStruct,
+  method: _superstruct.string.call(void 0, ),
+  params: exactOptional(JsonRpcParamsStruct)
+});
+var JsonRpcNotificationStruct = object({
+  jsonrpc: JsonRpcVersionStruct,
+  method: _superstruct.string.call(void 0, ),
+  params: exactOptional(JsonRpcParamsStruct)
+});
+function isJsonRpcNotification(value) {
+  return _superstruct.is.call(void 0, value, JsonRpcNotificationStruct);
+}
+function assertIsJsonRpcNotification(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcNotificationStruct,
+    "Invalid JSON-RPC notification",
+    ErrorWrapper
+  );
+}
+function isJsonRpcRequest(value) {
+  return _superstruct.is.call(void 0, value, JsonRpcRequestStruct);
+}
+function assertIsJsonRpcRequest(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcRequestStruct,
+    "Invalid JSON-RPC request",
+    ErrorWrapper
+  );
+}
+var PendingJsonRpcResponseStruct = _superstruct.object.call(void 0, {
+  id: JsonRpcIdStruct,
+  jsonrpc: JsonRpcVersionStruct,
+  result: _superstruct.optional.call(void 0, _superstruct.unknown.call(void 0, )),
+  error: _superstruct.optional.call(void 0, JsonRpcErrorStruct)
+});
+var JsonRpcSuccessStruct = object({
+  id: JsonRpcIdStruct,
+  jsonrpc: JsonRpcVersionStruct,
+  result: JsonStruct
+});
+var JsonRpcFailureStruct = object({
+  id: JsonRpcIdStruct,
+  jsonrpc: JsonRpcVersionStruct,
+  error: JsonRpcErrorStruct
+});
+var JsonRpcResponseStruct = _superstruct.union.call(void 0, [
+  JsonRpcSuccessStruct,
+  JsonRpcFailureStruct
+]);
+function isPendingJsonRpcResponse(response) {
+  return _superstruct.is.call(void 0, response, PendingJsonRpcResponseStruct);
+}
+function assertIsPendingJsonRpcResponse(response, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    response,
+    PendingJsonRpcResponseStruct,
+    "Invalid pending JSON-RPC response",
+    ErrorWrapper
+  );
+}
+function isJsonRpcResponse(response) {
+  return _superstruct.is.call(void 0, response, JsonRpcResponseStruct);
+}
+function assertIsJsonRpcResponse(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcResponseStruct,
+    "Invalid JSON-RPC response",
+    ErrorWrapper
+  );
+}
+function isJsonRpcSuccess(value) {
+  return _superstruct.is.call(void 0, value, JsonRpcSuccessStruct);
+}
+function assertIsJsonRpcSuccess(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcSuccessStruct,
+    "Invalid JSON-RPC success response",
+    ErrorWrapper
+  );
+}
+function isJsonRpcFailure(value) {
+  return _superstruct.is.call(void 0, value, JsonRpcFailureStruct);
+}
+function assertIsJsonRpcFailure(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcFailureStruct,
+    "Invalid JSON-RPC failure response",
+    ErrorWrapper
+  );
+}
+function isJsonRpcError(value) {
+  return _superstruct.is.call(void 0, value, JsonRpcErrorStruct);
+}
+function assertIsJsonRpcError(value, ErrorWrapper) {
+  _chunk6ZDHSOUVjs.assertStruct.call(void 0, 
+    value,
+    JsonRpcErrorStruct,
+    "Invalid JSON-RPC error",
+    ErrorWrapper
+  );
+}
+function getJsonRpcIdValidator(options) {
+  const { permitEmptyString, permitFractions, permitNull } = {
+    permitEmptyString: true,
+    permitFractions: false,
+    permitNull: true,
+    ...options
+  };
+  const isValidJsonRpcId = (id) => {
+    return Boolean(
+      typeof id === "number" && (permitFractions || Number.isInteger(id)) || typeof id === "string" && (permitEmptyString || id.length > 0) || permitNull && id === null
+    );
+  };
+  return isValidJsonRpcId;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.object = object; exports.exactOptional = exactOptional; exports.UnsafeJsonStruct = UnsafeJsonStruct; exports.JsonStruct = JsonStruct; exports.isValidJson = isValidJson; exports.getSafeJson = getSafeJson; exports.getJsonSize = getJsonSize; exports.jsonrpc2 = jsonrpc2; exports.JsonRpcVersionStruct = JsonRpcVersionStruct; exports.JsonRpcIdStruct = JsonRpcIdStruct; exports.JsonRpcErrorStruct = JsonRpcErrorStruct; exports.JsonRpcParamsStruct = JsonRpcParamsStruct; exports.JsonRpcRequestStruct = JsonRpcRequestStruct; exports.JsonRpcNotificationStruct = JsonRpcNotificationStruct; exports.isJsonRpcNotification = isJsonRpcNotification; exports.assertIsJsonRpcNotification = assertIsJsonRpcNotification; exports.isJsonRpcRequest = isJsonRpcRequest; exports.assertIsJsonRpcRequest = assertIsJsonRpcRequest; exports.PendingJsonRpcResponseStruct = PendingJsonRpcResponseStruct; exports.JsonRpcSuccessStruct = JsonRpcSuccessStruct; exports.JsonRpcFailureStruct = JsonRpcFailureStruct; exports.JsonRpcResponseStruct = JsonRpcResponseStruct; exports.isPendingJsonRpcResponse = isPendingJsonRpcResponse; exports.assertIsPendingJsonRpcResponse = assertIsPendingJsonRpcResponse; exports.isJsonRpcResponse = isJsonRpcResponse; exports.assertIsJsonRpcResponse = assertIsJsonRpcResponse; exports.isJsonRpcSuccess = isJsonRpcSuccess; exports.assertIsJsonRpcSuccess = assertIsJsonRpcSuccess; exports.isJsonRpcFailure = isJsonRpcFailure; exports.assertIsJsonRpcFailure = assertIsJsonRpcFailure; exports.isJsonRpcError = isJsonRpcError; exports.assertIsJsonRpcError = assertIsJsonRpcError; exports.getJsonRpcIdValidator = getJsonRpcIdValidator;
+//# sourceMappingURL=chunk-OLLG4H35.js.map

package/dist/chunk-OLLG4H35.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Context, Infer } from 'superstruct';\nimport {\n  any,\n  array,\n  boolean,\n  coerce,\n  create,\n  define,\n  integer,\n  is,\n  lazy,\n  literal,\n  nullable,\n  number,\n  object as superstructObject,\n  optional,\n  record,\n  string,\n  union,\n  unknown,\n  Struct,\n} from 'superstruct';\nimport type {\n  ObjectSchema,\n  Optionalize,\n  Simplify,\n} from 'superstruct/dist/utils';\n\nimport type { AssertionErrorConstructor } from './assert';\nimport { assertStruct } from './assert';\nimport { hasProperty } from './misc';\n\n/**\n * Any JSON-compatible value.\n */\nexport type Json =\n  | null\n  | boolean\n  | number\n  | string\n  | Json[]\n  | { [prop: string]: Json };\n\n/**\n * A helper type to make properties with `undefined` in their type optional, but\n * not `undefined` itself.\n *\n * @example\n * ```ts\n * type Foo = ObjectOptional<{ foo: string | undefined }>;\n * // Foo is equivalent to { foo?: string }\n * ```\n */\nexport type ObjectOptional<Schema extends Record<string, unknown>> = {\n  [Key in keyof Schema as Schema[Key] extends ExactOptionalGuard\n    ? Key\n    : never]?: Schema[Key] extends ExactOptionalGuard & infer Original\n    ? Original\n    : never;\n} & {\n  [Key in keyof Schema as Schema[Key] extends ExactOptionalGuard\n    ? never\n    : Key]: Schema[Key];\n};\n\n/**\n * An object type with support for exact optionals. This is used by the `object`\n * struct. This uses the {@link ObjectOptional} helper to make properties with\n * `undefined` in their type optional, but not `undefined` itself.\n */\nexport type ObjectType<Schema extends ObjectSchema> = Simplify<\n  ObjectOptional<\n    Optionalize<{\n      [Key in keyof Schema]: Infer<Schema[Key]>;\n    }>\n  >\n>;\n\n/**\n * A struct to check if the given value is a valid object, with support for\n * {@link exactOptional} types.\n *\n * @param schema - The schema of the object.\n * @returns A struct to check if the given value is an object.\n */\nexport const object = <Schema extends ObjectSchema>(\n  schema: Schema,\n): Struct<ObjectType<Schema>> =>\n  // The type is slightly different from a regular object struct, because we\n  // want to make properties with `undefined` in their type optional, but not\n  // `undefined` itself. This means that we need a type cast.\n  superstructObject(schema) as unknown as Struct<ObjectType<Schema>>;\n\ndeclare const exactOptionalSymbol: unique symbol;\ntype ExactOptionalGuard = {\n  _exactOptionalGuard?: typeof exactOptionalSymbol;\n};\n\n/**\n * Check the last field of a path is present.\n *\n * @param context - The context to check.\n * @param context.path - The path to check.\n * @param context.branch - The branch to check.\n * @returns Whether the last field of a path is present.\n */\nfunction hasOptional({ path, branch }: Context): boolean {\n  const field = path[path.length - 1];\n  return hasProperty(branch[branch.length - 2], field);\n}\n\n/**\n * A struct which allows the property of an object to be absent, or to be present\n * as long as it's valid and not set to `undefined`.\n *\n * This struct should be used in conjunction with the {@link object} from this\n * library, to get proper type inference.\n *\n * @param struct - The struct to check the value against, if present.\n * @returns A struct to check if the given value is valid, or not present.\n * @example\n * ```ts\n * const struct = object({\n *   foo: exactOptional(string()),\n *   bar: exactOptional(number()),\n *   baz: optional(boolean()),\n *   qux: unknown(),\n * });\n *\n * type Type = Infer<typeof struct>;\n * // Type is equivalent to:\n * // {\n * //   foo?: string;\n * //   bar?: number;\n * //   baz?: boolean | undefined;\n * //   qux: unknown;\n * // }\n * ```\n */\nexport function exactOptional<Type, Schema>(\n  struct: Struct<Type, Schema>,\n): Struct<Type & ExactOptionalGuard, Schema> {\n  return new Struct<Type & ExactOptionalGuard, Schema>({\n    ...struct,\n\n    type: `optional ${struct.type}`,\n    validator: (value, context) =>\n      !hasOptional(context) || struct.validator(value, context),\n\n    refiner: (value, context) =>\n      !hasOptional(context) || struct.refiner(value as Type, context),\n  });\n}\n\n/**\n * A struct to check if the given value is finite number. Superstruct's\n * `number()` struct does not check if the value is finite.\n *\n * @returns A struct to check if the given value is finite number.\n */\nconst finiteNumber = () =>\n  define<number>('finite number', (value) => {\n    return is(value, number()) && Number.isFinite(value);\n  });\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * Note that this struct is unsafe. For safe validation, use {@link JsonStruct}.\n */\n// We cannot infer the type of the struct, because it is recursive.\nexport const UnsafeJsonStruct: Struct<Json> = union([\n  literal(null),\n  boolean(),\n  finiteNumber(),\n  string(),\n  array(lazy(() => UnsafeJsonStruct)),\n  record(\n    string(),\n    lazy(() => UnsafeJsonStruct),\n  ),\n]);\n\n/**\n * A struct to check if the given value is a valid JSON-serializable value.\n *\n * This struct sanitizes the value before validating it, so that it is safe to\n * use with untrusted input.\n */\nexport const JsonStruct = coerce(UnsafeJsonStruct, any(), (value) => {\n  assertStruct(value, UnsafeJsonStruct);\n  return JSON.parse(\n    JSON.stringify(value, (propKey, propValue) => {\n      // Strip __proto__ and constructor properties to prevent prototype pollution.\n      if (propKey === '__proto__' || propKey === 'constructor') {\n        return undefined;\n      }\n      return propValue;\n    }),\n  );\n});\n\n/**\n * Check if the given value is a valid {@link Json} value, i.e., a value that is\n * serializable to JSON.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid {@link Json} value.\n */\nexport function isValidJson(value: unknown): value is Json {\n  try {\n    getSafeJson(value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate and return sanitized JSON.\n *\n * Note:\n * This function uses sanitized JsonStruct for validation\n * that applies stringify and then parse of a value provided\n * to ensure that there are no getters which can have side effects\n * that can cause security issues.\n *\n * @param value - JSON structure to be processed.\n * @returns Sanitized JSON structure.\n */\nexport function getSafeJson<Type extends Json = Json>(value: unknown): Type {\n  return create(value, JsonStruct) as Type;\n}\n\n/**\n * Get the size of a JSON value in bytes. This also validates the value.\n *\n * @param value - The JSON value to get the size of.\n * @returns The size of the JSON value in bytes.\n */\nexport function getJsonSize(value: unknown): number {\n  assertStruct(value, JsonStruct, 'Invalid JSON value');\n\n  const json = JSON.stringify(value);\n  return new TextEncoder().encode(json).byteLength;\n}\n\n/**\n * The string '2.0'.\n */\nexport const jsonrpc2 = '2.0' as const;\nexport const JsonRpcVersionStruct = literal(jsonrpc2);\n\n/**\n * A String specifying the version of the JSON-RPC protocol.\n * MUST be exactly \"2.0\".\n */\nexport type JsonRpcVersion2 = typeof jsonrpc2;\n\nexport const JsonRpcIdStruct = nullable(union([number(), string()]));\n\n/**\n * An identifier established by the Client that MUST contain a String, Number,\n * or NULL value if included. If it is not included it is assumed to be a\n * notification. The value SHOULD normally not be Null and Numbers SHOULD\n * NOT contain fractional parts.\n */\nexport type JsonRpcId = Infer<typeof JsonRpcIdStruct>;\n\nexport const JsonRpcErrorStruct = object({\n  code: integer(),\n  message: string(),\n  data: exactOptional(JsonStruct),\n  stack: exactOptional(string()),\n});\n\n/**\n * Mark a certain key of a type as optional.\n */\nexport type OptionalField<\n  Type extends Record<string, unknown>,\n  Key extends keyof Type,\n> = Omit<Type, Key> & Partial<Pick<Type, Key>>;\n\n/**\n * A JSON-RPC error object.\n *\n * Note that TypeScript infers `unknown | undefined` as `unknown`, meaning that\n * the `data` field is not optional. To make it optional, we use the\n * `OptionalField` helper, to explicitly make it optional.\n */\nexport type JsonRpcError = OptionalField<\n  Infer<typeof JsonRpcErrorStruct>,\n  'data'\n>;\n\nexport const JsonRpcParamsStruct: Struct<Json[] | Record<string, Json>, null> =\n  union([record(string(), JsonStruct), array(JsonStruct)]);\n\nexport type JsonRpcParams = Json[] | Record<string, Json>;\n\nexport const JsonRpcRequestStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: exactOptional(JsonRpcParamsStruct),\n});\n\nexport type InferWithParams<\n  Type extends Struct<any>,\n  Params extends JsonRpcParams,\n> = Infer<Type> & {\n  params?: Params;\n};\n\n/**\n * A JSON-RPC request object.\n */\nexport type JsonRpcRequest<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcRequestStruct, Params>;\n\nexport const JsonRpcNotificationStruct = object({\n  jsonrpc: JsonRpcVersionStruct,\n  method: string(),\n  params: exactOptional(JsonRpcParamsStruct),\n});\n\n/**\n * A JSON-RPC notification object.\n */\nexport type JsonRpcNotification<Params extends JsonRpcParams = JsonRpcParams> =\n  InferWithParams<typeof JsonRpcNotificationStruct, Params>;\n\n/**\n * Check if the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcNotification}\n * object.\n */\nexport function isJsonRpcNotification(\n  value: unknown,\n): value is JsonRpcNotification {\n  return is(value, JsonRpcNotificationStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcNotification} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcNotification} object.\n */\nexport function assertIsJsonRpcNotification(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcNotification {\n  assertStruct(\n    value,\n    JsonRpcNotificationStruct,\n    'Invalid JSON-RPC notification',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcRequest} object.\n */\nexport function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {\n  return is(value, JsonRpcRequestStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcRequest} object.\n *\n * @param value - The JSON-RPC request or notification to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcRequest} object.\n */\nexport function assertIsJsonRpcRequest(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcRequest {\n  assertStruct(\n    value,\n    JsonRpcRequestStruct,\n    'Invalid JSON-RPC request',\n    ErrorWrapper,\n  );\n}\n\nexport const PendingJsonRpcResponseStruct = superstructObject({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: optional(unknown()),\n  error: optional(JsonRpcErrorStruct),\n});\n\n/**\n * A JSON-RPC response object that has not yet been resolved.\n */\nexport type PendingJsonRpcResponse<Result extends Json> = Omit<\n  Infer<typeof PendingJsonRpcResponseStruct>,\n  'result'\n> & {\n  result?: Result;\n};\n\nexport const JsonRpcSuccessStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  result: JsonStruct,\n});\n\n/**\n * A successful JSON-RPC response object.\n */\nexport type JsonRpcSuccess<Result extends Json> = Omit<\n  Infer<typeof JsonRpcSuccessStruct>,\n  'result'\n> & {\n  result: Result;\n};\n\nexport const JsonRpcFailureStruct = object({\n  id: JsonRpcIdStruct,\n  jsonrpc: JsonRpcVersionStruct,\n  error: JsonRpcErrorStruct as Struct<JsonRpcError>,\n});\n\n/**\n * A failed JSON-RPC response object.\n */\nexport type JsonRpcFailure = Infer<typeof JsonRpcFailureStruct>;\n\nexport const JsonRpcResponseStruct = union([\n  JsonRpcSuccessStruct,\n  JsonRpcFailureStruct,\n]);\n\n/**\n * A JSON-RPC response object. Must be checked to determine whether it's a\n * success or failure.\n *\n * @template Result - The type of the result.\n */\nexport type JsonRpcResponse<Result extends Json> =\n  | JsonRpcSuccess<Result>\n  | JsonRpcFailure;\n\n/**\n * Type guard to check whether specified JSON-RPC response is a\n * {@link PendingJsonRpcResponse}.\n *\n * @param response - The JSON-RPC response to check.\n * @returns Whether the specified JSON-RPC response is pending.\n */\nexport function isPendingJsonRpcResponse(\n  response: unknown,\n): response is PendingJsonRpcResponse<Json> {\n  return is(response, PendingJsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link PendingJsonRpcResponse} object.\n *\n * @param response - The JSON-RPC response to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link PendingJsonRpcResponse}\n * object.\n */\nexport function assertIsPendingJsonRpcResponse(\n  response: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts response is PendingJsonRpcResponse<Json> {\n  assertStruct(\n    response,\n    PendingJsonRpcResponseStruct,\n    'Invalid pending JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Type guard to check if a value is a {@link JsonRpcResponse}.\n *\n * @param response - The object to check.\n * @returns Whether the object is a JsonRpcResponse.\n */\nexport function isJsonRpcResponse(\n  response: unknown,\n): response is JsonRpcResponse<Json> {\n  return is(response, JsonRpcResponseStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcResponse} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcResponse} object.\n */\nexport function assertIsJsonRpcResponse(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcResponse<Json> {\n  assertStruct(\n    value,\n    JsonRpcResponseStruct,\n    'Invalid JSON-RPC response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcSuccess} object.\n */\nexport function isJsonRpcSuccess(\n  value: unknown,\n): value is JsonRpcSuccess<Json> {\n  return is(value, JsonRpcSuccessStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcSuccess} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcSuccess} object.\n */\nexport function assertIsJsonRpcSuccess(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcSuccess<Json> {\n  assertStruct(\n    value,\n    JsonRpcSuccessStruct,\n    'Invalid JSON-RPC success response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcFailure} object.\n */\nexport function isJsonRpcFailure(value: unknown): value is JsonRpcFailure {\n  return is(value, JsonRpcFailureStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcFailure} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcFailure} object.\n */\nexport function assertIsJsonRpcFailure(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcFailure {\n  assertStruct(\n    value,\n    JsonRpcFailureStruct,\n    'Invalid JSON-RPC failure response',\n    ErrorWrapper,\n  );\n}\n\n/**\n * Check if the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @returns Whether the given value is a valid {@link JsonRpcError} object.\n */\nexport function isJsonRpcError(value: unknown): value is JsonRpcError {\n  return is(value, JsonRpcErrorStruct);\n}\n\n/**\n * Assert that the given value is a valid {@link JsonRpcError} object.\n *\n * @param value - The value to check.\n * @param ErrorWrapper - The error class to throw if the assertion fails.\n * Defaults to {@link AssertionError}.\n * @throws If the given value is not a valid {@link JsonRpcError} object.\n */\nexport function assertIsJsonRpcError(\n  value: unknown,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  ErrorWrapper?: AssertionErrorConstructor,\n): asserts value is JsonRpcError {\n  assertStruct(\n    value,\n    JsonRpcErrorStruct,\n    'Invalid JSON-RPC error',\n    ErrorWrapper,\n  );\n}\n\ntype JsonRpcValidatorOptions = {\n  permitEmptyString?: boolean;\n  permitFractions?: boolean;\n  permitNull?: boolean;\n};\n\n/**\n * Gets a function for validating JSON-RPC request / response `id` values.\n *\n * By manipulating the options of this factory, you can control the behavior\n * of the resulting validator for some edge cases. This is useful because e.g.\n * `null` should sometimes but not always be permitted.\n *\n * Note that the empty string (`''`) is always permitted by the JSON-RPC\n * specification, but that kind of sucks and you may want to forbid it in some\n * instances anyway.\n *\n * For more details, see the\n * [JSON-RPC Specification](https://www.jsonrpc.org/specification).\n *\n * @param options - An options object.\n * @param options.permitEmptyString - Whether the empty string (i.e. `''`)\n * should be treated as a valid ID. Default: `true`\n * @param options.permitFractions - Whether fractional numbers (e.g. `1.2`)\n * should be treated as valid IDs. Default: `false`\n * @param options.permitNull - Whether `null` should be treated as a valid ID.\n * Default: `true`\n * @returns The JSON-RPC ID validator function.\n */\nexport function getJsonRpcIdValidator(options?: JsonRpcValidatorOptions) {\n  const { permitEmptyString, permitFractions, permitNull } = {\n    permitEmptyString: true,\n    permitFractions: false,\n    permitNull: true,\n    ...options,\n  };\n\n  /**\n   * Type guard for {@link JsonRpcId}.\n   *\n   * @param id - The JSON-RPC ID value to check.\n   * @returns Whether the given ID is valid per the options given to the\n   * factory.\n   */\n  const isValidJsonRpcId = (id: unknown): id is JsonRpcId => {\n    return Boolean(\n      (typeof id === 'number' && (permitFractions || Number.isInteger(id))) ||\n        (typeof id === 'string' && (permitEmptyString || id.length > 0)) ||\n        (permitNull && id === null),\n    );\n  };\n\n  return isValidJsonRpcId;\n}\n"]}

package/dist/chunk-QEPVHEP7.js

@@ -0,0 +1,273 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk6ZDHSOUVjs = require('./chunk-6ZDHSOUV.js');
+
+// src/hex.ts
+var _sha3 = require('@noble/hashes/sha3');
+var _superstruct = require('superstruct');
+
+// src/bytes.ts
+var _base = require('@scure/base');
+var HEX_MINIMUM_NUMBER_CHARACTER = 48;
+var HEX_MAXIMUM_NUMBER_CHARACTER = 58;
+var HEX_CHARACTER_OFFSET = 87;
+function getPrecomputedHexValuesBuilder() {
+  const lookupTable = [];
+  return () => {
+    if (lookupTable.length === 0) {
+      for (let i = 0; i < 256; i++) {
+        lookupTable.push(i.toString(16).padStart(2, "0"));
+      }
+    }
+    return lookupTable;
+  };
+}
+var getPrecomputedHexValues = getPrecomputedHexValuesBuilder();
+function isBytes(value) {
+  return value instanceof Uint8Array;
+}
+function assertIsBytes(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, isBytes(value), "Value must be a Uint8Array.");
+}
+function bytesToHex(bytes) {
+  assertIsBytes(bytes);
+  if (bytes.length === 0) {
+    return "0x";
+  }
+  const lookupTable = getPrecomputedHexValues();
+  const hexadecimal = new Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    hexadecimal[i] = lookupTable[bytes[i]];
+  }
+  return add0x(hexadecimal.join(""));
+}
+function bytesToBigInt(bytes) {
+  assertIsBytes(bytes);
+  const hexadecimal = bytesToHex(bytes);
+  return BigInt(hexadecimal);
+}
+function bytesToSignedBigInt(bytes) {
+  assertIsBytes(bytes);
+  let value = BigInt(0);
+  for (const byte of bytes) {
+    value = (value << BigInt(8)) + BigInt(byte);
+  }
+  return BigInt.asIntN(bytes.length * 8, value);
+}
+function bytesToNumber(bytes) {
+  assertIsBytes(bytes);
+  const bigint = bytesToBigInt(bytes);
+  _chunk6ZDHSOUVjs.assert.call(void 0, 
+    bigint <= BigInt(Number.MAX_SAFE_INTEGER),
+    "Number is not a safe integer. Use `bytesToBigInt` instead."
+  );
+  return Number(bigint);
+}
+function bytesToString(bytes) {
+  assertIsBytes(bytes);
+  return new TextDecoder().decode(bytes);
+}
+function bytesToBase64(bytes) {
+  assertIsBytes(bytes);
+  return _base.base64.encode(bytes);
+}
+function hexToBytes(value) {
+  if (_optionalChain([value, 'optionalAccess', _ => _.toLowerCase, 'optionalCall', _2 => _2()]) === "0x") {
+    return new Uint8Array();
+  }
+  assertIsHexString(value);
+  const strippedValue = remove0x(value).toLowerCase();
+  const normalizedValue = strippedValue.length % 2 === 0 ? strippedValue : `0${strippedValue}`;
+  const bytes = new Uint8Array(normalizedValue.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const c1 = normalizedValue.charCodeAt(i * 2);
+    const c2 = normalizedValue.charCodeAt(i * 2 + 1);
+    const n1 = c1 - (c1 < HEX_MAXIMUM_NUMBER_CHARACTER ? HEX_MINIMUM_NUMBER_CHARACTER : HEX_CHARACTER_OFFSET);
+    const n2 = c2 - (c2 < HEX_MAXIMUM_NUMBER_CHARACTER ? HEX_MINIMUM_NUMBER_CHARACTER : HEX_CHARACTER_OFFSET);
+    bytes[i] = n1 * 16 + n2;
+  }
+  return bytes;
+}
+function bigIntToBytes(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "bigint", "Value must be a bigint.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, value >= BigInt(0), "Value must be a non-negative bigint.");
+  const hexadecimal = value.toString(16);
+  return hexToBytes(hexadecimal);
+}
+function bigIntFits(value, bytes) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, bytes > 0);
+  const mask = value >> BigInt(31);
+  return !((~value & mask) + (value & ~mask) >> BigInt(bytes * 8 + ~0));
+}
+function signedBigIntToBytes(value, byteLength) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "bigint", "Value must be a bigint.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof byteLength === "number", "Byte length must be a number.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, byteLength > 0, "Byte length must be greater than 0.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, 
+    bigIntFits(value, byteLength),
+    "Byte length is too small to represent the given value."
+  );
+  let numberValue = value;
+  const bytes = new Uint8Array(byteLength);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number(BigInt.asUintN(8, numberValue));
+    numberValue >>= BigInt(8);
+  }
+  return bytes.reverse();
+}
+function numberToBytes(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "number", "Value must be a number.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, value >= 0, "Value must be a non-negative number.");
+  _chunk6ZDHSOUVjs.assert.call(void 0, 
+    Number.isSafeInteger(value),
+    "Value is not a safe integer. Use `bigIntToBytes` instead."
+  );
+  const hexadecimal = value.toString(16);
+  return hexToBytes(hexadecimal);
+}
+function stringToBytes(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "string", "Value must be a string.");
+  return new TextEncoder().encode(value);
+}
+function base64ToBytes(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, typeof value === "string", "Value must be a string.");
+  return _base.base64.decode(value);
+}
+function valueToBytes(value) {
+  if (typeof value === "bigint") {
+    return bigIntToBytes(value);
+  }
+  if (typeof value === "number") {
+    return numberToBytes(value);
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("0x")) {
+      return hexToBytes(value);
+    }
+    return stringToBytes(value);
+  }
+  if (isBytes(value)) {
+    return value;
+  }
+  throw new TypeError(`Unsupported value type: "${typeof value}".`);
+}
+function concatBytes(values) {
+  const normalizedValues = new Array(values.length);
+  let byteLength = 0;
+  for (let i = 0; i < values.length; i++) {
+    const value = valueToBytes(values[i]);
+    normalizedValues[i] = value;
+    byteLength += value.length;
+  }
+  const bytes = new Uint8Array(byteLength);
+  for (let i = 0, offset = 0; i < normalizedValues.length; i++) {
+    bytes.set(normalizedValues[i], offset);
+    offset += normalizedValues[i].length;
+  }
+  return bytes;
+}
+function createDataView(bytes) {
+  if (typeof Buffer !== "undefined" && bytes instanceof Buffer) {
+    const buffer = bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength
+    );
+    return new DataView(buffer);
+  }
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+
+// src/hex.ts
+var HexStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), /^(?:0x)?[0-9a-f]+$/iu);
+var StrictHexStruct = _superstruct.pattern.call(void 0, _superstruct.string.call(void 0, ), /^0x[0-9a-f]+$/iu);
+var HexAddressStruct = _superstruct.pattern.call(void 0, 
+  _superstruct.string.call(void 0, ),
+  /^0x[0-9a-f]{40}$/u
+);
+var HexChecksumAddressStruct = _superstruct.pattern.call(void 0, 
+  _superstruct.string.call(void 0, ),
+  /^0x[0-9a-fA-F]{40}$/u
+);
+function isHexString(value) {
+  return _superstruct.is.call(void 0, value, HexStruct);
+}
+function isStrictHexString(value) {
+  return _superstruct.is.call(void 0, value, StrictHexStruct);
+}
+function assertIsHexString(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, isHexString(value), "Value must be a hexadecimal string.");
+}
+function assertIsStrictHexString(value) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, 
+    isStrictHexString(value),
+    'Value must be a hexadecimal string, starting with "0x".'
+  );
+}
+function isValidHexAddress(possibleAddress) {
+  return _superstruct.is.call(void 0, possibleAddress, HexAddressStruct) || isValidChecksumAddress(possibleAddress);
+}
+function getChecksumAddress(address) {
+  _chunk6ZDHSOUVjs.assert.call(void 0, _superstruct.is.call(void 0, address, HexChecksumAddressStruct), "Invalid hex address.");
+  const unPrefixed = remove0x(address.toLowerCase());
+  const unPrefixedHash = remove0x(bytesToHex(_sha3.keccak_256.call(void 0, unPrefixed)));
+  return `0x${unPrefixed.split("").map((character, nibbleIndex) => {
+    const hashCharacter = unPrefixedHash[nibbleIndex];
+    _chunk6ZDHSOUVjs.assert.call(void 0, _superstruct.is.call(void 0, hashCharacter, _superstruct.string.call(void 0, )), "Hash shorter than address.");
+    return parseInt(hashCharacter, 16) > 7 ? character.toUpperCase() : character;
+  }).join("")}`;
+}
+function isValidChecksumAddress(possibleChecksum) {
+  if (!_superstruct.is.call(void 0, possibleChecksum, HexChecksumAddressStruct)) {
+    return false;
+  }
+  return getChecksumAddress(possibleChecksum) === possibleChecksum;
+}
+function add0x(hexadecimal) {
+  if (hexadecimal.startsWith("0x")) {
+    return hexadecimal;
+  }
+  if (hexadecimal.startsWith("0X")) {
+    return `0x${hexadecimal.substring(2)}`;
+  }
+  return `0x${hexadecimal}`;
+}
+function remove0x(hexadecimal) {
+  if (hexadecimal.startsWith("0x") || hexadecimal.startsWith("0X")) {
+    return hexadecimal.substring(2);
+  }
+  return hexadecimal;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HexStruct = HexStruct; exports.StrictHexStruct = StrictHexStruct; exports.HexAddressStruct = HexAddressStruct; exports.HexChecksumAddressStruct = HexChecksumAddressStruct; exports.isHexString = isHexString; exports.isStrictHexString = isStrictHexString; exports.assertIsHexString = assertIsHexString; exports.assertIsStrictHexString = assertIsStrictHexString; exports.isValidHexAddress = isValidHexAddress; exports.getChecksumAddress = getChecksumAddress; exports.isValidChecksumAddress = isValidChecksumAddress; exports.add0x = add0x; exports.remove0x = remove0x; exports.isBytes = isBytes; exports.assertIsBytes = assertIsBytes; exports.bytesToHex = bytesToHex; exports.bytesToBigInt = bytesToBigInt; exports.bytesToSignedBigInt = bytesToSignedBigInt; exports.bytesToNumber = bytesToNumber; exports.bytesToString = bytesToString; exports.bytesToBase64 = bytesToBase64; exports.hexToBytes = hexToBytes; exports.bigIntToBytes = bigIntToBytes; exports.signedBigIntToBytes = signedBigIntToBytes; exports.numberToBytes = numberToBytes; exports.stringToBytes = stringToBytes; exports.base64ToBytes = base64ToBytes; exports.valueToBytes = valueToBytes; exports.concatBytes = concatBytes; exports.createDataView = createDataView;
+//# sourceMappingURL=chunk-QEPVHEP7.js.map

package/dist/chunk-QEPVHEP7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hex.ts","../src/bytes.ts"],"names":[],"mappings":"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","sourcesContent":["import { keccak_256 as keccak256 } from '@noble/hashes/sha3';\nimport type { Struct } from 'superstruct';\nimport { is, pattern, string } from 'superstruct';\n\nimport { assert } from './assert';\nimport { bytesToHex } from './bytes';\n\nexport type Hex = `0x${string}`;\n\nexport const HexStruct = pattern(string(), /^(?:0x)?[0-9a-f]+$/iu);\nexport const StrictHexStruct = pattern(string(), /^0x[0-9a-f]+$/iu) as Struct<\n  Hex,\n  null\n>;\nexport const HexAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-f]{40}$/u,\n) as Struct<Hex, null>;\nexport const HexChecksumAddressStruct = pattern(\n  string(),\n  /^0x[0-9a-fA-F]{40}$/u,\n) as Struct<Hex, null>;\n\n/**\n * Check if a string is a valid hex string.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isHexString(value: unknown): value is string {\n  return is(value, HexStruct);\n}\n\n/**\n * Strictly check if a string is a valid hex string. A valid hex string must\n * start with the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @returns Whether the value is a valid hex string.\n */\nexport function isStrictHexString(value: unknown): value is Hex {\n  return is(value, StrictHexStruct);\n}\n\n/**\n * Assert that a value is a valid hex string.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsHexString(value: unknown): asserts value is string {\n  assert(isHexString(value), 'Value must be a hexadecimal string.');\n}\n\n/**\n * Assert that a value is a valid hex string. A valid hex string must start with\n * the \"0x\"-prefix.\n *\n * @param value - The value to check.\n * @throws If the value is not a valid hex string.\n */\nexport function assertIsStrictHexString(value: unknown): asserts value is Hex {\n  assert(\n    isStrictHexString(value),\n    'Value must be a hexadecimal string, starting with \"0x\".',\n  );\n}\n\n/**\n * Validate that the passed prefixed hex string is an all-lowercase\n * hex address, or a valid mixed-case checksum address.\n *\n * @param possibleAddress - Input parameter to check against.\n * @returns Whether or not the input is a valid hex address.\n */\nexport function isValidHexAddress(possibleAddress: Hex) {\n  return (\n    is(possibleAddress, HexAddressStruct) ||\n    isValidChecksumAddress(possibleAddress)\n  );\n}\n\n/**\n * Encode a passed hex string as an ERC-55 mixed-case checksum address.\n *\n * @param address - The hex address to encode.\n * @returns The address encoded according to ERC-55.\n * @see https://eips.ethereum.org/EIPS/eip-55\n */\nexport function getChecksumAddress(address: Hex) {\n  assert(is(address, HexChecksumAddressStruct), 'Invalid hex address.');\n  const unPrefixed = remove0x(address.toLowerCase());\n  const unPrefixedHash = remove0x(bytesToHex(keccak256(unPrefixed)));\n  return `0x${unPrefixed\n    .split('')\n    .map((character, nibbleIndex) => {\n      const hashCharacter = unPrefixedHash[nibbleIndex];\n      assert(is(hashCharacter, string()), 'Hash shorter than address.');\n      return parseInt(hashCharacter, 16) > 7\n        ? character.toUpperCase()\n        : character;\n    })\n    .join('')}`;\n}\n\n/**\n * Validate that the passed hex string is a valid ERC-55 mixed-case\n * checksum address.\n *\n * @param possibleChecksum - The hex address to check.\n * @returns True if the address is a checksum address.\n */\nexport function isValidChecksumAddress(possibleChecksum: Hex) {\n  if (!is(possibleChecksum, HexChecksumAddressStruct)) {\n    return false;\n  }\n\n  return getChecksumAddress(possibleChecksum) === possibleChecksum;\n}\n\n/**\n * Add the `0x`-prefix to a hexadecimal string. If the string already has the\n * prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to add the prefix to.\n * @returns The prefixed hexadecimal string.\n */\nexport function add0x(hexadecimal: string): Hex {\n  if (hexadecimal.startsWith('0x')) {\n    return hexadecimal as Hex;\n  }\n\n  if (hexadecimal.startsWith('0X')) {\n    return `0x${hexadecimal.substring(2)}`;\n  }\n\n  return `0x${hexadecimal}`;\n}\n\n/**\n * Remove the `0x`-prefix from a hexadecimal string. If the string doesn't have\n * the prefix, it is returned as-is.\n *\n * @param hexadecimal - The hexadecimal string to remove the prefix from.\n * @returns The un-prefixed hexadecimal string.\n */\nexport function remove0x(hexadecimal: string): string {\n  if (hexadecimal.startsWith('0x') || hexadecimal.startsWith('0X')) {\n    return hexadecimal.substring(2);\n  }\n\n  return hexadecimal;\n}\n","import { base64 } from '@scure/base';\n\nimport { assert } from './assert';\nimport type { Hex } from './hex';\nimport { add0x, assertIsHexString, remove0x } from './hex';\n\n// '0'.charCodeAt(0) === 48\nconst HEX_MINIMUM_NUMBER_CHARACTER = 48;\n\n// '9'.charCodeAt(0) === 57\nconst HEX_MAXIMUM_NUMBER_CHARACTER = 58;\nconst HEX_CHARACTER_OFFSET = 87;\n\nexport type Bytes = bigint | number | string | Uint8Array;\n\n/**\n * Memoized function that returns an array to be used as a lookup table for\n * converting bytes to hexadecimal values.\n *\n * The array is created lazily and then cached for future use. The benefit of\n * this approach is that the performance of converting bytes to hex is much\n * better than if we were to call `toString(16)` on each byte.\n *\n * The downside is that the array is created once and then never garbage\n * collected. This is not a problem in practice because the array is only 256\n * elements long.\n *\n * @returns A function that returns the lookup table.\n */\nfunction getPrecomputedHexValuesBuilder(): () => string[] {\n  // To avoid issues with tree shaking, we need to use a function to return the\n  // array. This is because the array is only used in the `bytesToHex` function\n  // and if we were to use a global variable, the array might be removed by the\n  // tree shaker.\n  const lookupTable: string[] = [];\n\n  return () => {\n    if (lookupTable.length === 0) {\n      for (let i = 0; i < 256; i++) {\n        lookupTable.push(i.toString(16).padStart(2, '0'));\n      }\n    }\n\n    return lookupTable;\n  };\n}\n\n/**\n * Function implementation of the {@link getPrecomputedHexValuesBuilder}\n * function.\n */\nconst getPrecomputedHexValues = getPrecomputedHexValuesBuilder();\n\n/**\n * Check if a value is a `Uint8Array`.\n *\n * @param value - The value to check.\n * @returns Whether the value is a `Uint8Array`.\n */\nexport function isBytes(value: unknown): value is Uint8Array {\n  return value instanceof Uint8Array;\n}\n\n/**\n * Assert that a value is a `Uint8Array`.\n *\n * @param value - The value to check.\n * @throws If the value is not a `Uint8Array`.\n */\nexport function assertIsBytes(value: unknown): asserts value is Uint8Array {\n  assert(isBytes(value), 'Value must be a Uint8Array.');\n}\n\n/**\n * Convert a `Uint8Array` to a hexadecimal string.\n *\n * @param bytes - The bytes to convert to a hexadecimal string.\n * @returns The hexadecimal string.\n */\nexport function bytesToHex(bytes: Uint8Array): Hex {\n  assertIsBytes(bytes);\n\n  if (bytes.length === 0) {\n    return '0x';\n  }\n\n  const lookupTable = getPrecomputedHexValues();\n  const hexadecimal = new Array(bytes.length);\n\n  for (let i = 0; i < bytes.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    hexadecimal[i] = lookupTable[bytes[i]!];\n  }\n\n  return add0x(hexadecimal.join(''));\n}\n\n/**\n * Convert a `Uint8Array` to a `bigint`.\n *\n * To convert a `Uint8Array` to a `number` instead, use {@link bytesToNumber}.\n * To convert a two's complement encoded `Uint8Array` to a `bigint`, use\n * {@link bytesToSignedBigInt}.\n *\n * @param bytes - The bytes to convert to a `bigint`.\n * @returns The `bigint`.\n */\nexport function bytesToBigInt(bytes: Uint8Array): bigint {\n  assertIsBytes(bytes);\n\n  const hexadecimal = bytesToHex(bytes);\n  return BigInt(hexadecimal);\n}\n\n/**\n * Convert a `Uint8Array` to a signed `bigint`. This assumes that the bytes are\n * encoded in two's complement.\n *\n * To convert a `Uint8Array` to an unsigned `bigint` instead, use\n * {@link bytesToBigInt}.\n *\n * @see https://en.wikipedia.org/wiki/Two%27s_complement\n * @param bytes - The bytes to convert to a signed `bigint`.\n * @returns The signed `bigint`.\n */\nexport function bytesToSignedBigInt(bytes: Uint8Array): bigint {\n  assertIsBytes(bytes);\n\n  let value = BigInt(0);\n  for (const byte of bytes) {\n    // eslint-disable-next-line no-bitwise\n    value = (value << BigInt(8)) + BigInt(byte);\n  }\n\n  return BigInt.asIntN(bytes.length * 8, value);\n}\n\n/**\n * Convert a `Uint8Array` to a `number`.\n *\n * To convert a `Uint8Array` to a `bigint` instead, use {@link bytesToBigInt}.\n *\n * @param bytes - The bytes to convert to a number.\n * @returns The number.\n * @throws If the resulting number is not a safe integer.\n */\nexport function bytesToNumber(bytes: Uint8Array): number {\n  assertIsBytes(bytes);\n\n  const bigint = bytesToBigInt(bytes);\n\n  assert(\n    bigint <= BigInt(Number.MAX_SAFE_INTEGER),\n    'Number is not a safe integer. Use `bytesToBigInt` instead.',\n  );\n\n  return Number(bigint);\n}\n\n/**\n * Convert a UTF-8 encoded `Uint8Array` to a `string`.\n *\n * @param bytes - The bytes to convert to a string.\n * @returns The string.\n */\nexport function bytesToString(bytes: Uint8Array): string {\n  assertIsBytes(bytes);\n\n  return new TextDecoder().decode(bytes);\n}\n\n/**\n * Convert a `Uint8Array` to a base64 encoded string.\n *\n * @param bytes - The bytes to convert to a base64 encoded string.\n * @returns The base64 encoded string.\n */\nexport function bytesToBase64(bytes: Uint8Array): string {\n  assertIsBytes(bytes);\n\n  return base64.encode(bytes);\n}\n\n/**\n * Convert a hexadecimal string to a `Uint8Array`. The string can optionally be\n * prefixed with `0x`. It accepts even and odd length strings.\n *\n * If the value is \"0x\", an empty `Uint8Array` is returned.\n *\n * @param value - The hexadecimal string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function hexToBytes(value: string): Uint8Array {\n  // \"0x\" is often used as empty byte array.\n  if (value?.toLowerCase?.() === '0x') {\n    return new Uint8Array();\n  }\n\n  assertIsHexString(value);\n\n  // Remove the `0x` prefix if it exists, and pad the string to have an even\n  // number of characters.\n  const strippedValue = remove0x(value).toLowerCase();\n  const normalizedValue =\n    strippedValue.length % 2 === 0 ? strippedValue : `0${strippedValue}`;\n  const bytes = new Uint8Array(normalizedValue.length / 2);\n\n  for (let i = 0; i < bytes.length; i++) {\n    // While this is not the prettiest way to convert a hexadecimal string to a\n    // `Uint8Array`, it is a lot faster than using `parseInt` to convert each\n    // character.\n    const c1 = normalizedValue.charCodeAt(i * 2);\n    const c2 = normalizedValue.charCodeAt(i * 2 + 1);\n    const n1 =\n      c1 -\n      (c1 < HEX_MAXIMUM_NUMBER_CHARACTER\n        ? HEX_MINIMUM_NUMBER_CHARACTER\n        : HEX_CHARACTER_OFFSET);\n    const n2 =\n      c2 -\n      (c2 < HEX_MAXIMUM_NUMBER_CHARACTER\n        ? HEX_MINIMUM_NUMBER_CHARACTER\n        : HEX_CHARACTER_OFFSET);\n\n    bytes[i] = n1 * 16 + n2;\n  }\n\n  return bytes;\n}\n\n/**\n * Convert a `bigint` to a `Uint8Array`.\n *\n * This assumes that the `bigint` is an unsigned integer. To convert a signed\n * `bigint` instead, use {@link signedBigIntToBytes}.\n *\n * @param value - The bigint to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function bigIntToBytes(value: bigint): Uint8Array {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(value >= BigInt(0), 'Value must be a non-negative bigint.');\n\n  const hexadecimal = value.toString(16);\n  return hexToBytes(hexadecimal);\n}\n\n/**\n * Check if a `bigint` fits in a certain number of bytes.\n *\n * @param value - The `bigint` to check.\n * @param bytes - The number of bytes.\n * @returns Whether the `bigint` fits in the number of bytes.\n */\nfunction bigIntFits(value: bigint, bytes: number): boolean {\n  assert(bytes > 0);\n\n  /* eslint-disable no-bitwise */\n  const mask = value >> BigInt(31);\n  return !(((~value & mask) + (value & ~mask)) >> BigInt(bytes * 8 + ~0));\n  /* eslint-enable no-bitwise */\n}\n\n/**\n * Convert a signed `bigint` to a `Uint8Array`. This uses two's complement\n * encoding to represent negative numbers.\n *\n * To convert an unsigned `bigint` to a `Uint8Array` instead, use\n * {@link bigIntToBytes}.\n *\n * @see https://en.wikipedia.org/wiki/Two%27s_complement\n * @param value - The number to convert to bytes.\n * @param byteLength - The length of the resulting `Uint8Array`. If the number\n * is larger than the maximum value that can be represented by the given length,\n * an error is thrown.\n * @returns The bytes as `Uint8Array`.\n */\nexport function signedBigIntToBytes(\n  value: bigint,\n  byteLength: number,\n): Uint8Array {\n  assert(typeof value === 'bigint', 'Value must be a bigint.');\n  assert(typeof byteLength === 'number', 'Byte length must be a number.');\n  assert(byteLength > 0, 'Byte length must be greater than 0.');\n  assert(\n    bigIntFits(value, byteLength),\n    'Byte length is too small to represent the given value.',\n  );\n\n  // ESLint doesn't like mutating function parameters, so to avoid having to\n  // disable the rule, we create a new variable.\n  let numberValue = value;\n  const bytes = new Uint8Array(byteLength);\n\n  for (let i = 0; i < bytes.length; i++) {\n    bytes[i] = Number(BigInt.asUintN(8, numberValue));\n    // eslint-disable-next-line no-bitwise\n    numberValue >>= BigInt(8);\n  }\n\n  return bytes.reverse();\n}\n\n/**\n * Convert a `number` to a `Uint8Array`.\n *\n * @param value - The number to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n * @throws If the number is not a safe integer.\n */\nexport function numberToBytes(value: number): Uint8Array {\n  assert(typeof value === 'number', 'Value must be a number.');\n  assert(value >= 0, 'Value must be a non-negative number.');\n  assert(\n    Number.isSafeInteger(value),\n    'Value is not a safe integer. Use `bigIntToBytes` instead.',\n  );\n\n  const hexadecimal = value.toString(16);\n  return hexToBytes(hexadecimal);\n}\n\n/**\n * Convert a `string` to a UTF-8 encoded `Uint8Array`.\n *\n * @param value - The string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function stringToBytes(value: string): Uint8Array {\n  assert(typeof value === 'string', 'Value must be a string.');\n\n  return new TextEncoder().encode(value);\n}\n\n/**\n * Convert a base64 encoded string to a `Uint8Array`.\n *\n * @param value - The base64 encoded string to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function base64ToBytes(value: string): Uint8Array {\n  assert(typeof value === 'string', 'Value must be a string.');\n\n  return base64.decode(value);\n}\n\n/**\n * Convert a byte-like value to a `Uint8Array`. The value can be a `Uint8Array`,\n * a `bigint`, a `number`, or a `string`.\n *\n * This will attempt to guess the type of the value based on its type and\n * contents. For more control over the conversion, use the more specific\n * conversion functions, such as {@link hexToBytes} or {@link stringToBytes}.\n *\n * If the value is a `string`, and it is prefixed with `0x`, it will be\n * interpreted as a hexadecimal string. Otherwise, it will be interpreted as a\n * UTF-8 string. To convert a hexadecimal string to bytes without interpreting\n * it as a UTF-8 string, use {@link hexToBytes} instead.\n *\n * If the value is a `bigint`, it is assumed to be unsigned. To convert a signed\n * `bigint` to bytes, use {@link signedBigIntToBytes} instead.\n *\n * If the value is a `Uint8Array`, it will be returned as-is.\n *\n * @param value - The value to convert to bytes.\n * @returns The bytes as `Uint8Array`.\n */\nexport function valueToBytes(value: Bytes): Uint8Array {\n  if (typeof value === 'bigint') {\n    return bigIntToBytes(value);\n  }\n\n  if (typeof value === 'number') {\n    return numberToBytes(value);\n  }\n\n  if (typeof value === 'string') {\n    if (value.startsWith('0x')) {\n      return hexToBytes(value);\n    }\n\n    return stringToBytes(value);\n  }\n\n  if (isBytes(value)) {\n    return value;\n  }\n\n  throw new TypeError(`Unsupported value type: \"${typeof value}\".`);\n}\n\n/**\n * Concatenate multiple byte-like values into a single `Uint8Array`. The values\n * can be `Uint8Array`, `bigint`, `number`, or `string`. This uses\n * {@link valueToBytes} under the hood to convert each value to bytes. Refer to\n * the documentation of that function for more information.\n *\n * @param values - The values to concatenate.\n * @returns The concatenated bytes as `Uint8Array`.\n */\nexport function concatBytes(values: Bytes[]): Uint8Array {\n  const normalizedValues = new Array(values.length);\n  let byteLength = 0;\n\n  for (let i = 0; i < values.length; i++) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const value = valueToBytes(values[i]!);\n\n    normalizedValues[i] = value;\n    byteLength += value.length;\n  }\n\n  const bytes = new Uint8Array(byteLength);\n  for (let i = 0, offset = 0; i < normalizedValues.length; i++) {\n    // While we could simply spread the values into an array and use\n    // `Uint8Array.from`, that is a lot slower than using `Uint8Array.set`.\n    bytes.set(normalizedValues[i], offset);\n    offset += normalizedValues[i].length;\n  }\n\n  return bytes;\n}\n\n/**\n * Create a {@link DataView} from a {@link Uint8Array}. This is a convenience\n * function that avoids having to create a {@link DataView} manually, which\n * requires passing the `byteOffset` and `byteLength` parameters every time.\n *\n * Not passing the `byteOffset` and `byteLength` parameters can result in\n * unexpected behavior when the {@link Uint8Array} is a view of a larger\n * {@link ArrayBuffer}, e.g., when using {@link Uint8Array.subarray}.\n *\n * This function also supports Node.js {@link Buffer}s.\n *\n * @example\n * ```typescript\n * const bytes = new Uint8Array([1, 2, 3]);\n *\n * // This is equivalent to:\n * // const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n * const dataView = createDataView(bytes);\n * ```\n * @param bytes - The bytes to create the {@link DataView} from.\n * @returns The {@link DataView}.\n */\nexport function createDataView(bytes: Uint8Array): DataView {\n  // To maintain compatibility with Node.js, we need to check if the bytes are\n  // a Buffer. If so, we need to slice the buffer to get the underlying\n  // ArrayBuffer.\n  // eslint-disable-next-line no-restricted-globals\n  if (typeof Buffer !== 'undefined' && bytes instanceof Buffer) {\n    const buffer = bytes.buffer.slice(\n      bytes.byteOffset,\n      bytes.byteOffset + bytes.byteLength,\n    );\n\n    return new DataView(buffer);\n  }\n\n  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n}\n"]}