@xylabs/hex 4.13.23 → 4.14.1

package/dist/neutral/HexRegExMinMax.d.ts

@@ -0,0 +1,2 @@
+export declare const HexRegExMinMax: (minBytes?: number, maxBytes?: number) => RegExp;
+//# sourceMappingURL=HexRegExMinMax.d.ts.map

package/dist/neutral/HexRegExMinMax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HexRegExMinMax.d.ts","sourceRoot":"","sources":["../../src/HexRegExMinMax.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,iBAAY,EAAE,WAAU,MAAsC,WAE5F,CAAA"}

package/dist/neutral/address.d.ts

@@ -1,9 +1,16 @@
+import z from 'zod';
 import type { AssertConfig } from './assert.ts';
 import type { Hex, HexConfig } from './hex/index.ts';
-export type Address = Exclude<Hex, 'reserved-address-value'>;
+export declare const AddressRegEx: RegExp;
+export declare const AddressToStringSchema: z.ZodString;
+export declare const AddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
+export type Address = Hex & {
+    readonly __address: unique symbol;
+};
 export declare const ZERO_ADDRESS: Address;
-export declare const toAddress: (value: string | number | bigint | ArrayBufferLike, config?: HexConfig) => Lowercase<string>;
+export declare const toAddress: (value: string | number | bigint | ArrayBufferLike, config?: HexConfig) => Address;
 export declare const isAddress: (value: unknown, config?: HexConfig) => value is Address;
+export declare const AddressZod: z.ZodString;
 export declare function asAddress(value: unknown): Address | undefined;
 export declare function asAddress(value: unknown, assert: AssertConfig): Address;
 //# sourceMappingURL=address.d.ts.map

package/dist/neutral/address.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/address.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAKpD,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,wBAAwB,CAAC,CAAA;AAE5D,eAAO,MAAM,YAAY,EAAE,OAA6D,CAAA;AAExF,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,sBAKlG,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,OAG3E,CAAA;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAA;AAC9D,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAA"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src/address.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAMpD,eAAO,MAAM,YAAY,QAAyB,CAAA;AAElD,eAAO,MAAM,qBAAqB,aAA+C,CAAA;AACjF,eAAO,MAAM,uBAAuB,yDAA4E,CAAA;AAEhH,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AAEjE,eAAO,MAAM,YAAY,EAAiD,OAAO,CAAA;AAEjF,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,OAKrG,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,OAG3E,CAAA;AAED,eAAO,MAAM,UAAU,aAKpB,CAAA;AAEH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAAA;AAC9D,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAA"}

package/dist/neutral/hash.d.ts

@@ -1,11 +1,16 @@
+import z from 'zod';
 import type { AssertConfig } from './assert.ts';
 import type { Hex } from './hex/index.ts';
+export declare const HashRegEx: RegExp;
 export declare const ZERO_HASH: Hash;
 export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;
 export declare const HashBitLength: HashBitLength[];
 export declare const isHashBitLength: (value: unknown) => value is HashBitLength;
-export type Hash = Exclude<Hex, 'reserved-hash-value'>;
+export type Hash = Hex & {
+    readonly __hash: unique symbol;
+};
 export declare const isHash: (value: unknown, bitLength?: HashBitLength) => value is Hash;
+export declare const HashZod: z.ZodString;
 export declare function asHash(value: unknown): Hash | undefined;
 export declare function asHash(value: unknown, assert: AssertConfig): Hash;
 //# sourceMappingURL=hash.d.ts.map

