@xylabs/hex 5.0.5 → 5.0.6

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

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const AddressTransformZod: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBigInt, z.ZodNumber]>, z.ZodTransform<string, string | number | bigint>>, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, {
+    readonly __address: true;
+}>, string>>;
+export type AddressTransformZodType = z.infer<typeof AddressTransformZod>;
+//# sourceMappingURL=AddressTransformZod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AddressTransformZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressTransformZod.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,eAAO,MAAM,mBAAmB;;;;YAkBD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

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

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const AddressValidationZod: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, {
+    readonly __address: true;
+}>, string>>;
+export type AddressValidationZodType = z.infer<typeof AddressValidationZod>;
+//# sourceMappingURL=AddressValidationZod.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AddressValidationZod.d.ts","sourceRoot":"","sources":["../../../src/address/AddressValidationZod.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAMnB,eAAO,MAAM,oBAAoB;;;;YAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -1,26 +1,11 @@
+import type { Brand } from '@xylabs/typeof';
 import z from 'zod';
-import type { AssertConfig } from '../assert.ts';
-import type { Hex, HexConfig } from '../hex/index.ts';
-export type Address = Hex & {
-    readonly __address: true;
-};
-export declare const AddressRegEx: RegExp;
-export declare const AddressToStringZod: z.ZodString;
-/** @deprecated use AddressToStringZod */
-export declare const AddressToStringSchema: z.ZodString;
-export declare const AddressFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
-/** @deprecated use AddressFromStringZod */
-export declare const AddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
+import type { Hex } from '../hex/index.ts';
 export declare const ZERO_ADDRESS: Address;
 export declare const ADDRESS_LENGTH: 40;
-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 function asAddress(value: unknown): Address | undefined;
-export declare function asAddress(value: unknown, assert: AssertConfig): Address;
-/** @alpha */
-export declare function isAddressV2(value: unknown): value is Address;
-/** @alpha */
-export declare function asAddressV2(value: unknown, assert?: boolean): Address | undefined;
-/** @alpha */
-export declare function toAddressV2(value: unknown, assert?: boolean): Address | undefined;
+export declare const AddressRegEx: RegExp;
+export declare const AddressZod: z.ZodType<Brand<Hex, {
+    readonly __address: true;
+}>>;
+export type Address = z.infer<typeof AddressZod>;
 //# sourceMappingURL=address.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/address/address.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAEhD,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AASrD,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CACzB,CAAA;AAED,eAAO,MAAM,YAAY,QAAyB,CAAA;AAElD,eAAO,MAAM,kBAAkB,aAAiC,CAAA;AAEhE,yCAAyC;AACzC,eAAO,MAAM,qBAAqB,aAAqB,CAAA;AAEvD,eAAO,MAAM,oBAAoB,yDAA4E,CAAA;AAE7G,2CAA2C;AAC3C,eAAO,MAAM,uBAAuB,yDAAuB,CAAA;AAE3D,eAAO,MAAM,YAAY,EAAiD,OAAO,CAAA;AACjF,eAAO,MAAM,cAAc,EAAG,EAAW,CAAA;AAEzC,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,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;AAqBxE,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE5D;AAED,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,GAAG,SAAS,CAIxF;AAED,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,GAAG,SAAS,CAIxF"}
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src/address/address.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAG1C,eAAO,MAAM,YAAY,EAAiD,OAAO,CAAA;AACjF,eAAO,MAAM,cAAc,EAAG,EAAW,CAAA;AAEzC,eAAO,MAAM,YAAY,QAAyD,CAAA;AAElF,eAAO,MAAM,UAAU,EACiD,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,CAAA;AAE3H,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

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

