@xylabs/hex 5.0.1 → 5.0.3

package/dist/neutral/Brand.d.ts

@@ -1,4 +1,4 @@
-export type Brand<T, B> = T & {
-    [K in keyof B]: B[K];
-};
+import type { Brand as TypeOfBrand } from '@xylabs/typeof';
+/** @deprecated use from @xylabs/typeof instead */
+export type Brand<T, B> = TypeOfBrand<T, B>;
 //# sourceMappingURL=Brand.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../src/Brand.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAA"}
+{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../src/Brand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,IAAI,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE1D,kDAAkD;AAClD,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA"}

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

@@ -1,5 +1,5 @@
 import z from 'zod';
-import type { Address } from './AddressNamespace.ts';
+import type { Address } from './address.ts';
 export declare const AddressZodTransform: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodBigInt]>, z.ZodTransform<string, string | bigint>>, z.ZodTransform<Address, string>>;
 export type AddressZodTransformType = z.infer<typeof AddressZodTransform>;
 //# sourceMappingURL=AddressZodTransform.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AddressZodTransform.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodTransform.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAGpD,eAAO,MAAM,mBAAmB,iJAWD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}
+{"version":3,"file":"AddressZodTransform.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodTransform.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,mBAAmB,iJAWD,CAAA;AAE/B,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

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

@@ -1,5 +1,5 @@
 import z from 'zod';
-import type { Address } from './AddressNamespace.ts';
+import type { Address } from './address.ts';
 export declare const AddressZodValidation: z.ZodPipe<z.ZodString, z.ZodTransform<Address, string>>;
 export type AddressZodValidationType = z.infer<typeof AddressZodValidation>;
 //# sourceMappingURL=AddressZodValidation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AddressZodValidation.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodValidation.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAInB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAEpD,eAAO,MAAM,oBAAoB,yDAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}
+{"version":3,"file":"AddressZodValidation.d.ts","sourceRoot":"","sources":["../../../src/address/AddressZodValidation.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAGnB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,eAAO,MAAM,oBAAoB,yDAGF,CAAA;AAE/B,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA"}

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

@@ -1,7 +1,9 @@
 import z from 'zod';
 import type { AssertConfig } from '../assert.ts';
-import type { HexConfig } from '../hex/index.ts';
-import type { Address } from './AddressNamespace.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 */
@@ -15,4 +17,10 @@ export declare const toAddress: (value: string | number | bigint | ArrayBufferLi
 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;
 //# 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,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAKhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAEpD,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"}
+{"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"}

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

@@ -1,5 +1,4 @@
 export * from './address.ts';
-export * from './AddressNamespace.ts';
 export * from './AddressZodTransform.ts';
 export * from './AddressZodValidation.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,uBAAuB,CAAA;AACrC,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,0BAA0B,CAAA;AACxC,cAAc,2BAA2B,CAAA"}

package/dist/neutral/ethAddress.d.ts

@@ -1,6 +1,6 @@
+import type { Brand } from '@xylabs/typeof';
 import z from 'zod';
 import type { AssertConfig } from './assert.ts';
-import type { Brand } from './Brand.ts';
 import type { HexConfig } from './hex/index.ts';
 export declare const EthAddressRegEx: RegExp;
 export declare const EthAddressToStringSchema: z.ZodString;

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

@@ -1 +1 @@
-{"version":3,"file":"ethAddress.d.ts","sourceRoot":"","sources":["../../src/ethAddress.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,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,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"}

package/dist/neutral/hash.d.ts

@@ -1,6 +1,6 @@
+import type { Brand } from '@xylabs/typeof';
 import z from 'zod';
 import type { AssertConfig } from './assert.ts';
-import type { Brand } from './Brand.ts';
 import type { Hex } from './hex/index.ts';
 export declare const HashRegEx: RegExp;
 export declare const ZERO_HASH: Hash;

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

@@ -1 +1 @@
-{"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,KAAK,EAAE,MAAM,YAAY,CAAA;AACvC,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;AAGD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExD,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"}
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAE3C,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;AAGD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAExD,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,5 +1,5 @@
+import type { Brand } from '@xylabs/typeof';
 import z from 'zod';
-import type { Brand } from '../Brand.ts';
 export type Hex = Brand<Lowercase<string>, {
     readonly __hex: true;
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/hex/model.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAEnB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAIxC,MAAM,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpE,eAAO,MAAM,MAAM,qDAC2D,CAAA;AAE9E,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA"}
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/hex/model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,CAAC,MAAM,KAAK,CAAA;AAKnB,MAAM,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;CAAE,CAAC,CAAA;AAEpE,eAAO,MAAM,MAAM,qDAC2D,CAAA;AAE9E,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAA"}

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

@@ -0,0 +1,8 @@
+export * from './address/index.ts';
+export * from './assert.ts';
+export * from './ethAddress.ts';
+export * from './hash.ts';
+export * from './hex/index.ts';
+export * from './HexRegEx.ts';
+export * from './hexToBigInt.ts';
+//# sourceMappingURL=index-internal.d.ts.map

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

@@ -0,0 +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"}

package/dist/neutral/index-internal.mjs

@@ -0,0 +1,332 @@
+// src/address/address.ts
+import { isObject } from "@xylabs/typeof";
+import z4 from "zod";
+
+// src/assert.ts
+import { isString, isUndefined } from "@xylabs/typeof";
+var assertError = (value, assert, defaultMessage) => {
+  if (!isUndefined(assert)) {
+    const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+    if (isString(assertString) || assertString === true) {
+      throw new Error(assertString === true ? defaultMessage : assertString);
+    }
+  }
+  return void 0;
+};
+
+// 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;
+  if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+  return nibbles;
+};
+var nibblesToBits = (value) => {
+  return value << 2;
+};
+
+// src/hex/is.ts
+var isHex = (value, config) => {
+  if (typeof value !== "string") return false;
+  const valueCharLength = config?.prefix ? value.length - 2 : value.length;
+  if (config?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config?.bitLength)) return false;
+  return config?.prefix ? HexRegExWithPrefix.test(value) : HexRegEx.test(value);
+};
+
+// src/hex/from/fromHexString.ts
+var hexFromHexString = (value, config = {}) => {
+  const {
+    prefix = false,
+    byteSize = 8,
+    bitLength
+  } = config;
+  const nibbleBoundary = bitsToNibbles(byteSize);
+  const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+  if (isHex(unEvened)) {
+    const evenCharacters = unEvened.padStart(unEvened.length + unEvened.length % nibbleBoundary, "0");
+    const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+    return (prefix ? `0x${padded}` : padded).toLowerCase();
+  } else {
+    throw new Error("Received string is not a value hex");
+  }
+};
+
+// src/hex/from/fromArrayBuffer.ts
+var hexFromArrayBuffer = (buffer, config) => {
+  const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hexFromHexString(unPadded, config);
+};
+
+// src/hex/from/fromBigInt.ts
+var hexFromBigInt = (value, config = {}) => {
+  const unPadded = value.toString(16);
+  return hexFromHexString(unPadded, config);
+};
+
+// src/hex/from/fromNumber.ts
+var hexFromNumber = (value, config) => {
+  return hexFromBigInt(BigInt(value), config);
+};
+
+// src/hex/from/from.ts
+var hexFrom = (value, config) => {
+  switch (typeof value) {
+    case "string": {
+      return hexFromHexString(value, config);
+    }
+    case "bigint": {
+      return hexFromBigInt(value, config);
+    }
+    case "number": {
+      return hexFromNumber(value, config);
+    }
+    case "object": {
+      return hexFromArrayBuffer(value, config);
+    }
+    default: {
+      throw new Error(`Invalid type: ${typeof value}`);
+    }
+  }
+};
+
+// src/hex/as.ts
+function asHex(value, assert) {
+  let stringValue = void 0;
+  switch (typeof value) {
+    case "string": {
+      stringValue = hexFromHexString(value);
+      break;
+    }
+    default: {
+      return assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+  return isHex(stringValue) ? stringValue : assertError(value, assert, `Value is not Hex [${value}]`);
+}
+
+// src/hex/isHexZero.ts
+import { isString as isString2 } from "@xylabs/typeof";
+var isHexZero = (value) => {
+  return isString2(value) ? BigInt(hexFromHexString(value, { prefix: true })) === 0n : void 0;
+};
+
+// src/hex/legacy.ts
+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" }).transform((x) => x);
+
+// 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/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/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);
+  }
+  return value;
+}).refine((x) => AddressZodValidation.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;
+var toAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix = false } = config;
+  return hexFrom(value, {
+    bitLength,
+    prefix,
+    ...config
+  });
+};
+var isAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix = false } = config;
+  return isHex(value, { bitLength, prefix });
+};
+function asAddress(value, assert) {
+  try {
+    let stringValue = void 0;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: false });
+        break;
+      }
+      default: {
+        return isObject(assert) ? assertError(value, assert, `Unsupported type [${typeof value}]`) : void 0;
+      }
+    }
+    return isAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an Address [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    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;
+}
+
+// src/ethAddress.ts
+import z5 from "zod";
+var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+var EthAddressToStringSchema = z5.string().regex(EthAddressRegEx);
+var EthAddressFromStringSchema = z5.string().regex(EthAddressRegEx).transform((v) => toEthAddress(v));
+var ETH_ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var toEthAddress = (value, config = {}) => {
+  const { bitLength = 160, prefix = false } = config;
+  return `0x${hexFrom(value, {
+    bitLength,
+    prefix,
+    ...config
+  })}`;
+};
+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(
+  isEthAddress
+);
+function asEthAddress(value, assert) {
+  try {
+    let stringValue = void 0;
+    switch (typeof value) {
+      case "string": {
+        stringValue = hexFromHexString(value, { prefix: true });
+        break;
+      }
+      default: {
+        if (value !== void 0) {
+          return assertError(value, assert, `Unsupported type [${typeof value}]`);
+        }
+      }
+    }
+    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`);
+  } catch (ex) {
+    const error = ex;
+    return assertError(void 0, assert, error.message);
+  }
+}
+
+// src/hash.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);
+};
+var isHash = (value, bitLength = 256) => {
+  return isHex(value, { bitLength });
+};
+var HashZod = z6.string().toLowerCase().regex(HashRegEx, { message: "Invalid hash format" }).refine(
+  isHash
+);
+function asHash(value, assert) {
+  let stringValue = void 0;
+  switch (typeof value) {
+    case "string": {
+      stringValue = hexFromHexString(value);
+      break;
+    }
+    default: {
+      return isUndefined2(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+    }
+  }
+  return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+}
+
+// src/hexToBigInt.ts
+function hexToBigInt(hex) {
+  return BigInt(hexFromHexString(hex, { prefix: true }));
+}
+export {
+  ADDRESS_LENGTH,
+  AddressFromStringSchema,
+  AddressFromStringZod,
+  AddressRegEx,
+  AddressToStringSchema,
+  AddressToStringZod,
+  AddressZodTransform,
+  AddressZodValidation,
+  ETH_ZERO_ADDRESS,
+  EthAddressFromStringSchema,
+  EthAddressRegEx,
+  EthAddressToStringSchema,
+  EthAddressZod,
+  HashBitLength,
+  HashRegEx,
+  HashZod,
+  HexRegEx,
+  HexRegExMinMax,
+  HexRegExMinMaxMixedCaseWithPrefix,
+  HexRegExWithPrefix,
+  HexZod,
+  ZERO_ADDRESS,
+  ZERO_HASH,
+  asAddress,
+  asAddressV2,
+  asEthAddress,
+  asHash,
+  asHex,
+  assertError,
+  bitsToNibbles,
+  hexFrom,
+  hexFromArrayBuffer,
+  hexFromBigInt,
+  hexFromHexString,
+  hexFromNumber,
+  hexToBigInt,
+  isAddress,
+  isAddressV2,
+  isEthAddress,
+  isHash,
+  isHashBitLength,
+  isHex,
+  isHexZero,
+  nibblesToBits,
+  toAddress,
+  toAddressV2,
+  toEthAddress,
+  toHex,
+  toHexLegacy
+};
+//# sourceMappingURL=index-internal.mjs.map

package/dist/neutral/index-internal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/address/address.ts","../../src/assert.ts","../../src/hex/from/fromHexString.ts","../../src/HexRegEx.ts","../../src/hex/nibble.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/hex/to.ts","../../src/address/AddressZodTransform.ts","../../src/address/AddressZodValidation.ts","../../src/ethAddress.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 '../HexRegEx.ts'\nimport { AddressZodTransform } from './AddressZodTransform.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Address = Hex & {\n  readonly __address: true\n}\n\nexport const AddressRegEx = HexRegExMinMax(20, 20)\n\nexport const AddressToStringZod = z.string().regex(AddressRegEx)\n\n/** @deprecated use AddressToStringZod */\nexport const AddressToStringSchema = AddressToStringZod\n\nexport const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\n/** @deprecated use AddressFromStringZod */\nexport const AddressFromStringSchema = AddressFromStringZod\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\nexport const ADDRESS_LENGTH = 40 as const\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 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\n/** @alpha */\nexport function isAddressV2(value: unknown): value is Address {\n  return AddressZodValidation.safeParse(value).success\n}\n\n/** @alpha */\nexport function asAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressZodValidation.parse(value)\n    : AddressZodValidation.safeParse(value).data\n}\n\n/** @alpha */\nexport function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressZodTransform.parse(value)\n    : AddressZodTransform.safeParse(value).data\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","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\nexport const HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n\nexport const HexRegEx = /^[0-9a-f]+$/\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\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","import { HexRegEx, HexRegExWithPrefix } from '../HexRegEx.ts'\nimport type { Hex, HexConfig } from './model.ts'\nimport { bitsToNibbles } from './nibble.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 type { Brand } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport { HexRegEx } from '../HexRegEx.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hex = Brand<Lowercase<string>, { readonly __hex: true }>\n\nexport const HexZod = z.string()\n  .regex(HexRegEx, { message: 'Invalid hex format' }).transform(x => x as Hex)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n\nexport type HexZodType = z.infer<typeof HexZod>\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 z from 'zod'\n\nimport type { Address } from './address.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\nexport const AddressZodTransform = z.union([z.string(), z.bigint()])\n  .transform((value) => {\n    if (typeof value === 'bigint') {\n      return value.toString(16).padStart(40, '0')\n    }\n    if (value.startsWith('0x')) {\n      return value.slice(2)\n    }\n    return value\n  })\n  .refine(x => AddressZodValidation.safeParse(x).data)\n  .transform(x => x as Address)\n\nexport type AddressZodTransformType = z.infer<typeof AddressZodTransform>\n","import z from 'zod'\n\nimport { HexZod } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\n\nexport const AddressZodValidation = z.string()\n  .refine(x => HexZod.safeParse(x))\n  .refine(x => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${e.input}]`) })\n  .transform(v => v as Address)\n\nexport type AddressZodValidationType = z.infer<typeof AddressZodValidation>\n","import type { Brand } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\nexport const EthAddressToStringSchema = z.string().regex(EthAddressRegEx)\nexport const EthAddressFromStringSchema = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type EthAddress = Brand<string, { readonly __eth_address: true }>\n\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix, ...config,\n  })}` as EthAddress\n}\n\nexport const isEthAddress = (value: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix = true } = config\n  return isHex(value, { bitLength, prefix })\n}\n\nexport const EthAddressZod = z.string()\n  .regex(EthAddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isEthAddress,\n  )\n\nexport function asEthAddress(value: unknown): EthAddress | undefined\nexport function asEthAddress(value: unknown, assert: AssertConfig): EthAddress\nexport function asEthAddress(value: unknown, assert?: AssertConfig): EthAddress | undefined {\n  try {\n    let stringValue: string | undefined = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: true })\n        break\n      }\n      default: {\n        if (value !== undefined) {\n          return assertError(value, assert, `Unsupported type [${typeof value}]`)\n        }\n      }\n    }\n    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n","import type { Brand } from '@xylabs/typeof'\nimport { 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 './HexRegEx.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\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hash = Brand<Hex, { readonly __hash: true }>\n\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","z","z","z","z","z","z","isUndefined","z","z","isUndefined"]}

package/dist/neutral/index.d.ts

@@ -1,9 +1,3 @@
-export * from './address/index.ts';
-export * from './assert.ts';
 export * from './Brand.ts';
-export * from './ethAddress.ts';
-export * from './hash.ts';
-export * from './hex/index.ts';
-export * from './HexRegEx.ts';
-export * from './hexToBigInt.ts';
+export * from './index-internal.ts';
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/neutral/index.mjs

@@ -1,6 +1,6 @@
 // src/address/address.ts
 import { isObject } from "@xylabs/typeof";
-import z2 from "zod";
+import z4 from "zod";
 
 // src/assert.ts
 import { isString, isUndefined } from "@xylabs/typeof";
@@ -137,11 +137,29 @@ var toHex = (value, config = {}) => {
   return hexFrom(value, { prefix, ...config });
 };
 
+// src/address/AddressZodTransform.ts
+import z3 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/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);
+  }
+  return value;
+}).refine((x) => AddressZodValidation.safeParse(x).data).transform((x) => x);
+
 // src/address/address.ts
 var AddressRegEx = HexRegExMinMax(20, 20);
-var AddressToStringZod = z2.string().regex(AddressRegEx);
+var AddressToStringZod = z4.string().regex(AddressRegEx);
 var AddressToStringSchema = AddressToStringZod;
-var AddressFromStringZod = z2.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
+var AddressFromStringZod = z4.string().toLowerCase().regex(AddressRegEx).transform((v) => toAddress(v));
 var AddressFromStringSchema = AddressFromStringZod;
 var ZERO_ADDRESS = "0000000000000000000000000000000000000000";
 var ADDRESS_LENGTH = 40;
@@ -175,33 +193,15 @@ function asAddress(value, assert) {
     return assertError(void 0, assert, error.message);
   }
 }
-
-// src/address/AddressZodTransform.ts
-import z4 from "zod";
-
-// src/address/AddressZodValidation.ts
-import z3 from "zod";
-var AddressZodValidation = 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 = z4.union([z4.string(), z4.bigint()]).transform((value) => {
-  if (typeof value === "bigint") {
-    return value.toString(16).padStart(40, "0");
-  }
-  if (value.startsWith("0x")) {
-    return value.slice(2);
-  }
-  return value;
-}).refine((x) => AddressZodValidation.safeParse(x).data).transform((x) => x);
-
-// src/address/AddressNamespace.ts
-var Address;
-((Address2) => {
-  Address2.identify = (value) => AddressZodValidation.safeParse(value).success;
-  Address2.cast = (value, assert = false) => assert ? AddressZodValidation.parse(value) : AddressZodValidation.safeParse(value).data;
-  Address2.from = (value, assert = false) => assert ? AddressZodTransform.parse(value) : AddressZodTransform.safeParse(value).data;
-  Address2.toString = (value) => value;
-})(Address || (Address = {}));
+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;
+}
 
 // src/ethAddress.ts
 import z5 from "zod";
@@ -280,7 +280,6 @@ function hexToBigInt(hex) {
 }
 export {
   ADDRESS_LENGTH,
-  Address,
   AddressFromStringSchema,
   AddressFromStringZod,
   AddressRegEx,
@@ -304,6 +303,7 @@ export {
   ZERO_ADDRESS,
   ZERO_HASH,
   asAddress,
+  asAddressV2,
   asEthAddress,
   asHash,
   asHex,
@@ -316,6 +316,7 @@ export {
   hexFromNumber,
   hexToBigInt,
   isAddress,
+  isAddressV2,
   isEthAddress,
   isHash,
   isHashBitLength,
@@ -323,6 +324,7 @@ export {
   isHexZero,
   nibblesToBits,
   toAddress,
+  toAddressV2,
   toEthAddress,
   toHex,
   toHexLegacy

package/dist/neutral/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/address/address.ts","../../src/assert.ts","../../src/hex/from/fromHexString.ts","../../src/HexRegEx.ts","../../src/hex/nibble.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/hex/to.ts","../../src/address/AddressZodTransform.ts","../../src/address/AddressZodValidation.ts","../../src/address/AddressNamespace.ts","../../src/ethAddress.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 { HexConfig } from '../hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from '../hex/index.ts'\nimport { HexRegExMinMax } from '../HexRegEx.ts'\nimport type { Address } from './AddressNamespace.ts'\n\nexport const AddressRegEx = HexRegExMinMax(20, 20)\n\nexport const AddressToStringZod = z.string().regex(AddressRegEx)\n\n/** @deprecated use AddressToStringZod */\nexport const AddressToStringSchema = AddressToStringZod\n\nexport const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\n/** @deprecated use AddressFromStringZod */\nexport const AddressFromStringSchema = AddressFromStringZod\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\nexport const ADDRESS_LENGTH = 40 as const\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 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","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\nexport const HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n\nexport const HexRegEx = /^[0-9a-f]+$/\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\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","import { HexRegEx, HexRegExWithPrefix } from '../HexRegEx.ts'\nimport type { Hex, HexConfig } from './model.ts'\nimport { bitsToNibbles } from './nibble.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 type { Brand } from '../Brand.ts'\nimport { HexRegEx } from '../HexRegEx.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hex = Brand<Lowercase<string>, { readonly __hex: true }>\n\nexport const HexZod = z.string()\n  .regex(HexRegEx, { message: 'Invalid hex format' }).transform(x => x as Hex)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n\nexport type HexZodType = z.infer<typeof HexZod>\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 z from 'zod'\n\nimport type { Address } from './AddressNamespace.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\nexport const AddressZodTransform = z.union([z.string(), z.bigint()])\n  .transform((value) => {\n    if (typeof value === 'bigint') {\n      return value.toString(16).padStart(40, '0')\n    }\n    if (value.startsWith('0x')) {\n      return value.slice(2)\n    }\n    return value\n  })\n  .refine(x => AddressZodValidation.safeParse(x).data)\n  .transform(x => x as Address)\n\nexport type AddressZodTransformType = z.infer<typeof AddressZodTransform>\n","import z from 'zod'\n\nimport { HexZod } from '../hex/index.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\nimport type { Address } from './AddressNamespace.ts'\n\nexport const AddressZodValidation = z.string()\n  .refine(x => HexZod.safeParse(x))\n  .refine(x => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${e.input}]`) })\n  .transform(v => v as Address)\n\nexport type AddressZodValidationType = z.infer<typeof AddressZodValidation>\n","import type { Hex } from '../hex/index.ts'\nimport { AddressZodTransform } from './AddressZodTransform.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Address = Hex & { readonly __address: true }\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace Address {\n  export const identify = (value: unknown): value is Address => AddressZodValidation.safeParse(value).success\n  export const cast = (value: unknown, assert: boolean = false): Address | undefined => assert\n    ? AddressZodValidation.parse(value)\n    : AddressZodValidation.safeParse(value).data\n  export const from = (value: unknown, assert: boolean = false): Address | undefined => assert\n    ? AddressZodTransform.parse(value)\n    : AddressZodTransform.safeParse(value).data\n  export const toString = (value: Address): string => value as string\n}\n","import z from 'zod'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { Brand } from './Brand.ts'\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\nexport const EthAddressToStringSchema = z.string().regex(EthAddressRegEx)\nexport const EthAddressFromStringSchema = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type EthAddress = Brand<string, { readonly __eth_address: true }>\n\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix, ...config,\n  })}` as EthAddress\n}\n\nexport const isEthAddress = (value: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix = true } = config\n  return isHex(value, { bitLength, prefix })\n}\n\nexport const EthAddressZod = z.string()\n  .regex(EthAddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isEthAddress,\n  )\n\nexport function asEthAddress(value: unknown): EthAddress | undefined\nexport function asEthAddress(value: unknown, assert: AssertConfig): EthAddress\nexport function asEthAddress(value: unknown, assert?: AssertConfig): EthAddress | undefined {\n  try {\n    let stringValue: string | undefined = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: true })\n        break\n      }\n      default: {\n        if (value !== undefined) {\n          return assertError(value, assert, `Unsupported type [${typeof value}]`)\n        }\n      }\n    }\n    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\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 { Brand } from './Brand.ts'\nimport type { Hex } from './hex/index.ts'\nimport { hexFromHexString, isHex } from './hex/index.ts'\nimport { HexRegExMinMax } from './HexRegEx.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\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hash = Brand<Hex, { readonly __hash: true }>\n\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":";AAAA,SAAS,gBAAgB;AACzB,OAAOA,QAAO;;;ACDd,SAAS,UAAU,mBAAmB;AAM/B,IAAM,cAAc,CAAC,OAAgB,QAAkC,mBAA2B;AACvG,MAAI,CAAC,YAAY,MAAM,GAAG;AACxB,UAAM,eACF,OAAO,WAAW,WAChB,SACA,OAAO,WAAW,YAChB,iBACA,OAAO,OAAO,cAAc;AACpC,QAAI,SAAS,YAAY,KAAK,iBAAiB,MAAM;AACnD,YAAM,IAAI,MAAM,iBAAiB,OAAO,iBAAiB,YAAY;AAAA,IACvE;AAAA,EACF;AAEA,SAAO;AACT;;;ACpBA,SAAS,gBAAgB;;;ACAlB,IAAM,iBAAiB,CAAC,WAAW,GAAG,WAAoB,OAAO,mBAAmB,MAAO;AAChG,SAAO,IAAI,OAAO,aAAa,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI;AACjE;AAEO,IAAM,oCAAoC,CAAC,WAAW,GAAG,WAAoB,OAAO,mBAAmB,MAAO;AACnH,SAAO,IAAI,OAAO,kBAAkB,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI;AACtE;AAEO,IAAM,WAAW;AACjB,IAAM,qBAAqB;;;ACR3B,IAAM,gBAAgB,CAAC,UAA0B;AACtD,QAAM,UAAU,SAAS;AACzB,MAAI,UAAU,WAAW,EAAG,OAAM,IAAI,MAAM,qCAAqC;AACjF,SAAO;AACT;AAGO,IAAM,gBAAgB,CAAC,UAA0B;AACtD,SAAO,SAAS;AAClB;;;ACNO,IAAM,QAAQ,CAAC,OAAgB,WAAqC;AAEzE,MAAI,OAAO,UAAU,SAAU,QAAO;AAEtC,QAAM,kBAAkB,QAAQ,SAAS,MAAM,SAAS,IAAI,MAAM;AAGlE,MAAI,QAAQ,cAAc,UAAa,oBAAoB,cAAc,QAAQ,SAAS,EAAG,QAAO;AAGpG,SAAO,QAAQ,SAAS,mBAAmB,KAAK,KAAK,IAAI,SAAS,KAAK,KAAK;AAC9E;;;AHTO,IAAM,mBAAmB,CAAC,OAAe,SAAoB,CAAC,MAAW;AAC9E,QAAM;AAAA,IACJ,SAAS;AAAA,IAAO,WAAW;AAAA,IAAG;AAAA,EAChC,IAAI;AACJ,QAAM,iBAAiB,cAAc,QAAQ;AAC7C,QAAM,YAAY,MAAM,WAAW,IAAI,IAAI,MAAM,MAAM,CAAC,IAAI,OAAO,YAAY;AAC/E,MAAI,MAAM,QAAQ,GAAG;AACnB,UAAM,iBAAiB,SAAS,SAAS,SAAS,SAAU,SAAS,SAAS,gBAAiB,GAAG;AAClG,UAAM,SAAS,SAAS,SAAS,IAAI,eAAe,SAAS,YAAY,GAAG,GAAG,IAAI;AACnF,YAAQ,SAAS,KAAK,MAAM,KAAK,QAAQ,YAAY;AAAA,EACvD,OAAO;AACL,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AACF;;;AIfO,IAAM,qBAAqB,CAEhC,QAEA,WACQ;AACR,QAAM,WAAW,CAAC,GAAG,IAAI,WAAW,MAAM,CAAC,EAAE,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC9F,SAAO,iBAAiB,UAAU,MAAM;AAC1C;;;ACRO,IAAM,gBAAgB,CAE3B,OAEA,SAAoB,CAAC,MACb;AACR,QAAM,WAAW,MAAM,SAAS,EAAE;AAClC,SAAO,iBAAiB,UAAU,MAAM;AAC1C;;;ACTO,IAAM,gBAAgB,CAAC,OAAe,WAA4B;AACvE,SAAO,cAAc,OAAO,KAAK,GAAG,MAAM;AAC5C;;;ACEO,IAAM,UAAU,CAErB,OAEA,WACQ;AACR,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,aAAO,iBAAiB,OAAO,MAAM;AAAA,IACvC;AAAA,IACA,KAAK,UAAU;AACb,aAAO,cAAc,OAAO,MAAM;AAAA,IACpC;AAAA,IACA,KAAK,UAAU;AACb,aAAO,cAAc,OAAO,MAAM;AAAA,IACpC;AAAA,IACA,KAAK,UAAU;AACb,aAAO,mBAAmB,OAAO,MAAM;AAAA,IACzC;AAAA,IACA,SAAS;AACP,YAAM,IAAI,MAAM,iBAAiB,OAAO,KAAK,EAAE;AAAA,IACjD;AAAA,EACF;AACF;;;ACtBO,SAAS,MAAM,OAAgB,QAAwC;AAC5E,MAAI,cAAkC;AAEtC,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,oBAAc,iBAAiB,KAAK;AACpC;AAAA,IACF;AAAA,IACA,SAAS;AACP,aAAO,YAAY,OAAO,QAAQ,qBAAqB,OAAO,KAAK,GAAG;AAAA,IACxE;AAAA,EACF;AAEA,SAAO,MAAM,WAAW,IAAI,cAAc,YAAY,OAAO,QAAQ,qBAAqB,KAAK,GAAG;AACpG;;;ACtBA,SAAS,YAAAC,iBAAgB;AAIlB,IAAM,YAAY,CAAC,UAAmB;AAC3C,SAAOC,UAAS,KAAK,IAAI,OAAO,iBAAiB,OAAO,EAAE,QAAQ,KAAK,CAAC,CAAC,MAAM,KAAK;AACtF;;;ACNO,IAAM,cAAc,CAAC,WAAwB;AAClD,SAAO,CAAC,GAAG,IAAI,WAAW,MAAM,CAAC,EAAE,IAAI,OAAK,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AACtF;;;ACFA,OAAO,OAAO;AAQP,IAAM,SAAS,EAAE,OAAO,EAC5B,MAAM,UAAU,EAAE,SAAS,qBAAqB,CAAC,EAAE,UAAU,OAAK,CAAQ;;;ACLtE,IAAM,QAAQ,CAEnB,OAEA,SAAoB,CAAC,MAClB;AACH,QAAM,EAAE,SAAS,MAAM,IAAI;AAC3B,SAAO,QAAQ,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC;AAC7C;;;AdAO,IAAM,eAAe,eAAe,IAAI,EAAE;AAE1C,IAAM,qBAAqBC,GAAE,OAAO,EAAE,MAAM,YAAY;AAGxD,IAAM,wBAAwB;AAE9B,IAAM,uBAAuBA,GAAE,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,EAAE,UAAU,OAAK,UAAU,CAAC,CAAC;AAGrG,IAAM,0BAA0B;AAEhC,IAAM,eAAe;AACrB,IAAM,iBAAiB;AAEvB,IAAM,YAAY,CAAC,OAAmD,SAAoB,CAAC,MAAe;AAC/G,QAAM,EAAE,YAAY,KAAK,SAAS,MAAM,IAAI;AAC5C,SAAO,QAAQ,OAAO;AAAA,IACpB;AAAA,IAAW;AAAA,IAAQ,GAAG;AAAA,EACxB,CAAC;AACH;AAEO,IAAM,YAAY,CAAC,OAAgB,SAAoB,CAAC,MAAwB;AACrF,QAAM,EAAE,YAAY,KAAK,SAAS,MAAM,IAAI;AAC5C,SAAO,MAAM,OAAO,EAAE,WAAW,OAAO,CAAC;AAC3C;AAIO,SAAS,UAAU,OAAgB,QAA4C;AACpF,MAAI;AACF,QAAI,cAAkC;AAEtC,YAAQ,OAAO,OAAO;AAAA,MACpB,KAAK,UAAU;AACb,sBAAc,iBAAiB,OAAO,EAAE,QAAQ,MAAM,CAAC;AACvD;AAAA,MACF;AAAA,MACA,SAAS;AACP,eAAO,SAAS,MAAM,IAAI,YAAY,OAAO,QAAQ,qBAAqB,OAAO,KAAK,GAAG,IAAI;AAAA,MAC/F;AAAA,IACF;AACA,WAAO,UAAU,WAAW,IAAI,cAAc,YAAY,OAAO,QAAQ,4BAA4B,KAAK,GAAG;AAAA,EAC/G,SAAS,IAAI;AACX,UAAM,QAAQ;AACd,WAAO,YAAY,QAAW,QAAQ,MAAM,OAAO;AAAA,EACrD;AACF;;;Ae3DA,OAAOC,QAAO;;;ACAd,OAAOC,QAAO;AAMP,IAAM,uBAAuBC,GAAE,OAAO,EAC1C,OAAO,OAAK,OAAO,UAAU,CAAC,CAAC,EAC/B,OAAO,OAAK,EAAE,WAAW,gBAAgB,EAAE,OAAO,OAAK,IAAI,MAAM,oCAAoC,EAAE,KAAK,GAAG,EAAE,CAAC,EAClH,UAAU,OAAK,CAAY;;;ADJvB,IAAM,sBAAsBC,GAAE,MAAM,CAACA,GAAE,OAAO,GAAGA,GAAE,OAAO,CAAC,CAAC,EAChE,UAAU,CAAC,UAAU;AACpB,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,MAAM,SAAS,EAAE,EAAE,SAAS,IAAI,GAAG;AAAA,EAC5C;AACA,MAAI,MAAM,WAAW,IAAI,GAAG;AAC1B,WAAO,MAAM,MAAM,CAAC;AAAA,EACtB;AACA,SAAO;AACT,CAAC,EACA,OAAO,OAAK,qBAAqB,UAAU,CAAC,EAAE,IAAI,EAClD,UAAU,OAAK,CAAY;;;AERvB,IAAU;AAAA,CAAV,CAAUC,aAAV;AACE,EAAMA,SAAA,WAAW,CAAC,UAAqC,qBAAqB,UAAU,KAAK,EAAE;AAC7F,EAAMA,SAAA,OAAO,CAAC,OAAgB,SAAkB,UAA+B,SAClF,qBAAqB,MAAM,KAAK,IAChC,qBAAqB,UAAU,KAAK,EAAE;AACnC,EAAMA,SAAA,OAAO,CAAC,OAAgB,SAAkB,UAA+B,SAClF,oBAAoB,MAAM,KAAK,IAC/B,oBAAoB,UAAU,KAAK,EAAE;AAClC,EAAMA,SAAA,WAAW,CAAC,UAA2B;AAAA,GARrC;;;ACRjB,OAAOC,QAAO;AAWP,IAAM,kBAAkB,kCAAkC,IAAI,EAAE;AAEhE,IAAM,2BAA2BC,GAAE,OAAO,EAAE,MAAM,eAAe;AACjE,IAAM,6BAA6BA,GAAE,OAAO,EAAE,MAAM,eAAe,EAAE,UAAU,OAAK,aAAa,CAAC,CAAC;AAKnG,IAAM,mBAAmB;AAEzB,IAAM,eAAe,CAAC,OAAmD,SAAoB,CAAC,MAAkB;AACrH,QAAM,EAAE,YAAY,KAAK,SAAS,MAAM,IAAI;AAC5C,SAAO,KAAK,QAAQ,OAAO;AAAA,IACzB;AAAA,IAAW;AAAA,IAAQ,GAAG;AAAA,EACxB,CAAC,CAAC;AACJ;AAEO,IAAM,eAAe,CAAC,OAAgB,SAAoB,CAAC,MAA2B;AAC3F,QAAM,EAAE,YAAY,KAAK,SAAS,KAAK,IAAI;AAC3C,SAAO,MAAM,OAAO,EAAE,WAAW,OAAO,CAAC;AAC3C;AAEO,IAAM,gBAAgBA,GAAE,OAAO,EACnC,MAAM,iBAAiB,EAAE,SAAS,yBAAyB,CAAC,EAC5D;AAAA,EACC;AACF;AAIK,SAAS,aAAa,OAAgB,QAA+C;AAC1F,MAAI;AACF,QAAI,cAAkC;AAEtC,YAAQ,OAAO,OAAO;AAAA,MACpB,KAAK,UAAU;AACb,sBAAc,iBAAiB,OAAO,EAAE,QAAQ,KAAK,CAAC;AACtD;AAAA,MACF;AAAA,MACA,SAAS;AACP,YAAI,UAAU,QAAW;AACvB,iBAAO,YAAY,OAAO,QAAQ,qBAAqB,OAAO,KAAK,GAAG;AAAA,QACxE;AAAA,MACF;AAAA,IACF;AACA,WAAO,aAAa,WAAW,IAAI,cAAc,YAAY,OAAO,QAAQ,+BAA+B,KAAK,GAAG;AAAA,EACrH,SAAS,IAAI;AACX,UAAM,QAAQ;AACd,WAAO,YAAY,QAAW,QAAQ,MAAM,OAAO;AAAA,EACrD;AACF;;;AC7DA,SAAS,eAAAC,oBAAmB;AAC5B,OAAOC,QAAO;AASP,IAAM,YAAY,eAAe,IAAI,EAAE;AAEvC,IAAM,YAAY;AAGlB,IAAM,gBAAiC,CAAC,IAAI,IAAI,KAAK,KAAK,KAAK,MAAM,MAAM,IAAI;AAE/E,IAAM,kBAAkB,CAAC,UAA2C;AACzE,SAAO,OAAO,UAAU,YAAY,cAAc,SAAS,KAAsB;AACnF;AAKO,IAAM,SAAS,CAAC,OAAgB,YAA2B,QAAuB;AACvF,SAAO,MAAM,OAAO,EAAE,UAAU,CAAC;AACnC;AAEO,IAAM,UAAUC,GAAE,OAAO,EAC7B,YAAY,EACZ,MAAM,WAAW,EAAE,SAAS,sBAAsB,CAAC,EACnD;AAAA,EACC;AACF;AAIK,SAAS,OAAO,OAAgB,QAAyC;AAC9E,MAAI,cAAkC;AAEtC,UAAQ,OAAO,OAAO;AAAA,IACpB,KAAK,UAAU;AACb,oBAAc,iBAAiB,KAAK;AACpC;AAAA,IACF;AAAA,IACA,SAAS;AACP,aAAOC,aAAY,MAAM,IAAI,SAAY,YAAY,OAAO,QAAQ,qBAAqB,OAAO,KAAK,GAAG;AAAA,IAC1G;AAAA,EACF;AACA,SAAO,OAAO,WAAW,IAAI,cAAc,YAAY,OAAO,QAAQ,wBAAwB,KAAK,GAAG;AACxG;;;AChDO,SAAS,YAAY,KAAkB;AAC5C,SAAO,OAAO,iBAAiB,KAAK,EAAE,QAAQ,KAAK,CAAC,CAAC;AACvD;","names":["z","isString","isString","z","z","z","z","z","Address","z","z","isUndefined","z","z","isUndefined"]}
+{"version":3,"sources":["../../src/address/address.ts","../../src/assert.ts","../../src/hex/from/fromHexString.ts","../../src/HexRegEx.ts","../../src/hex/nibble.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/hex/to.ts","../../src/address/AddressZodTransform.ts","../../src/address/AddressZodValidation.ts","../../src/ethAddress.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 '../HexRegEx.ts'\nimport { AddressZodTransform } from './AddressZodTransform.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Address = Hex & {\n  readonly __address: true\n}\n\nexport const AddressRegEx = HexRegExMinMax(20, 20)\n\nexport const AddressToStringZod = z.string().regex(AddressRegEx)\n\n/** @deprecated use AddressToStringZod */\nexport const AddressToStringSchema = AddressToStringZod\n\nexport const AddressFromStringZod = z.string().toLowerCase().regex(AddressRegEx).transform(v => toAddress(v))\n\n/** @deprecated use AddressFromStringZod */\nexport const AddressFromStringSchema = AddressFromStringZod\n\nexport const ZERO_ADDRESS = '0000000000000000000000000000000000000000' as Address\nexport const ADDRESS_LENGTH = 40 as const\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 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\n/** @alpha */\nexport function isAddressV2(value: unknown): value is Address {\n  return AddressZodValidation.safeParse(value).success\n}\n\n/** @alpha */\nexport function asAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressZodValidation.parse(value)\n    : AddressZodValidation.safeParse(value).data\n}\n\n/** @alpha */\nexport function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {\n  return assert\n    ? AddressZodTransform.parse(value)\n    : AddressZodTransform.safeParse(value).data\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","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\nexport const HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes: number = (Number.MAX_SAFE_INTEGER / 2)) => {\n  return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`)\n}\n\nexport const HexRegEx = /^[0-9a-f]+$/\nexport const HexRegExWithPrefix = /^0x[0-9a-f]+$/\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","import { HexRegEx, HexRegExWithPrefix } from '../HexRegEx.ts'\nimport type { Hex, HexConfig } from './model.ts'\nimport { bitsToNibbles } from './nibble.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 type { Brand } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport { HexRegEx } from '../HexRegEx.ts'\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hex = Brand<Lowercase<string>, { readonly __hex: true }>\n\nexport const HexZod = z.string()\n  .regex(HexRegEx, { message: 'Invalid hex format' }).transform(x => x as Hex)\n\n/** Configuration of validation and output format */\nexport interface HexConfig {\n  bitLength?: number\n  byteSize?: number\n  prefix?: boolean\n}\n\nexport type HexZodType = z.infer<typeof HexZod>\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 z from 'zod'\n\nimport type { Address } from './address.ts'\nimport { AddressZodValidation } from './AddressZodValidation.ts'\n\nexport const AddressZodTransform = z.union([z.string(), z.bigint()])\n  .transform((value) => {\n    if (typeof value === 'bigint') {\n      return value.toString(16).padStart(40, '0')\n    }\n    if (value.startsWith('0x')) {\n      return value.slice(2)\n    }\n    return value\n  })\n  .refine(x => AddressZodValidation.safeParse(x).data)\n  .transform(x => x as Address)\n\nexport type AddressZodTransformType = z.infer<typeof AddressZodTransform>\n","import z from 'zod'\n\nimport { HexZod } from '../hex/index.ts'\nimport type { Address } from './address.ts'\nimport { ADDRESS_LENGTH } from './address.ts'\n\nexport const AddressZodValidation = z.string()\n  .refine(x => HexZod.safeParse(x))\n  .refine(x => x.length === ADDRESS_LENGTH, { error: e => new Error(`Address must have 40 characters [${e.input}]`) })\n  .transform(v => v as Address)\n\nexport type AddressZodValidationType = z.infer<typeof AddressZodValidation>\n","import type { Brand } from '@xylabs/typeof'\nimport z from 'zod'\n\nimport type { AssertConfig } from './assert.ts'\nimport { assertError } from './assert.ts'\nimport type { HexConfig } from './hex/index.ts'\nimport {\n  hexFrom, hexFromHexString, isHex,\n} from './hex/index.ts'\nimport { HexRegExMinMaxMixedCaseWithPrefix } from './HexRegEx.ts'\n\nexport const EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20)\n\nexport const EthAddressToStringSchema = z.string().regex(EthAddressRegEx)\nexport const EthAddressFromStringSchema = z.string().regex(EthAddressRegEx).transform(v => toEthAddress(v))\n\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type EthAddress = Brand<string, { readonly __eth_address: true }>\n\nexport const ETH_ZERO_ADDRESS = '0x0000000000000000000000000000000000000000' as EthAddress\n\nexport const toEthAddress = (value: string | number | bigint | ArrayBufferLike, config: HexConfig = {}): EthAddress => {\n  const { bitLength = 160, prefix = false } = config\n  return `0x${hexFrom(value, {\n    bitLength, prefix, ...config,\n  })}` as EthAddress\n}\n\nexport const isEthAddress = (value: unknown, config: HexConfig = {}): value is EthAddress => {\n  const { bitLength = 160, prefix = true } = config\n  return isHex(value, { bitLength, prefix })\n}\n\nexport const EthAddressZod = z.string()\n  .regex(EthAddressRegEx, { message: 'Invalid address format' })\n  .refine(\n    isEthAddress,\n  )\n\nexport function asEthAddress(value: unknown): EthAddress | undefined\nexport function asEthAddress(value: unknown, assert: AssertConfig): EthAddress\nexport function asEthAddress(value: unknown, assert?: AssertConfig): EthAddress | undefined {\n  try {\n    let stringValue: string | undefined = undefined\n\n    switch (typeof value) {\n      case 'string': {\n        stringValue = hexFromHexString(value, { prefix: true })\n        break\n      }\n      default: {\n        if (value !== undefined) {\n          return assertError(value, assert, `Unsupported type [${typeof value}]`)\n        }\n      }\n    }\n    return isEthAddress(stringValue) ? stringValue : assertError(value, assert, `Value is not an EthAddress [${value}]`)\n  } catch (ex) {\n    const error = ex as Error\n    return assertError(undefined, assert, error.message)\n  }\n}\n","import type { Brand } from '@xylabs/typeof'\nimport { 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 './HexRegEx.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\n// using true instead of unique symbol to avoid conflicts with other versions of library\nexport type Hash = Brand<Hex, { readonly __hash: true }>\n\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","z","z","z","z","z","z","isUndefined","z","z","isUndefined"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xylabs/hex",
-  "version": "5.0.1",
+  "version": "5.0.3",
   "description": "Base functionality used throughout XY Labs TypeScript/JavaScript libraries",
   "keywords": [
     "hex",
@@ -32,6 +32,11 @@
       "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
+    "./internal": {
+      "types": "./dist/neutral/index-internal.d.ts",
+      "source": "./src/index-internal.ts",
+      "default": "./dist/neutral/index-internal.mjs"
+    },
     "./package.json": "./package.json"
   },
   "module": "./dist/neutral/index.mjs",
@@ -42,14 +47,13 @@
     "src"
   ],
   "dependencies": {
-    "@xylabs/typeof": "~5.0.1",
-    "zod": "~4.0.14",
-    "zod-to-json-schema": "~3.24.6"
+    "@xylabs/typeof": "~5.0.3",
+    "zod": "~4.0.15"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "~7.0.3",
-    "@xylabs/tsconfig": "~7.0.3",
-    "@xylabs/vitest-extended": "~5.0.1",
+    "@xylabs/ts-scripts-yarn3": "~7.1.0",
+    "@xylabs/tsconfig": "~7.1.0",
+    "@xylabs/vitest-extended": "~5.0.3",
     "typescript": "~5.9.2",
     "vitest": "~3.2.4"
   },

package/src/Brand.ts

@@ -1 +1,4 @@
-export type Brand<T, B> = T & { [K in keyof B]: B[K] }
+import type { Brand as TypeOfBrand } from '@xylabs/typeof'
+
+/** @deprecated use from @xylabs/typeof instead */
+export type Brand<T, B> = TypeOfBrand<T, B>

package/src/address/AddressZodTransform.ts

@@ -1,6 +1,6 @@
 import z from 'zod'
 
-import type { Address } from './AddressNamespace.ts'
+import type { Address } from './address.ts'
 import { AddressZodValidation } from './AddressZodValidation.ts'
 
 export const AddressZodTransform = z.union([z.string(), z.bigint()])

package/src/address/AddressZodValidation.ts

@@ -1,8 +1,8 @@
 import z from 'zod'
 
 import { HexZod } from '../hex/index.ts'
+import type { Address } from './address.ts'
 import { ADDRESS_LENGTH } from './address.ts'
-import type { Address } from './AddressNamespace.ts'
 
 export const AddressZodValidation = z.string()
   .refine(x => HexZod.safeParse(x))

package/src/address/address.ts

@@ -3,12 +3,18 @@ import z from 'zod'
 
 import type { AssertConfig } from '../assert.ts'
 import { assertError } from '../assert.ts'
-import type { HexConfig } from '../hex/index.ts'
+import type { Hex, HexConfig } from '../hex/index.ts'
 import {
   hexFrom, hexFromHexString, isHex,
 } from '../hex/index.ts'
 import { HexRegExMinMax } from '../HexRegEx.ts'
-import type { Address } from './AddressNamespace.ts'
+import { AddressZodTransform } from './AddressZodTransform.ts'
+import { AddressZodValidation } from './AddressZodValidation.ts'
+
+// using true instead of unique symbol to avoid conflicts with other versions of library
+export type Address = Hex & {
+  readonly __address: true
+}
 
 export const AddressRegEx = HexRegExMinMax(20, 20)
 
@@ -58,3 +64,22 @@ export function asAddress(value: unknown, assert?: AssertConfig): Address | unde
     return assertError(undefined, assert, error.message)
   }
 }