package/dist/neutral/hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAGzC,eAAO,MAAM,SAAS,EAAE,IAAkF,CAAA;AAE1G,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC1E,eAAO,MAAM,aAAa,EAAE,aAAa,EAA8C,CAAA;AAEvF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,EAAE,qBAAqB,CAAC,CAAA;AACtD,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAW,aAAmB,KAAG,KAAK,IAAI,IAEhF,CAAA;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;AACxD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AAIzC,eAAO,MAAM,SAAS,QAAyB,CAAA;AAE/C,eAAO,MAAM,SAAS,EAAyE,IAAI,CAAA;AAEnG,MAAM,MAAM,aAAa,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAC1E,eAAO,MAAM,aAAa,EAAE,aAAa,EAA8C,CAAA;AAEvF,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAEzD,CAAA;AAED,MAAM,MAAM,IAAI,GAAG,GAAG,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AAC3D,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAW,aAAmB,KAAG,KAAK,IAAI,IAEhF,CAAA;AAED,eAAO,MAAM,OAAO,aAKjB,CAAA;AAEH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;AACxD,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA"}

package/dist/neutral/hex/model.d.ts

@@ -1,4 +1,9 @@
-export type Hex = Exclude<Lowercase<string>, 'reserved-hex-value'>;
+import z from 'zod';
+export type Hex = Lowercase<string> & {
+    readonly __hex: unique symbol;
+};
+export declare const HexRegEx: RegExp;
+export declare const HexZod: z.ZodString;
 /** Configuration of validation and output format */
 export interface HexConfig {
     bitLength?: number;

package/dist/neutral/hex/model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/hex/model.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,oBAAoB,CAAC,CAAA;AAElE,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/hex/model.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,MAAM,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,MAAM,CAAA;CAAE,CAAA;AAEvE,eAAO,MAAM,QAAQ,QAA6C,CAAA;AAElE,eAAO,MAAM,MAAM,aAKhB,CAAA;AAEH,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB"}

package/dist/neutral/hex/to.d.ts

@@ -4,5 +4,5 @@ export declare const toHex: (
 /** Supported types are string, number, bigint, and ArrayBuffer */
 value: string | number | bigint | ArrayBufferLike, 
 /** Configuration of output format and validation */
-config?: HexConfig) => Lowercase<string>;
+config?: HexConfig) => import("./model.ts").Hex;
 //# sourceMappingURL=to.d.ts.map

package/dist/neutral/hex/to.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/hex/to.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,uEAAuE;AACvE,eAAO,MAAM,KAAK;AAChB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAQ,SAAc,sBAIvB,CAAA"}
+{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/hex/to.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE3C,uEAAuE;AACvE,eAAO,MAAM,KAAK;AAChB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAQ,SAAc,6BAIvB,CAAA"}

package/dist/neutral/index.mjs

@@ -1,5 +1,6 @@
 // src/address.ts
 import { isObject } from "@xylabs/typeof";
+import z2 from "zod";
 
 // src/assert.ts
 import { isString, isUndefined } from "@xylabs/typeof";
@@ -120,6 +121,20 @@ var toHexLegacy = (buffer) => {
   return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
 };
 
+// src/hex/model.ts
+import z from "zod";
+
+// src/HexRegExMinMax.ts
+var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+
+// src/hex/model.ts
+var HexRegEx = HexRegExMinMax(1, Number.MAX_SAFE_INTEGER);
+var HexZod = z.string().toLowerCase().regex(HexRegEx, { message: "Invalid hex format" }).refine(
+  isHex
+);
+
 // src/hex/to.ts
 var toHex = (value, config = {}) => {
   const { prefix = false } = config;
@@ -127,6 +142,9 @@ var toHex = (value, config = {}) => {
 };
 
 // src/address.ts
+var AddressRegEx = HexRegExMinMax(20, 20);
+var AddressToStringSchema = z2.string().toLowerCase().regex(AddressRegEx);
+var AddressFromStringSchema = z2.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
 var toAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = false } = config;
@@ -140,6 +158,9 @@ var isAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = false } = config;
   return isHex(value, { bitLength, prefix });
 };