@@ -0,0 +1,18 @@
+import z from 'zod';
+/** @deprecated use AddressZod */
+export declare const AddressToStringZod: z.ZodString;
+/** @deprecated use AddressZod */
+export declare const AddressToStringSchema: z.ZodString;
+/** @deprecated use AddressZod */
+export declare const AddressFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, {
+    readonly __address: true;
+}>, string>>;
+/** @deprecated use AddressZod */
+export declare const AddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<import("@xylabs/typeof").Brand<import("@xylabs/typeof").Brand<Lowercase<string>, {
+    readonly __hex: true;
+}>, {
+    readonly __address: true;
+}>, string>>;
+//# sourceMappingURL=addressDeprecated.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"addressDeprecated.d.ts","sourceRoot":"","sources":["../../../src/address/addressDeprecated.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,iCAAiC;AACjC,eAAO,MAAM,kBAAkB,aAAiC,CAAA;AAEhE,iCAAiC;AAEjC,eAAO,MAAM,qBAAqB,aAAqB,CAAA;AAEvD,iCAAiC;AACjC,eAAO,MAAM,oBAAoB;;;;YAA4E,CAAA;AAE7G,iCAAiC;AAEjC,eAAO,MAAM,uBAAuB;;;;YAAuB,CAAA"}

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

@@ -0,0 +1,7 @@
+import type { AssertConfig } from '../assert.ts';
+import type { Address } from './address.ts';
+export declare function asAddress(value: unknown): Address | undefined;
+export declare function asAddress(value: unknown, assert: AssertConfig): Address;
+/** @alpha */
+export declare function asAddressV2(value: unknown, assert?: boolean): Address | undefined;
+//# sourceMappingURL=as.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"as.d.ts","sourceRoot":"","sources":["../../../src/address/as.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAI3C,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;AAqBxE,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,GAAG,SAAS,CAIxF"}

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

@@ -1,4 +1,8 @@
 export * from './address.ts';
-export * from './AddressZodTransform.ts';
-export * from './AddressZodValidation.ts';
+export * from './addressDeprecated.ts';
+export * from './AddressTransformZod.ts';
+export * from './AddressValidationZod.ts';
+export * from './as.ts';
+export * from './is.ts';
+export * from './to.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,wBAAwB,CAAA;AACtC,cAAc,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA;AACzC,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}

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

@@ -0,0 +1,6 @@
+import type { HexConfig } from '../hex/index.ts';
+import type { Address } from './address.ts';
+export declare const isAddress: (value: unknown, config?: HexConfig) => value is Address;
+/** @alpha */
+export declare function isAddressV2(value: unknown): value is Address;
+//# sourceMappingURL=is.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../../src/address/is.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,OAG3E,CAAA;AAED,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE5D"}

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

@@ -0,0 +1,6 @@
+import type { HexConfig } from '../hex/index.ts';
+import type { Address } from './address.ts';
+export declare const toAddress: (value: string | number | bigint | ArrayBufferLike, config?: HexConfig) => Address;
+/** @alpha */
+export declare function toAddressV2(value: unknown, assert?: boolean): Address | undefined;
+//# sourceMappingURL=to.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/address/to.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,OAKrG,CAAA;AAED,aAAa;AACb,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,GAAG,SAAS,CAIxF"}

package/dist/neutral/ethAddress.d.ts

@@ -3,7 +3,11 @@ import z from 'zod';
 import type { AssertConfig } from './assert.ts';
 import type { HexConfig } from './hex/index.ts';
 export declare const EthAddressRegEx: RegExp;
+export declare const EthAddressToStringZod: z.ZodString;
+/** @deprecated use EthAddressToStringZod */
 export declare const EthAddressToStringSchema: z.ZodString;