+
+/** @alpha */
+export function isAddressV2(value: unknown): value is Address {
+  return AddressZodValidation.safeParse(value).success
+}
+
+/** @alpha */
+export function asAddressV2(value: unknown, assert: boolean = false): Address | undefined {
+  return assert
+    ? AddressZodValidation.parse(value)
+    : AddressZodValidation.safeParse(value).data
+}
+
+/** @alpha */
+export function toAddressV2(value: unknown, assert: boolean = false): Address | undefined {
+  return assert
+    ? AddressZodTransform.parse(value)
+    : AddressZodTransform.safeParse(value).data
+}

package/src/address/index.ts

@@ -1,4 +1,3 @@
 export * from './address.ts'
-export * from './AddressNamespace.ts'
 export * from './AddressZodTransform.ts'
 export * from './AddressZodValidation.ts'

package/src/ethAddress.ts

@@ -1,8 +1,8 @@
+import type { Brand } from '@xylabs/typeof'
 import z from 'zod'
 
 import type { AssertConfig } from './assert.ts'
 import { assertError } from './assert.ts'
-import type { Brand } from './Brand.ts'
 import type { HexConfig } from './hex/index.ts'
 import {
   hexFrom, hexFromHexString, isHex,

package/src/hash.ts

@@ -1,9 +1,9 @@
+import type { Brand } from '@xylabs/typeof'
 import { isUndefined } from '@xylabs/typeof'
 import z from 'zod'
 
 import type { AssertConfig } from './assert.ts'
 import { assertError } from './assert.ts'
-import type { Brand } from './Brand.ts'
 import type { Hex } from './hex/index.ts'
 import { hexFromHexString, isHex } from './hex/index.ts'
 import { HexRegExMinMax } from './HexRegEx.ts'

package/src/hex/model.ts

@@ -1,6 +1,6 @@
+import type { Brand } from '@xylabs/typeof'
 import z from 'zod'
 
-import type { Brand } from '../Brand.ts'
 import { HexRegEx } from '../HexRegEx.ts'
 
 // using true instead of unique symbol to avoid conflicts with other versions of library

package/src/index-internal.ts

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

package/src/index.ts

@@ -1,8 +1,2 @@
-export * from './address/index.ts'
-export * from './assert.ts'
 export * from './Brand.ts'
-export * from './ethAddress.ts'
-export * from './hash.ts'
-export * from './hex/index.ts'
-export * from './HexRegEx.ts'
-export * from './hexToBigInt.ts'
+export * from './index-internal.ts'

package/src/spec/address.spec.ts

@@ -5,7 +5,9 @@ import {
 } from 'vitest'
 
 import {
-  Address, asAddress, isAddress,
+  asAddress, asAddressV2, isAddress,
+  isAddressV2,
+  toAddressV2,
 } from '../address/index.ts'
 
 describe('address', () => {
@@ -28,34 +30,34 @@ describe('address', () => {
 
 describe('address [zod]', () => {
   test('identify', () => {
-    expect(Address.identify(true)).toBeFalse()
-    expect(Address.identify({})).toBeFalse()
-    expect(Address.identify('NotHex')).toBeFalse()
-    expect(Address.identify('deadbeef')).toBeFalse()
-    expect(Address.identify('0xdeadbeef')).toBeFalse()
-    expect(Address.identify('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBeTrue()
-    expect(Address.identify('0xdeadbeefdeadbeefdeadxxxxdeadbeefdeadbeef')).toBeFalse()
+    expect(isAddressV2(true)).toBeFalse()
+    expect(isAddressV2({})).toBeFalse()
+    expect(isAddressV2('NotHex')).toBeFalse()
+    expect(isAddressV2('deadbeef')).toBeFalse()
+    expect(isAddressV2('0xdeadbeef')).toBeFalse()
+    expect(isAddressV2('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBeTrue()
+    expect(isAddressV2('0xdeadbeefdeadbeefdeadxxxxdeadbeefdeadbeef')).toBeFalse()
   })
   test('cast', () => {
-    expect(Address.cast('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe(undefined)
-    expect(Address.cast('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
-    expect(Address.cast('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', false)).toBe(undefined)
-    expect(Address.cast('000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
-    expect(Address.cast('0x000000000000000000000000000000000000000a', false)).toBe(undefined)
+    expect(asAddressV2('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe(undefined)
+    expect(asAddressV2('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
+    expect(asAddressV2('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', false)).toBe(undefined)
+    expect(asAddressV2('000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
+    expect(asAddressV2('0x000000000000000000000000000000000000000a', false)).toBe(undefined)
   })
 
   test('from', () => {
-    expect(Address.from('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
-    expect(Address.from('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
-    expect(Address.from('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', true)).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
-    expect(Address.from('000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
-    expect(Address.from('0x000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
-    expect(Address.from(10n, true)).toBe('000000000000000000000000000000000000000a')
-    expect(Address.from(
+    expect(toAddressV2('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
+    expect(toAddressV2('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
+    expect(toAddressV2('0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef', true)).toBe('deadbeefdeadbeefdeadbeefdeadbeefdeadbeef')
+    expect(toAddressV2('000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
+    expect(toAddressV2('0x000000000000000000000000000000000000000a', true)).toBe('000000000000000000000000000000000000000a')
+    expect(toAddressV2(10n, true)).toBe('000000000000000000000000000000000000000a')
+    expect(toAddressV2(
       1_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890n,
       false,
     )).toBe(undefined)
-    expect(Address.from(
+    expect(toAddressV2(
       1_234_567_890_123_456_789_012_345_678_901_234_567n,
       true,
     )).toBe('0000000000edc4e57e669eb52d3a8e6e7c9f4b87')
@@ -63,7 +65,7 @@ describe('address [zod]', () => {
 
   test('from [assert]', () => {
     try {
-      Address.from(
+      toAddressV2(
         1_234_567_890_123_456_789_012_345_678_901_234_567_890_123_456_789_012_345_678_901_234_567_890n,
         true,
       )

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

@@ -1,11 +0,0 @@
-import type { Hex } from '../hex/index.ts';
-export type Address = Hex & {
-    readonly __address: true;
-};
-export declare namespace Address {
-    const identify: (value: unknown) => value is Address;
-    const cast: (value: unknown, assert?: boolean) => Address | undefined;
-    const from: (value: unknown, assert?: boolean) => Address | undefined;
-    const toString: (value: Address) => string;
-}
-//# sourceMappingURL=AddressNamespace.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"AddressNamespace.d.ts","sourceRoot":"","sources":["../../../src/address/AddressNamespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AAK1C,MAAM,MAAM,OAAO,GAAG,GAAG,GAAG;IAAE,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAA;CAAE,CAAA;AAGxD,yBAAiB,OAAO,CAAC;IAChB,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,OAAwD,CAAA;IACpG,MAAM,IAAI,GAAI,OAAO,OAAO,EAAE,SAAQ,OAAe,KAAG,OAAO,GAAG,SAE3B,CAAA;IACvC,MAAM,IAAI,GAAI,OAAO,OAAO,EAAE,SAAQ,OAAe,KAAG,OAAO,GAAG,SAE5B,CAAA;IACtC,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,MAAyB,CAAA;CACpE"}

package/src/address/AddressNamespace.ts

@@ -1,18 +0,0 @@
-import type { Hex } from '../hex/index.ts'
-import { AddressZodTransform } from './AddressZodTransform.ts'
-import { AddressZodValidation } from './AddressZodValidation.ts'
-
-// using true instead of unique symbol to avoid conflicts with other versions of library
-export type Address = Hex & { readonly __address: true }
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-export namespace Address {
-  export const identify = (value: unknown): value is Address => AddressZodValidation.safeParse(value).success
-  export const cast = (value: unknown, assert: boolean = false): Address | undefined => assert
-    ? AddressZodValidation.parse(value)
-    : AddressZodValidation.safeParse(value).data
-  export const from = (value: unknown, assert: boolean = false): Address | undefined => assert
-    ? AddressZodTransform.parse(value)
-    : AddressZodTransform.safeParse(value).data
-  export const toString = (value: Address): string => value as string
-}