+var AddressZod = z2.string().toLowerCase().regex(AddressRegEx, { message: "Invalid address format" }).refine(
+  isAddress
+);
 function asAddress(value, assert) {
   try {
     let stringValue = void 0;
@@ -161,6 +182,8 @@ function asAddress(value, assert) {
 
 // src/hash.ts
 import { isUndefined as isUndefined2 } from "@xylabs/typeof";
+import z3 from "zod";
+var HashRegEx = HexRegExMinMax(32, 32);
 var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
 var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
 var isHashBitLength = (value) => {
@@ -169,6 +192,9 @@ var isHashBitLength = (value) => {
 var isHash = (value, bitLength = 256) => {
   return isHex(value, { bitLength });
 };
+var HashZod = z3.string().toLowerCase().regex(HashRegEx, { message: "Invalid hash format" }).refine(
+  isHash
+);
 function asHash(value, assert) {
   let stringValue = void 0;
   switch (typeof value) {
@@ -188,7 +214,15 @@ function hexToBigInt(hex) {
   return BigInt(hexFromHexString(hex, { prefix: true }));
 }
 export {
+  AddressFromStringSchema,
+  AddressRegEx,
+  AddressToStringSchema,
+  AddressZod,
   HashBitLength,
+  HashRegEx,
+  HashZod,
+  HexRegEx,
+  HexZod,
   ZERO_ADDRESS,
   ZERO_HASH,
   asAddress,

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/address.ts","../../src/assert.ts","../../src/hex/from/fromHexString.ts","../../src/hex/nibble.ts","../../src/hex/regex.ts","../../src/hex/is.ts","../../src/hex/from/fromArrayBuffer.ts","../../src/hex/from/fromBigInt.ts","../../src/hex/from/fromNumber.ts","../../src/hex/from/from.ts","../../src/hex/as.ts","../../src/hex/isHexZero.ts","../../src/hex/legacy.ts","../../src/hex/to.ts","../../src/hash.ts","../../src/hexToBigInt.ts"],"sourcesContent":["import { isObject } from '@xylabs/typeof'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { Hex, HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\n\nexport type Address = Exclude<Hex, 'reserved-address-value'>\n\nexport const ZERO_ADDRESS: Address = '0000000000000000000000000000000000000000' as const\n\nexport const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}) => {\n  const { bitLength = 160, prefix = false } = config\n  return hexFrom(value, {\n    bitLength, prefix, ...config,\n  })\n}\n\nexport const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {\n  const { bitLength = 160, prefix = false } = config\n  return isHex(value, { bitLength, prefix })\n}\n\nexport function asAddress(value: unknown): Address | undefined\nexport function asAddress(value: unknown, assert: AssertConfig): Address\nexport function asAddress(value: unknown, assert?: AssertConfig): Address | undefined {\n  try {\n    let stringValue: string | undefined = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: false })\n        break\n      }\n      default: {\n        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : undefined\n      }\n    }\n    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n","import { isString, isUndefined } from '@xylabs/typeof'\n\ntype AssertCallback = (value: unknown, message: string) => string | boolean\n\nexport type AssertConfig = string | AssertCallback | boolean\n\nexport const assertError = (value: unknown, assert: AssertConfig | undefined, defaultMessage: string) => {\n  if (!isUndefined(assert)) {\n    const assertString\n      = typeof assert === 'string'\n        ? assert\n        : typeof assert === 'boolean'\n          ? defaultMessage\n          : assert(value, defaultMessage)\n    if (isString(assertString) || assertString === true) {\n      throw new Error(assertString === true ? defaultMessage : assertString)\n    }\n  }\n  // eslint-disable-next-line unicorn/no-useless-undefined\n  return undefined\n}\n","import { isNumber } from '@xylabs/typeof'\n\nimport { isHex } from '../is.ts'\nimport type { Hex, HexConfig } from '../model.ts'\nimport { bitsToNibbles } from '../nibble.ts'\n\nexport const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {\n  const {\n    prefix = false, byteSize = 8, bitLength,\n  } = config\n  const nibbleBoundary = bitsToNibbles(byteSize)\n  const unEvened = (value.startsWith('0x') ? value.slice(2) : value).toLowerCase()\n  if (isHex(unEvened)) {\n    const evenCharacters = unEvened.padStart(unEvened.length + (unEvened.length % nibbleBoundary), '0')\n    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, '0') : evenCharacters\n    return (prefix ? `0x${padded}` : padded).toLowerCase() as Hex\n  } else {\n    throw new Error('Received string is not a value hex')\n  }\n}\n","// determine the number of nibbles for a given number of bits\nexport const bitsToNibbles = (value: number): number => {\n  const nibbles = value >> 2\n  if (value !== nibbles << 2) throw new Error('Bits for nibbles must multiple of 4')\n  return nibbles\n}\n\n// determine the number of nibbles for a given number of bits\nexport const nibblesToBits = (value: number): number => {\n  return value << 2\n}\n","export const hexRegex = /^[\\da-f]+$/i\nexport const hexRegexWithPrefix = /0x[\\da-f]+$/i\n","import type { Hex, HexConfig } from './model.ts'\nimport { bitsToNibbles } from './nibble.ts'\nimport { hexRegex, hexRegexWithPrefix } from './regex.ts'\n\nexport const isHex = (value: unknown, config?: HexConfig): value is Hex => {\n  // Is it a string?\n  if (typeof value !== 'string') return false\n\n  const valueCharLength = config?.prefix ? value.length - 2 : value.length\n\n  // If a bitLength specified, does it conform?\n  if (config?.bitLength !== undefined && valueCharLength !== bitsToNibbles(config?.bitLength)) return false\n\n  // Does it only has hex values?\n  return config?.prefix ? hexRegexWithPrefix.test(value) : hexRegex.test(value)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert an ArrayBuffer to a hex string */\nexport const hexFromArrayBuffer = (\n  /** The buffer to be converted */\n  buffer: ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  const unPadded = [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n  return hexFromHexString(unPadded, config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert a bigint to a hex string */\nexport const hexFromBigInt = (\n  /** The bigint to be converted */\n  value: bigint,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n): Hex => {\n  const unPadded = value.toString(16)\n  return hexFromHexString(unPadded, config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\n\nexport const hexFromNumber = (value: number, config?: HexConfig): Hex => {\n  return hexFromBigInt(BigInt(value), config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromArrayBuffer } from './fromArrayBuffer.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\nimport { hexFromHexString } from './fromHexString.ts'\nimport { hexFromNumber } from './fromNumber.ts'\n\n/** Takes unknown value and tries our best to convert it to a hex string */\nexport const hexFrom = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  switch (typeof value) {\n    case 'string': {\n      return hexFromHexString(value, config)\n    }\n    case 'bigint': {\n      return hexFromBigInt(value, config)\n    }\n    case 'number': {\n      return hexFromNumber(value, config)\n    }\n    case 'object': {\n      return hexFromArrayBuffer(value, config)\n    }\n    default: {\n      throw new Error(`Invalid type: ${typeof value}`)\n    }\n  }\n}\n","import type { AssertConfig } from '../assert.ts'\nimport { assertError } from '../assert.ts'\nimport { hexFromHexString } from './from/index.ts'\nimport { isHex } from './is.ts'\nimport type { Hex } from './model.ts'\n\nexport function asHex(value: unknown): Hex | undefined\nexport function asHex(value: unknown, assert: AssertConfig): Hex\nexport function asHex(value: unknown, assert?: AssertConfig): Hex | undefined {\n  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n\n  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`)\n}\n","import { isString } from '@xylabs/typeof'\n\nimport { hexFromHexString } from './from/index.ts'\n\nexport const isHexZero = (value?: string) => {\n  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : undefined\n}\n","export const toHexLegacy = (buffer: ArrayBuffer) => {\n  return [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n}\n","import { hexFrom } from './from/index.ts'\nimport type { HexConfig } from './model.ts'\n\n/** takes any value and tries our best to convert it to a hex string */\nexport const toHex = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n) => {\n  const { prefix = false } = config\n  return hexFrom(value, { prefix, ...config })\n}\n","import { isUndefined } from '@xylabs/typeof'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { Hex } from './hex/index.ts'\nimport { hexFromHexString, isHex } from './hex/index.ts'\n\nexport const ZERO_HASH: Hash = '0000000000000000000000000000000000000000000000000000000000000000' as const\n\nexport type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096\nexport const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n\nexport const isHashBitLength = (value: unknown): value is HashBitLength => {\n  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)\n}\n\nexport type Hash = Exclude<Hex, 'reserved-hash-value'>\nexport const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {\n  return isHex(value, { bitLength })\n}\n\nexport function asHash(value: unknown): Hash | undefined\nexport function asHash(value: unknown, assert: AssertConfig): Hash\nexport function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {\n  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)\n}\n","import { type Hex, hexFromHexString } from './hex/index.ts'\n\nexport function hexToBigInt(hex: Hex): bigint {\n  return BigInt(hexFromHexString(hex, { prefix: true }))\n}\n"],"mappings":"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","names":["isString","isString","isUndefined","isUndefined"]}
+{"version":3,"sources":["../../src/address.ts","../../src/assert.ts","../../src/hex/from/fromHexString.ts","../../src/hex/nibble.ts","../../src/hex/regex.ts","../../src/hex/is.ts","../../src/hex/from/fromArrayBuffer.ts","../../src/hex/from/fromBigInt.ts","../../src/hex/from/fromNumber.ts","../../src/hex/from/from.ts","../../src/hex/as.ts","../../src/hex/isHexZero.ts","../../src/hex/legacy.ts","../../src/hex/model.ts","../../src/HexRegExMinMax.ts","../../src/hex/to.ts","../../src/hash.ts","../../src/hexToBigInt.ts"],"sourcesContent":["import { isObject } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { Hex, HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMax } from './HexRegExMinMax.ts'\n\nexport const AddressRegEx = HexRegExMinMax(20, 20)\n\nexport const AddressToStringSchema = z.string().toLowerCase().regex(AddressRegEx)\nexport const AddressFromStringSchema = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\nexport type Address = Hex & { readonly __address: unique symbol }\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\n\nexport const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {\n  const { bitLength = 160, prefix = false } = config\n  return hexFrom(value, {\n    bitLength, prefix, ...config,\n  }) as Address\n}\n\nexport const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {\n  const { bitLength = 160, prefix = false } = config\n  return isHex(value, { bitLength, prefix })\n}\n\nexport const AddressZod = z.string()\n  .toLowerCase()\n  .regex(AddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isAddress,\n  )\n\nexport function asAddress(value: unknown): Address | undefined\nexport function asAddress(value: unknown, assert: AssertConfig): Address\nexport function asAddress(value: unknown, assert?: AssertConfig): Address | undefined {\n  try {\n    let stringValue: string | undefined = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: false })\n        break\n      }\n      default: {\n        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : undefined\n      }\n    }\n    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n","import { isString, isUndefined } from '@xylabs/typeof'\n\ntype AssertCallback = (value: unknown, message: string) => string | boolean\n\nexport type AssertConfig = string | AssertCallback | boolean\n\nexport const assertError = (value: unknown, assert: AssertConfig | undefined, defaultMessage: string) => {\n  if (!isUndefined(assert)) {\n    const assertString\n      = typeof assert === 'string'\n        ? assert\n        : typeof assert === 'boolean'\n          ? defaultMessage\n          : assert(value, defaultMessage)\n    if (isString(assertString) || assertString === true) {\n      throw new Error(assertString === true ? defaultMessage : assertString)\n    }\n  }\n  // eslint-disable-next-line unicorn/no-useless-undefined\n  return undefined\n}\n","import { isNumber } from '@xylabs/typeof'\n\nimport { isHex } from '../is.ts'\nimport type { Hex, HexConfig } from '../model.ts'\nimport { bitsToNibbles } from '../nibble.ts'\n\nexport const hexFromHexString = (value: string, config: HexConfig = {}): Hex => {\n  const {\n    prefix = false, byteSize = 8, bitLength,\n  } = config\n  const nibbleBoundary = bitsToNibbles(byteSize)\n  const unEvened = (value.startsWith('0x') ? value.slice(2) : value).toLowerCase()\n  if (isHex(unEvened)) {\n    const evenCharacters = unEvened.padStart(unEvened.length + (unEvened.length % nibbleBoundary), '0')\n    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, '0') : evenCharacters\n    return (prefix ? `0x${padded}` : padded).toLowerCase() as Hex\n  } else {\n    throw new Error('Received string is not a value hex')\n  }\n}\n","// determine the number of nibbles for a given number of bits\nexport const bitsToNibbles = (value: number): number => {\n  const nibbles = value >> 2\n  if (value !== nibbles << 2) throw new Error('Bits for nibbles must multiple of 4')\n  return nibbles\n}\n\n// determine the number of nibbles for a given number of bits\nexport const nibblesToBits = (value: number): number => {\n  return value << 2\n}\n","export const hexRegex = /^[\\da-f]+$/i\nexport const hexRegexWithPrefix = /0x[\\da-f]+$/i\n","import type { Hex, HexConfig } from './model.ts'\nimport { bitsToNibbles } from './nibble.ts'\nimport { hexRegex, hexRegexWithPrefix } from './regex.ts'\n\nexport const isHex = (value: unknown, config?: HexConfig): value is Hex => {\n  // Is it a string?\n  if (typeof value !== 'string') return false\n\n  const valueCharLength = config?.prefix ? value.length - 2 : value.length\n\n  // If a bitLength specified, does it conform?\n  if (config?.bitLength !== undefined && valueCharLength !== bitsToNibbles(config?.bitLength)) return false\n\n  // Does it only has hex values?\n  return config?.prefix ? hexRegexWithPrefix.test(value) : hexRegex.test(value)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert an ArrayBuffer to a hex string */\nexport const hexFromArrayBuffer = (\n  /** The buffer to be converted */\n  buffer: ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  const unPadded = [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n  return hexFromHexString(unPadded, config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromHexString } from './fromHexString.ts'\n\n/** Convert a bigint to a hex string */\nexport const hexFromBigInt = (\n  /** The bigint to be converted */\n  value: bigint,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n): Hex => {\n  const unPadded = value.toString(16)\n  return hexFromHexString(unPadded, config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\n\nexport const hexFromNumber = (value: number, config?: HexConfig): Hex => {\n  return hexFromBigInt(BigInt(value), config)\n}\n","import type { Hex, HexConfig } from '../model.ts'\nimport { hexFromArrayBuffer } from './fromArrayBuffer.ts'\nimport { hexFromBigInt } from './fromBigInt.ts'\nimport { hexFromHexString } from './fromHexString.ts'\nimport { hexFromNumber } from './fromNumber.ts'\n\n/** Takes unknown value and tries our best to convert it to a hex string */\nexport const hexFrom = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config?: HexConfig,\n): Hex => {\n  switch (typeof value) {\n    case 'string': {\n      return hexFromHexString(value, config)\n    }\n    case 'bigint': {\n      return hexFromBigInt(value, config)\n    }\n    case 'number': {\n      return hexFromNumber(value, config)\n    }\n    case 'object': {\n      return hexFromArrayBuffer(value, config)\n    }\n    default: {\n      throw new Error(`Invalid type: ${typeof value}`)\n    }\n  }\n}\n","import type { AssertConfig } from '../assert.ts'\nimport { assertError } from '../assert.ts'\nimport { hexFromHexString } from './from/index.ts'\nimport { isHex } from './is.ts'\nimport type { Hex } from './model.ts'\n\nexport function asHex(value: unknown): Hex | undefined\nexport function asHex(value: unknown, assert: AssertConfig): Hex\nexport function asHex(value: unknown, assert?: AssertConfig): Hex | undefined {\n  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n\n  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`)\n}\n","import { isString } from '@xylabs/typeof'\n\nimport { hexFromHexString } from './from/index.ts'\n\nexport const isHexZero = (value?: string) => {\n  return isString(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : undefined\n}\n","export const toHexLegacy = (buffer: ArrayBuffer) => {\n  return [...new Uint8Array(buffer)].map(x => x.toString(16).padStart(2, '0')).join('')\n}\n","import z from 'zod'\n\nimport { HexRegExMinMax } from '../HexRegExMinMax.ts'\nimport { isHex } from './is.ts'\n\n// we use Exclude to intentionally make the type not equal to string\nexport type Hex = Lowercase<string> & { readonly __hex: unique symbol }\n\nexport const HexRegEx = HexRegExMinMax(1, Number.MAX_SAFE_INTEGER)\n\nexport const HexZod = z.string()\n  .toLowerCase()\n  .regex(HexRegEx, { message: 'Invalid hex format' })\n  .refine(\n    isHex,\n  )\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n","export const HexRegExMinMax = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n","import { hexFrom } from './from/index.ts'\nimport type { HexConfig } from './model.ts'\n\n/** takes any value and tries our best to convert it to a hex string */\nexport const toHex = (\n  /** Supported types are string, number, bigint, and ArrayBuffer */\n  value: string | number | bigint | ArrayBufferLike,\n  /** Configuration of output format and validation */\n  config: HexConfig = {},\n) => {\n  const { prefix = false } = config\n  return hexFrom(value, { prefix, ...config })\n}\n","import { isUndefined } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { Hex } from './hex/index.ts'\nimport { hexFromHexString, isHex } from './hex/index.ts'\nimport { HexRegExMinMax } from './HexRegExMinMax.ts'\n\nexport const HashRegEx = HexRegExMinMax(32, 32)\n\nexport const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash\n\nexport type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096\nexport const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]\n\nexport const isHashBitLength = (value: unknown): value is HashBitLength => {\n  return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)\n}\n\nexport type Hash = Hex & { readonly __hash: unique symbol }\nexport const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {\n  return isHex(value, { bitLength })\n}\n\nexport const HashZod = z.string()\n  .toLowerCase()\n  .regex(HashRegEx, { message: 'Invalid hash format' })\n  .refine(\n    isHash,\n  )\n\nexport function asHash(value: unknown): Hash | undefined\nexport function asHash(value: unknown, assert: AssertConfig): Hash\nexport function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {\n  let stringValue: string | undefined = undefined\n\n  switch (typeof value) {\n    case 'string': {\n      stringValue = hexFromHexString(value)\n      break\n    }\n    default: {\n      return isUndefined(assert) ? undefined : assertError(value, assert, `Unsupported type [${typeof value}]`)\n    }\n  }\n  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`)\n}\n","import { type Hex, hexFromHexString } from './hex/index.ts'\n\nexport function hexToBigInt(hex: Hex): bigint {\n  return BigInt(hexFromHexString(hex, { prefix: true }))\n}\n"],"mappings":"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","names":["z","isString","isString","z","isUndefined","z","z","isUndefined"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/hex",
-  "version": "4.13.23",
+  "version": "4.14.1",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "hex",
@@ -42,14 +42,16 @@
     "src"
   ],
   "dependencies": {
-    "@xylabs/typeof": "^4.13.23"
+    "@xylabs/typeof": "~4.14.1",
+    "zod": "~4.0.9",
+    "zod-to-json-schema": "~3.24.6"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^7.0.0",
-    "@xylabs/tsconfig": "^7.0.0",
-    "@xylabs/vitest-extended": "^4.13.23",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.4"
+    "@xylabs/ts-scripts-yarn3": "~7.0.1",
+    "@xylabs/tsconfig": "~7.0.1",
+    "@xylabs/vitest-extended": "~4.14.1",
+    "typescript": "~5.8.3",
+    "vitest": "~3.2.4"
   },
   "engines": {
     "node": ">=18"

package/src/HexRegExMinMax.ts

@@ -0,0 +1,3 @@
+export const HexRegExMinMax = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`)
+}

package/src/address.ts

@@ -1,4 +1,5 @@
 import { isObject } from '@xylabs/typeof'
+import z from 'zod'
 
 import type { AssertConfig } from './assert.ts'
 import { assertError } from './assert.ts'
@@ -6,16 +7,22 @@ import type { Hex, HexConfig } from './hex/index.ts'
 import {
   hexFrom, hexFromHexString, isHex,
 } from './hex/index.ts'
+import { HexRegExMinMax } from './HexRegExMinMax.ts'
 
-export type Address = Exclude<Hex, 'reserved-address-value'>
+export const AddressRegEx = HexRegExMinMax(20, 20)
 
-export const ZERO_ADDRESS: Address = '0000000000000000000000000000000000000000' as const
+export const AddressToStringSchema = z.string().toLowerCase().regex(AddressRegEx)
+export const AddressFromStringSchema = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))
 
-export const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}) => {
+export type Address = Hex & { readonly __address: unique symbol }
+
+export const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address
+
+export const toAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): Address => {
   const { bitLength = 160, prefix = false } = config
   return hexFrom(value, {
     bitLength, prefix, ...config,
-  })
+  }) as Address
 }
 
 export const isAddress = (value: unknown, config: HexConfig = {}): value is Address => {
@@ -23,6 +30,13 @@ export const isAddress = (value: unknown, config: HexConfig = {}): value is Addr
   return isHex(value, { bitLength, prefix })
 }
 
+export const AddressZod = z.string()
+  .toLowerCase()
+  .regex(AddressRegEx, { message: 'Invalid address format' })
+  .refine(
+    isAddress,
+  )
+
 export function asAddress(value: unknown): Address | undefined
 export function asAddress(value: unknown, assert: AssertConfig): Address
 export function asAddress(value: unknown, assert?: AssertConfig): Address | undefined {

package/src/hash.ts

@@ -1,11 +1,15 @@
 import { isUndefined } from '@xylabs/typeof'
+import z from 'zod'
 
 import type { AssertConfig } from './assert.ts'
 import { assertError } from './assert.ts'
 import type { Hex } from './hex/index.ts'
 import { hexFromHexString, isHex } from './hex/index.ts'
+import { HexRegExMinMax } from './HexRegExMinMax.ts'
 
-export const ZERO_HASH: Hash = '0000000000000000000000000000000000000000000000000000000000000000' as const
+export const HashRegEx = HexRegExMinMax(32, 32)
+
+export const ZERO_HASH = '0000000000000000000000000000000000000000000000000000000000000000' as Hash
 
 export type HashBitLength = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096
 export const HashBitLength: HashBitLength[] = [32, 64, 128, 256, 512, 1024, 2048, 4096]
@@ -14,11 +18,18 @@ export const isHashBitLength = (value: unknown): value is HashBitLength => {
   return typeof value === 'number' && HashBitLength.includes(value as HashBitLength)
 }
 
-export type Hash = Exclude<Hex, 'reserved-hash-value'>
+export type Hash = Hex & { readonly __hash: unique symbol }
 export const isHash = (value: unknown, bitLength: HashBitLength = 256): value is Hash => {
   return isHex(value, { bitLength })
 }
 
+export const HashZod = z.string()
+  .toLowerCase()
+  .regex(HashRegEx, { message: 'Invalid hash format' })
+  .refine(
+    isHash,
+  )
+
 export function asHash(value: unknown): Hash | undefined
 export function asHash(value: unknown, assert: AssertConfig): Hash
 export function asHash(value: unknown, assert?: AssertConfig): Hash | undefined {

package/src/hex/model.ts

@@ -1,5 +1,19 @@
+import z from 'zod'
+
+import { HexRegExMinMax } from '../HexRegExMinMax.ts'
+import { isHex } from './is.ts'
+
 // we use Exclude to intentionally make the type not equal to string
-export type Hex = Exclude<Lowercase<string>, 'reserved-hex-value'>
+export type Hex = Lowercase<string> & { readonly __hex: unique symbol }
+
+export const HexRegEx = HexRegExMinMax(1, Number.MAX_SAFE_INTEGER)
+
+export const HexZod = z.string()
+  .toLowerCase()
+  .regex(HexRegEx, { message: 'Invalid hex format' })
+  .refine(
+    isHex,
+  )
 
 /** Configuration of validation and output format */
 export interface HexConfig {