+export declare const EthAddressFromStringZod: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
+/** @deprecated use EthAddressFromStringZod */
 export declare const EthAddressFromStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<EthAddress, string>>;
 export type EthAddress = Brand<string, {
     readonly __eth_address: true;

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

@@ -1 +1 @@
-{"version":3,"file":"ethAddress.d.ts","sourceRoot":"","sources":["../../src/ethAddress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAM/C,eAAO,MAAM,eAAe,QAA4C,CAAA;AAExE,eAAO,MAAM,wBAAwB,aAAoC,CAAA;AACzE,eAAO,MAAM,0BAA0B,4DAAoE,CAAA;AAG3G,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExE,eAAO,MAAM,gBAAgB,EAAmD,UAAU,CAAA;AAE1F,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,UAKxG,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,UAG9E,CAAA;AAED,eAAO,MAAM,aAAa,aAIvB,CAAA;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAA;AACpE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,UAAU,CAAA"}
+{"version":3,"file":"ethAddress.d.ts","sourceRoot":"","sources":["../../src/ethAddress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAM/C,eAAO,MAAM,eAAe,QAA4C,CAAA;AAExE,eAAO,MAAM,qBAAqB,aAAoC,CAAA;AAEtE,4CAA4C;AAC5C,eAAO,MAAM,wBAAwB,aAAwB,CAAA;AAE7D,eAAO,MAAM,uBAAuB,4DAAoE,CAAA;AAExG,8CAA8C;AAC9C,eAAO,MAAM,0BAA0B,4DAA0B,CAAA;AAGjE,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,aAAa,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExE,eAAO,MAAM,gBAAgB,EAAmD,UAAU,CAAA;AAE1F,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe,EAAE,SAAQ,SAAc,KAAG,UAKxG,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,SAAQ,SAAc,KAAG,KAAK,IAAI,UAG9E,CAAA;AAED,eAAO,MAAM,aAAa,aAIvB,CAAA;AAEH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAA;AACpE,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,UAAU,CAAA"}

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

@@ -0,0 +1,5 @@
+import type { AssertConfig } from '../assert.ts';
+import { type Hash } from './hash.ts';
+export declare function asHash(value: unknown): Hash | undefined;
+export declare function asHash(value: unknown, assert: AssertConfig): Hash;
+//# sourceMappingURL=as.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"as.d.ts","sourceRoot":"","sources":["../../../src/hash/as.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,WAAW,CAAA;AAGrC,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/hash/hash.d.ts

@@ -0,0 +1,14 @@
+import type { Brand } from '@xylabs/typeof';
+import z from 'zod';
+import type { Hex } from '../hex/index.ts';
+export declare const HASH_LENGTH: 32;
+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 declare const HashZod: z.ZodType<Brand<Hex, {
+    readonly __hash: true;
+}>>;
+export type Hash = z.infer<typeof HashZod>;
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/hash/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAG1C,eAAO,MAAM,WAAW,EAAG,EAAW,CAAA;AAEtC,eAAO,MAAM,SAAS,QAA2C,CAAA;AAEjE,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,eAAO,MAAM,OAAO,EACiD,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,CAAA;AAErH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA"}

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

@@ -0,0 +1,4 @@
+export * from './as.ts';
+export * from './hash.ts';
+export * from './is.ts';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hash/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,WAAW,CAAA;AACzB,cAAc,SAAS,CAAA"}

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

@@ -0,0 +1,3 @@
+import type { Hash, HashBitLength } from './hash.ts';
+export declare const isHash: (value: unknown, bitLength?: HashBitLength) => value is Hash;
+//# sourceMappingURL=is.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../../src/hash/is.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEpD,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,EAAE,YAAW,aAAmB,KAAG,KAAK,IAAI,IAEhF,CAAA"}

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

@@ -1,5 +1,5 @@
 import type { AssertConfig } from '../assert.ts';
-import type { Hex } from './model.ts';
+import type { Hex } from './hex.ts';
 export declare function asHex(value: unknown): Hex | undefined;
 export declare function asHex(value: unknown, assert: AssertConfig): Hex;
 //# sourceMappingURL=as.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"as.d.ts","sourceRoot":"","sources":["../../../src/hex/as.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAIhD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAA;AAErC,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,GAAG,SAAS,CAAA;AACtD,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAA"}
+{"version":3,"file":"as.d.ts","sourceRoot":"","sources":["../../../src/hex/as.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAGnC,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,GAAG,GAAG,SAAS,CAAA;AACtD,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,GAAG,CAAA"}

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

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts';
+import type { Hex, HexConfig } from '../hex.ts';
 /** Takes unknown value and tries our best to convert it to a hex string */
 export declare const hexFrom: (
 /** Supported types are string, number, bigint, and ArrayBuffer */

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

@@ -1 +1 @@
-{"version":3,"file":"from.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/from.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAMjD,2EAA2E;AAC3E,eAAO,MAAM,OAAO;AAClB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAS,SAAS,KACjB,GAkBF,CAAA"}
+{"version":3,"file":"from.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/from.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAM/C,2EAA2E;AAC3E,eAAO,MAAM,OAAO;AAClB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAS,SAAS,KACjB,GAkBF,CAAA"}

package/dist/neutral/hex/from/fromArrayBuffer.d.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts';
+import type { Hex, HexConfig } from '../hex.ts';
 /** Convert an ArrayBuffer to a hex string */
 export declare const hexFromArrayBuffer: (
 /** The buffer to be converted */

package/dist/neutral/hex/from/fromArrayBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fromArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromArrayBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGjD,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB;AAC7B,iCAAiC;AACjC,QAAQ,eAAe;AACvB,oDAAoD;AACpD,SAAS,SAAS,KACjB,GAGF,CAAA"}
+{"version":3,"file":"fromArrayBuffer.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromArrayBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAG/C,6CAA6C;AAC7C,eAAO,MAAM,kBAAkB;AAC7B,iCAAiC;AACjC,QAAQ,eAAe;AACvB,oDAAoD;AACpD,SAAS,SAAS,KACjB,GAGF,CAAA"}

package/dist/neutral/hex/from/fromBigInt.d.ts

@@ -1,4 +1,4 @@
-import type { Hex, HexConfig } from '../model.ts';
+import type { Hex, HexConfig } from '../hex.ts';
 /** Convert a bigint to a hex string */
 export declare const hexFromBigInt: (
 /** The bigint to be converted */

package/dist/neutral/hex/from/fromBigInt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fromBigInt.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromBigInt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGjD,uCAAuC;AACvC,eAAO,MAAM,aAAa;AACxB,iCAAiC;AACjC,OAAO,MAAM;AACb,oDAAoD;AACpD,SAAQ,SAAc,KACrB,GAGF,CAAA"}
+{"version":3,"file":"fromBigInt.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromBigInt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAG/C,uCAAuC;AACvC,eAAO,MAAM,aAAa;AACxB,iCAAiC;AACjC,OAAO,MAAM;AACb,oDAAoD;AACpD,SAAQ,SAAc,KACrB,GAGF,CAAA"}

package/dist/neutral/hex/from/fromHexString.d.ts

@@ -1,3 +1,3 @@
-import type { Hex, HexConfig } from '../model.ts';
+import type { Hex, HexConfig } from '../hex.ts';
 export declare const hexFromHexString: (value: string, config?: HexConfig) => Hex;
 //# sourceMappingURL=fromHexString.d.ts.map

package/dist/neutral/hex/from/fromHexString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fromHexString.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromHexString.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGjD,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,EAAE,SAAQ,SAAc,KAAG,GAaxE,CAAA"}
+{"version":3,"file":"fromHexString.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromHexString.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAI/C,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,EAAE,SAAQ,SAAc,KAAG,GAaxE,CAAA"}

package/dist/neutral/hex/from/fromNumber.d.ts

@@ -1,3 +1,3 @@
-import type { Hex, HexConfig } from '../model.ts';
+import type { Hex, HexConfig } from '../hex.ts';
 export declare const hexFromNumber: (value: number, config?: HexConfig) => Hex;
 //# sourceMappingURL=fromNumber.d.ts.map

package/dist/neutral/hex/from/fromNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fromNumber.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromNumber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGjD,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,SAAS,SAAS,KAAG,GAEjE,CAAA"}
+{"version":3,"file":"fromNumber.d.ts","sourceRoot":"","sources":["../../../../src/hex/from/fromNumber.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAG/C,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,SAAS,SAAS,KAAG,GAEjE,CAAA"}

package/dist/neutral/hex/{model.d.ts → hex.d.ts}

@@ -10,4 +10,4 @@ export interface HexConfig {
     byteSize?: number;
     prefix?: boolean;
 }
-//# sourceMappingURL=model.d.ts.map
+//# sourceMappingURL=hex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hex.d.ts","sourceRoot":"","sources":["../../../src/hex/hex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,eAAO,MAAM,MAAM,EACiD,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,CAAA;AAEjI,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA;AAExC,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/index.d.ts

@@ -1,9 +1,9 @@
 export * from './as.ts';
 export * from './from/index.ts';
+export * from './hex.ts';
 export * from './is.ts';
 export * from './isHexZero.ts';
 export * from './legacy.ts';
-export * from './model.ts';
 export * from './nibble.ts';
 export * from './to.ts';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hex/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hex/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA"}

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

@@ -1,3 +1,3 @@
-import type { Hex, HexConfig } from './model.ts';
+import type { Hex, HexConfig } from './hex.ts';
 export declare const isHex: (value: unknown, config?: HexConfig) => value is Hex;
 //# sourceMappingURL=is.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../../src/hex/is.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAGhD,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,EAAE,SAAS,SAAS,KAAG,KAAK,IAAI,GAWnE,CAAA"}
+{"version":3,"file":"is.d.ts","sourceRoot":"","sources":["../../../src/hex/is.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAG9C,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,EAAE,SAAS,SAAS,KAAG,KAAK,IAAI,GAWnE,CAAA"}

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

@@ -1,4 +1,4 @@
-import type { HexConfig } from './model.ts';
+import type { HexConfig } from './hex.ts';
 /** takes any value and tries our best to convert it to a hex string */
 export declare const toHex: (
 /** Supported types are string, number, bigint, and ArrayBuffer */

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;;EAIvB,CAAA"}
+{"version":3,"file":"to.d.ts","sourceRoot":"","sources":["../../../src/hex/to.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,uEAAuE;AACvE,eAAO,MAAM,KAAK;AAChB,kEAAkE;AAClE,OAAO,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,eAAe;AACjD,oDAAoD;AACpD,SAAQ,SAAc;;EAIvB,CAAA"}

package/dist/neutral/index-internal.d.ts

@@ -1,7 +1,7 @@
 export * from './address/index.ts';
 export * from './assert.ts';
 export * from './ethAddress.ts';
-export * from './hash.ts';
+export * from './hash/index.ts';
 export * from './hex/index.ts';
 export * from './HexRegEx.ts';
 export * from './hexToBigInt.ts';

package/dist/neutral/index-internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-internal.d.ts","sourceRoot":"","sources":["../../src/index-internal.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,WAAW,CAAA;AACzB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index-internal.d.ts","sourceRoot":"","sources":["../../src/index-internal.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,kBAAkB,CAAA"}

package/dist/neutral/index-internal.mjs

@@ -1,6 +1,24 @@
 // src/address/address.ts
-import { isObject } from "@xylabs/typeof";
-import z4 from "zod";
+import z from "zod";
+
+// src/HexRegEx.ts
+var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+};
+var HexRegEx = /^[0-9a-f]+$/;
+var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+
+// src/address/address.ts
+var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
+var ADDRESS_LENGTH = 40;
+var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+var AddressZod = z.string().regex(AddressRegEx, { message: "Invalid hex format" });
+
+// src/address/addressDeprecated.ts
+import z5 from "zod";
 
 // src/assert.ts
 import { isString, isUndefined } from "@xylabs/typeof";
@@ -17,16 +35,6 @@ var assertError = (value, assert, defaultMessage) => {
 // src/hex/from/fromHexString.ts
 import { isNumber } from "@xylabs/typeof";
 
-// src/HexRegEx.ts
-var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
-  return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
-};
-var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
-  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
-};
-var HexRegEx = /^[0-9a-f]+$/;
-var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
-
 // src/hex/nibble.ts
 var bitsToNibbles = (value) => {
   const nibbles = value >> 2;
@@ -116,6 +124,10 @@ function asHex(value, assert) {
   return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
 }
 
+// src/hex/hex.ts
+import z2 from "zod";
+var HexZod = z2.string().regex(HexRegEx, { message: "Invalid hex format" });
+
 // src/hex/isHexZero.ts
 import { isString as isString2 } from "@xylabs/typeof";
 var isHexZero = (value) => {
@@ -127,42 +139,38 @@ var toHexLegacy = (buffer) => {
   return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
 };
 
-// src/hex/model.ts
-import z from "zod";
-var HexZod = z.string().regex(HexRegEx, { message: "Invalid hex format" });
-
 // src/hex/to.ts
 var toHex = (value, config = {}) => {
   const { prefix = false } = config;
   return hexFrom(value, { prefix, ...config });
 };
 
-// src/address/AddressZodTransform.ts
-import z3 from "zod";
+// src/address/AddressTransformZod.ts
+import z4 from "zod";
 
-// src/address/AddressZodValidation.ts
-import z2 from "zod";
-var AddressZodValidation = z2.string().refine((x) => HexZod.safeParse(x)).refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${e.input}]`) }).transform((v) => v);
+// src/address/AddressValidationZod.ts
+import z3 from "zod";
+var AddressValidationZod = z3.string().refine((x) => HexZod.safeParse(x)).refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${e.input}]`) }).transform((v) => v);
 
-// src/address/AddressZodTransform.ts
-var AddressZodTransform = z3.union([z3.string(), z3.bigint()]).transform((value) => {
-  if (typeof value === "bigint") {
-    return value.toString(16).padStart(40, "0");
-  }
-  if (value.startsWith("0x")) {
-    return value.slice(2);
+// src/address/AddressTransformZod.ts
+var AddressTransformZod = z4.union([z4.string(), z4.bigint(), z4.number()]).transform((value) => {
+  switch (typeof value) {
+    case "bigint": {
+      return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+    }
+    case "string": {
+      if (value.startsWith("0x")) {
+        return value.slice(2);
+      }
+      return value;
+    }
+    case "number": {
+      return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+    }
   }
-  return value;
-}).refine((x) => AddressZodValidation.safeParse(x).data).transform((x) => x);
+}).refine((x) => AddressValidationZod.safeParse(x).data).transform((x) => x);
 
-// src/address/address.ts
-var AddressRegEx = HexRegExMinMax(20, 20);
-var AddressToStringZod = z4.string().regex(AddressRegEx);
-var AddressToStringSchema = AddressToStringZod;
-var AddressFromStringZod = z4.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
-var AddressFromStringSchema = AddressFromStringZod;
-var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
-var ADDRESS_LENGTH = 40;
+// src/address/to.ts
 var toAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = false } = config;
   return hexFrom(value, {
@@ -171,10 +179,29 @@ var toAddress = (value, config = {}) => {
     ...config
   });
 };
+function toAddressV2(value, assert = false) {
+  return assert ? AddressTransformZod.parse(value) : AddressTransformZod.safeParse(value).data;
+}
+
+// src/address/addressDeprecated.ts
+var AddressToStringZod = z5.string().regex(AddressRegEx);
+var AddressToStringSchema = AddressToStringZod;
+var AddressFromStringZod = z5.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+var AddressFromStringSchema = AddressFromStringZod;
+
+// src/address/as.ts
+import { isObject } from "@xylabs/typeof";
+
+// src/address/is.ts
 var isAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = false } = config;
   return isHex(value, { bitLength, prefix });
 };
+function isAddressV2(value) {
+  return AddressValidationZod.safeParse(value).success;
+}
+
+// src/address/as.ts
 function asAddress(value, assert) {
   try {
     let stringValue = void 0;
@@ -193,21 +220,17 @@ function asAddress(value, assert) {
     return assertError(void 0, assert, error.message);
   }
 }
-function isAddressV2(value) {
-  return AddressZodValidation.safeParse(value).success;
-}
 function asAddressV2(value, assert = false) {
-  return assert ? AddressZodValidation.parse(value) : AddressZodValidation.safeParse(value).data;
-}
-function toAddressV2(value, assert = false) {
-  return assert ? AddressZodTransform.parse(value) : AddressZodTransform.safeParse(value).data;
+  return assert ? AddressValidationZod.parse(value) : AddressValidationZod.safeParse(value).data;
 }
 
 // src/ethAddress.ts
-import z5 from "zod";
+import z6 from "zod";
 var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
-var EthAddressToStringSchema = z5.string().regex(EthAddressRegEx);
-var EthAddressFromStringSchema = z5.string().regex(EthAddressRegEx).transform((v) => toEthAddress(v));
+var EthAddressToStringZod = z6.string().regex(EthAddressRegEx);
+var EthAddressToStringSchema = EthAddressToStringZod;
+var EthAddressFromStringZod = z6.string().regex(EthAddressRegEx).transform((v) => toEthAddress(v));
+var EthAddressFromStringSchema = EthAddressFromStringZod;
 var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 var toEthAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = false } = config;
@@ -221,7 +244,7 @@ var isEthAddress = (value, config = {}) => {
   const { bitLength = 160, prefix = true } = config;
   return isHex(value, { bitLength, prefix });
 };
-var EthAddressZod = z5.string().regex(EthAddressRegEx, { message: "Invalid address format" }).refine(
+var EthAddressZod = z6.string().regex(EthAddressRegEx, { message: "Invalid address format" }).refine(
   isEthAddress
 );
 function asEthAddress(value, assert) {
@@ -245,21 +268,15 @@ function asEthAddress(value, assert) {
   }
 }
 
-// src/hash.ts
+// src/hash/as.ts
 import { isUndefined as isUndefined2 } from "@xylabs/typeof";
-import z6 from "zod";
-var HashRegEx = HexRegExMinMax(32, 32);
-var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
-var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
-var isHashBitLength = (value) => {
-  return typeof value === "number" && HashBitLength.includes(value);
-};
+
+// src/hash/is.ts
 var isHash = (value, bitLength = 256) => {
   return isHex(value, { bitLength });
 };
-var HashZod = z6.string().toLowerCase().regex(HashRegEx, { message: "Invalid hash format" }).refine(
-  isHash
-);
+
+// src/hash/as.ts
 function asHash(value, assert) {
   let stringValue = void 0;
   switch (typeof value) {
@@ -274,6 +291,17 @@ function asHash(value, assert) {
   return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
 }
 
+// src/hash/hash.ts
+import z7 from "zod";
+var HASH_LENGTH = 32;
+var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+var ZERO_HASH = "0000000000000000000000000000000000000000000000000000000000000000";
+var HashBitLength = [32, 64, 128, 256, 512, 1024, 2048, 4096];
+var isHashBitLength = (value) => {
+  return typeof value === "number" && HashBitLength.includes(value);
+};
+var HashZod = z7.string().regex(HashRegEx, { message: "Invalid hex format" });
+
 // src/hexToBigInt.ts
 function hexToBigInt(hex) {
   return BigInt(hexFromHexString(hex, { prefix: true }));
@@ -285,13 +313,17 @@ export {
   AddressRegEx,
   AddressToStringSchema,
   AddressToStringZod,
-  AddressZodTransform,
-  AddressZodValidation,
+  AddressTransformZod,
+  AddressValidationZod,
+  AddressZod,
   ETH_ZERO_ADDRESS,
   EthAddressFromStringSchema,
+  EthAddressFromStringZod,
   EthAddressRegEx,
   EthAddressToStringSchema,
+  EthAddressToStringZod,
   EthAddressZod,
+  HASH_LENGTH,
   HashBitLength,
   HashRegEx,
   HashZod,