@layerzerolabs/chain-utils 0.0.45 → 0.0.47

package/dist/index.cjs

@@ -1,26 +1,35 @@
 'use strict';
 
-var VPRYQZSC_cjs = require('./VPRYQZSC.cjs');
-var _223VIKVV_cjs = require('./223VIKVV.cjs');
-require('./YJF4D23A.cjs');
+var IVFVZYWG_cjs = require('./IVFVZYWG.cjs');
+var NOJYY7DN_cjs = require('./NOJYY7DN.cjs');
+var J6P5K7DC_cjs = require('./J6P5K7DC.cjs');
 
+// src/index.ts
+J6P5K7DC_cjs.init_cjs_shims();
 
-
-Object.defineProperty(exports, "formatTxHashByEncoding", {
+Object.defineProperty(exports, "AddressEncoding", {
+  enumerable: true,
+  get: function () { return IVFVZYWG_cjs.AddressEncoding; }
+});
+Object.defineProperty(exports, "addressParser", {
+  enumerable: true,
+  get: function () { return IVFVZYWG_cjs.addressParser; }
+});
+Object.defineProperty(exports, "base58AddressParser", {
   enumerable: true,
-  get: function () { return VPRYQZSC_cjs.formatTxHashByEncoding; }
+  get: function () { return IVFVZYWG_cjs.base58AddressParser; }
 });
-Object.defineProperty(exports, "getAddressAsBytes32", {
+Object.defineProperty(exports, "hexAddressParser", {
   enumerable: true,
-  get: function () { return VPRYQZSC_cjs.getAddressAsBytes32; }
+  get: function () { return IVFVZYWG_cjs.hexAddressParser; }
 });
-Object.defineProperty(exports, "getAddressAsBytes32HexString", {
+Object.defineProperty(exports, "tonAddressParser", {
   enumerable: true,
-  get: function () { return VPRYQZSC_cjs.getAddressAsBytes32HexString; }
+  get: function () { return IVFVZYWG_cjs.tonAddressParser; }
 });
 Object.defineProperty(exports, "getNetworkName", {
   enumerable: true,
-  get: function () { return _223VIKVV_cjs.getNetworkName; }
+  get: function () { return NOJYY7DN_cjs.getNetworkName; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}
+{"version":3,"sources":["../src/index.ts"],"names":["init_cjs_shims"],"mappings":";;;;;;;AAAAA,2BAAA,EAAA","file":"index.cjs","sourcesContent":["export * from './addressParser';\nexport * from './utils';\n"]}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from './addresses';
+export * from './addressParser';
 export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -1,5 +1,8 @@
-export { formatTxHashByEncoding, getAddressAsBytes32, getAddressAsBytes32HexString } from './WF3JPRDE.js';
-export { getNetworkName } from './UXYWZBHJ.js';
-import './VUOMXK5T.js';
+export { AddressEncoding, addressParser, base58AddressParser, hexAddressParser, tonAddressParser } from './IUWKW475.js';
+export { getNetworkName } from './FJIAQ3QL.js';
+import { init_esm_shims } from './YXE7PREU.js';
+
+// src/index.ts
+init_esm_shims();
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;AAAA,cAAA,EAAA","file":"index.js","sourcesContent":["export * from './addressParser';\nexport * from './utils';\n"]}

package/dist/utils.cjs

@@ -1,13 +1,13 @@
 'use strict';
 
-var _223VIKVV_cjs = require('./223VIKVV.cjs');
-require('./YJF4D23A.cjs');
+var NOJYY7DN_cjs = require('./NOJYY7DN.cjs');
+require('./J6P5K7DC.cjs');
 
 
 
 Object.defineProperty(exports, "getNetworkName", {
   enumerable: true,
-  get: function () { return _223VIKVV_cjs.getNetworkName; }
+  get: function () { return NOJYY7DN_cjs.getNetworkName; }
 });
 //# sourceMappingURL=utils.cjs.map
 //# sourceMappingURL=utils.cjs.map

package/dist/utils.js

@@ -1,4 +1,4 @@
-export { getNetworkName } from './UXYWZBHJ.js';
-import './VUOMXK5T.js';
+export { getNetworkName } from './FJIAQ3QL.js';
+import './YXE7PREU.js';
 //# sourceMappingURL=utils.js.map
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/chain-utils",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -14,17 +14,19 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@noble/hashes": "^1.1.5",
     "bs58": "^5.0.0",
-    "viem": "2.28.0",
-    "@layerzerolabs/common-chain-model": "0.0.45",
-    "@layerzerolabs/common-utils": "0.0.45"
+    "@layerzerolabs/common-chain-model": "0.0.47",
+    "@layerzerolabs/common-ton": "0.0.47",
+    "@layerzerolabs/layerzero-definitions": "0.0.47",
+    "@layerzerolabs/common-utils": "0.0.47",
+    "@layerzerolabs/static-chain-info": "0.0.47"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.0.45",
-    "@layerzerolabs/typescript-configuration": "0.0.45"
+    "@layerzerolabs/tsup-configuration": "0.0.47",
+    "@layerzerolabs/typescript-configuration": "0.0.47",
+    "@layerzerolabs/typescript-utils": "0.0.47"
   },
   "publishConfig": {
     "access": "restricted",

package/src/addressParser.test.ts

@@ -0,0 +1,269 @@
+import * as bs58 from 'bs58';
+import { describe, expect, it } from 'vitest';
+
+import type { NormalizedHexString } from '@layerzerolabs/common-chain-model';
+import { normalizeHex } from '@layerzerolabs/common-chain-model';
+import { bytesToHexPrefixed, hexToBytes, hexZeroPad } from '@layerzerolabs/common-utils';
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+
+import { addressParser } from './addressParser';
+
+// Test data generators
+const randomBytes = (length: number): Uint8Array => {
+    const bytes = new Uint8Array(length);
+    for (let i = 0; i < length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return bytes;
+};
+
+const randomHex = (byteLength: number): NormalizedHexString => {
+    return normalizeHex(bytesToHexPrefixed(randomBytes(byteLength)));
+};
+
+const runPropertyTest = <T>(fn: () => T, iterations = 100): void => {
+    for (let i = 0; i < iterations; i++) {
+        fn();
+    }
+};
+
+describe('addressParser - hex/EVM chains', () => {
+    const evmChains = [ChainName.ETHEREUM, ChainName.AVALANCHE, ChainName.BSC, ChainName.POLYGON];
+
+    evmChains.forEach((chain) => {
+        describe(chain, () => {
+            const parser = addressParser(chain);
+
+            it('maintains roundtrip invariant: hex -> native -> hex', () => {
+                runPropertyTest(() => {
+                    const input = randomHex(20);
+                    const native = parser.normalizedToNative(input);
+                    const back = parser.nativeToNormalized(native);
+                    expect(back).toBe(input);
+                });
+            });
+
+            it('maintains byte representation consistency', () => {
+                runPropertyTest(() => {
+                    const input = randomHex(20);
+                    const nativeStr = parser.normalizedToNativeString(input);
+                    const bytesFromHex = hexToBytes(nativeStr);
+                    const nativeBytes = parser.nativeToBytes(nativeStr);
+
+                    expect(nativeBytes).toEqual(bytesFromHex);
+                });
+            });
+
+            it('correctly pads addresses', () => {
+                runPropertyTest(() => {
+                    const byteLength = Math.floor(Math.random() * 20) + 1; // 1-20 bytes
+                    const input = randomHex(byteLength);
+                    const native = parser.normalizedToNative(input);
+                    expect(native.nativeAddress.length).toBe(42); // Always 20 bytes padded
+                    expect(native.chainName).toBe(chain);
+                });
+            });
+        });
+    });
+
+    it('normalizedToBytes32Hex pads correctly', () => {
+        runPropertyTest(() => {
+            const byteLength = Math.floor(Math.random() * 32) + 1; // 1-32 bytes
+            const input = randomHex(byteLength);
+            const padded = addressParser.normalizedToBytes32Hex(input);
+            expect(padded.length).toBe(66); // 32 bytes -> 64 hex chars + 0x
+            expect(padded).toBe(hexZeroPad(input as any, 32));
+        });
+    });
+
+    it('handles edge cases', () => {
+        const parser = addressParser(ChainName.ETHEREUM);
+
+        // Empty address
+        const empty = normalizeHex('0x');
+        expect(parser.normalizedToNative(empty).nativeAddress.length).toBe(42);
+
+        // Maximum value
+        const max = normalizeHex(('0x' + 'ff'.repeat(20)) as any);
+        expect(parser.nativeToNormalized(parser.normalizedToNative(max))).toBe(max);
+
+        // Single byte
+        const single = normalizeHex('0x01');
+        expect(parser.normalizedToNative(single).nativeAddress).toBe(hexZeroPad('0x01', 20));
+    });
+});
+
+describe('addressParser - base58 chains (Solana)', () => {
+    const parser = addressParser(ChainName.SOLANA);
+
+    it('maintains roundtrip invariant: hex -> base58 -> hex', () => {
+        runPropertyTest(() => {
+            const byteLength = Math.floor(Math.random() * 32) + 1; // 1-32 bytes
+            const input = randomHex(byteLength);
+            const native = parser.normalizedToNative(input);
+            const back = parser.nativeToNormalized(native);
+            expect(back).toBe(input);
+        });
+    });
+
+    it('maintains base58 encoding consistency', () => {
+        runPropertyTest(() => {
+            const input = randomHex(32);
+            const nativeStr = parser.normalizedToNativeString(input);
+            const expectedBase58 = bs58.encode(hexToBytes(input as any));
+            expect(nativeStr).toBe(expectedBase58);
+
+            // Verify bytes consistency
+            const nativeBytes = parser.nativeToBytes(nativeStr);
+            expect(nativeBytes).toEqual(bs58.decode(expectedBase58));
+        });
+    });
+
+    it('correctly handles 32-byte padding', () => {
+        runPropertyTest(() => {
+            const byteLength = Math.floor(Math.random() * 32) + 1;
+            const input = randomHex(byteLength);
+            const native = parser.normalizedToNativeString(input);
+            const padded = parser.nativeToBytes32Hex(native);
+            expect(padded.length).toBe(66);
+
+            // Verify padding preserves original value
+            expect(parser.nativeToNormalized(native)).toBe(
+                normalizeHex(bytesToHexPrefixed(hexToBytes(input as any))),
+            );
+        });
+    });
+
+    it('handles edge cases', () => {
+        // Single byte
+        const single = normalizeHex('0x01');
+        const singleNative = parser.normalizedToNative(single);
+        expect(parser.nativeToNormalized(singleNative)).toBe(single);
+
+        // Empty (though typically invalid for Solana)
+        const empty = normalizeHex('0x');
+        expect(() => parser.normalizedToNative(empty)).not.toThrow();
+
+        // 32 bytes (typical Solana address length)
+        const full32 = randomHex(32);
+        const native32 = parser.normalizedToNative(full32);
+        expect(parser.nativeToNormalized(native32)).toBe(full32);
+    });
+});
+
+describe('addressParser - chain validation', () => {
+    it('validates chain names for nativeToBytes32Hex', () => {
+        const evmParser = addressParser(ChainName.ETHEREUM);
+        const solanaParser = addressParser(ChainName.SOLANA);
+
+        const evmAddress = evmParser.normalizedToNative(randomHex(20));
+        const solanaAddress = solanaParser.normalizedToNative(randomHex(32));
+
+        // nativeTo32BytesHex validates chain names for NativeAddress objects
+        expect(() => solanaParser.nativeToBytes32Hex(evmAddress as any)).toThrow(/Cannot convert/);
+        expect(() => evmParser.nativeToBytes32Hex(solanaAddress as any)).toThrow(/Cannot convert/);
+    });
+
+    it('accepts string addresses without validation', () => {
+        const parser = addressParser(ChainName.ETHEREUM);
+        const randomAddress = '0x' + 'ab'.repeat(20);
+
+        // String addresses bypass chain validation for all methods
+        const result = parser.nativeToNormalized(randomAddress as any);
+        expect(result).toBe(normalizeHex(randomAddress as any));
+
+        const padded = parser.nativeToBytes32Hex(randomAddress as any);
+        expect(padded.length).toBe(66);
+
+        const bytes = parser.nativeToBytes(randomAddress as any);
+        expect(bytes).toEqual(hexToBytes(randomAddress));
+    });
+});
+
+describe('addressParser - TON', () => {
+    const parser = addressParser(ChainName.TON);
+
+    it('maintains roundtrip invariant: hex -> ton address -> hex', () => {
+        runPropertyTest(() => {
+            // TON addresses are typically 32 bytes (256 bits)
+            const byteLength = Math.floor(Math.random() * 32) + 1;
+            const input = randomHex(byteLength);
+            const native = parser.normalizedToNative(input);
+            const back = parser.nativeToNormalized(native);
+
+            expect(input).toBe(back);
+        });
+    });
+
+    it('correctly handles TON address format', () => {
+        runPropertyTest(() => {
+            const input = randomHex(32);
+            const native = parser.normalizedToNative(input);
+
+            // TON addresses should have the correct chain name
+            expect(native.chainName).toBe(ChainName.TON);
+
+            // Should be a valid TON address string
+            expect(typeof native.nativeAddress).toBe('string');
+            expect(native.nativeAddress.length).toBeGreaterThan(0);
+        });
+    });
+
+    it('maintains byte representation consistency', () => {
+        runPropertyTest(() => {
+            const input = randomHex(32);
+            const nativeStr = parser.normalizedToNativeString(input);
+            const nativeBytes = parser.nativeToBytes(nativeStr);
+
+            // Both should produce valid byte arrays
+            expect(nativeBytes).toBeInstanceOf(Uint8Array);
+
+            // Converting back should preserve the value
+            const backFromBytes = parser.nativeToNormalized(parser.normalizedToNative(input));
+            expect(backFromBytes).toBe(input);
+        });
+    });
+
+    it('correctly handles 32-byte padding', () => {
+        runPropertyTest(() => {
+            const byteLength = Math.floor(Math.random() * 32) + 1;
+            const input = randomHex(byteLength);
+            const native = parser.normalizedToNativeString(input);
+            const padded = parser.nativeToBytes32Hex(native);
+
+            expect(padded.length).toBe(66); // 32 bytes -> 64 hex chars + 0x
+
+            // Verify the numeric value is preserved
+            const paddedBigInt = BigInt(padded);
+            const inputBigInt = BigInt(input as any);
+            expect(paddedBigInt).toBe(inputBigInt);
+        });
+    });
+
+    it('handles edge cases', () => {
+        // Zero address
+        const zero = normalizeHex('0x0');
+        const zeroNative = parser.normalizedToNative(zero);
+        expect(() => parser.nativeToNormalized(zeroNative)).not.toThrow();
+
+        // Large values
+        const large = normalizeHex(('0x' + 'ff'.repeat(32)) as any);
+        const largeNative = parser.normalizedToNative(large);
+        const largeBack = parser.nativeToNormalized(largeNative);
+        expect(BigInt(largeBack as any)).toBe(BigInt(large as any));
+
+        // Single byte
+        const single = normalizeHex('0x01');
+        const singleNative = parser.normalizedToNative(single);
+        const singleBack = parser.nativeToNormalized(singleNative);
+        expect(BigInt(singleBack as any)).toBe(1n);
+    });
+
+    it('validates native addresses', () => {
+        const validAddress = parser.normalizedToNative(randomHex(32));
+        expect(parser.validateNative(validAddress.nativeAddress)).toBe(true);
+
+        // Invalid addresses should return false
+        expect(parser.validateNative('invalid-ton-address')).toBe(false);
+    });
+});

package/src/addressParser.ts

@@ -0,0 +1,258 @@
+import bs58 from 'bs58';
+
+import type { HexString, NormalizedHexString } from '@layerzerolabs/common-chain-model';
+import { normalizeHex } from '@layerzerolabs/common-chain-model';
+import { addressToHex, bigintToAddress, parseTonAddress } from '@layerzerolabs/common-ton';
+import {
+    bytesToHexPrefixed,
+    hexToBytes,
+    hexZeroPad,
+    isBase58,
+    isHexString,
+} from '@layerzerolabs/common-utils';
+import type {
+    Base58String,
+    ChainsByEncoding,
+    NativeAddress,
+    ResolvedEncodingForChainName,
+    TonString,
+} from '@layerzerolabs/layerzero-definitions';
+import type { ChainNativeAddress } from '@layerzerolabs/layerzero-definitions';
+import { ChainName } from '@layerzerolabs/layerzero-definitions';
+import { StaticChainConfigs } from '@layerzerolabs/static-chain-info';
+
+type NativeOrString<T extends ChainName | `${ChainName}`> =
+    | ChainNativeAddress<T>
+    | ResolvedEncodingForChainName<T>;
+
+export enum AddressEncoding {
+    HEX = 'hex',
+    BASE58 = 'base58',
+    TON = 'ton',
+}
+
+export interface AddressParser<T extends ChainName | `${ChainName}`> {
+    normalizedToNative: (address: NormalizedHexString) => ChainNativeAddress<T>;
+    normalizedToNativeString: (address: NormalizedHexString) => ResolvedEncodingForChainName<T>;
+    nativeToNormalized: (nativeAddress: NativeOrString<T>) => NormalizedHexString;
+    nativeToBytes: (nativeAddress: NativeOrString<T>) => Uint8Array;
+    nativeToBytes32Hex: (nativeAddress: NativeOrString<T>) => HexString;
+    nativeToBytes32: (nativeAddress: NativeOrString<T>) => Uint8Array;
+    validateNative: (nativeAddress: string) => nativeAddress is ResolvedEncodingForChainName<T>;
+    /**
+     * Parse a native address to a string if it is valid.
+     * Throws an error if the native address is invalid.
+     * @param nativeAddress - The native address to parse.
+     * @returns The parsed native address.
+     */
+    parseNative: (nativeAddress: string) => NormalizedHexString;
+    parseNativeToHex: (nativeAddress: string) => HexString;
+    encoding: AddressEncoding;
+}
+
+export function addressParser<T extends ChainName | `${ChainName}`>(
+    chainName: T,
+): AddressParser<T> {
+    // FIXME: figure out a way to not have to cast here
+    if (chainName === ChainName.TON)
+        return tonAddressParser(chainName) as unknown as AddressParser<T>;
+    if (chainName === ChainName.SOLANA)
+        return base58AddressParser(chainName) as unknown as AddressParser<T>;
+    return hexAddressParser(chainName) as unknown as AddressParser<T>;
+}
+
+export namespace addressParser {
+    export const normalizedToBytes32Hex = (address: NormalizedHexString) => {
+        return hexZeroPad(address as unknown as HexString, 32);
+    };
+    export const normalizedToBytes32 = (address: NormalizedHexString) => {
+        return hexToBytes(normalizedToBytes32Hex(address));
+    };
+    export const normalizedToBigInt = (address: NormalizedHexString) => {
+        return BigInt(address as unknown as HexString);
+    };
+    export const parseNative = (nativeAddress: NativeAddress) => {
+        return addressParser(nativeAddress.chainName).parseNative(nativeAddress.nativeAddress);
+    };
+}
+
+const validateNative = <T extends ChainName | `${ChainName}`>(
+    nativeAddress: string,
+    expectedChainName: T,
+): nativeAddress is ResolvedEncodingForChainName<T> => {
+    if (!addressParser(expectedChainName).validateNative(nativeAddress)) {
+        throw new Error(
+            'Cannot convert: ' +
+                nativeAddress +
+                ' - The native address does not match the expected format for the chain: ' +
+                expectedChainName,
+        );
+    }
+    return true;
+};
+
+const getAddress = <T extends ChainName | `${ChainName}`>(nativeAddress: NativeOrString<T>) => {
+    return typeof nativeAddress === 'object' ? nativeAddress.nativeAddress : nativeAddress;
+};
+
+export const tonAddressParser: (
+    chainName: ChainsByEncoding[TonString],
+) => AddressParser<ChainsByEncoding[TonString]> = (chainName) => {
+    return {
+        validateNative: (nativeAddress): nativeAddress is TonString => {
+            try {
+                parseTonAddress(nativeAddress);
+                return true;
+            } catch {
+                return false;
+            }
+        },
+        normalizedToNative: (address) => {
+            const numericalValue = addressParser.normalizedToBigInt(address);
+            return {
+                nativeAddress: bigintToAddress(numericalValue).toString() as TonString,
+                chainName,
+            };
+        },
+        normalizedToNativeString: (address) => {
+            return addressParser(chainName).normalizedToNative(address).nativeAddress;
+        },
+        nativeToNormalized: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            return normalizeHex(addressToHex(address));
+        },
+        nativeToBytes32Hex: (nativeAddress) => {
+            // naturally ton is 32 bytes, pad it anyway
+            return hexZeroPad(
+                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,
+                32,
+            );
+        },
+        nativeToBytes: (nativeAddress) => {
+            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
+        },
+        nativeToBytes32: (nativeAddress) => {
+            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
+        },
+        parseNative: (nativeAddress) => {
+            if (!validateNative(nativeAddress, chainName)) {
+                throw new Error('Invalid native address: ' + nativeAddress);
+            }
+            return addressParser(chainName).nativeToNormalized(nativeAddress);
+        },
+        parseNativeToHex: (nativeAddress) => {
+            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
+        },
+        encoding: AddressEncoding.TON,
+    };
+};
+
+export const base58AddressParser = (
+    chainName: ChainsByEncoding[Base58String],
+): AddressParser<ChainsByEncoding[Base58String]> => {
+    return {
+        validateNative: (nativeAddress): nativeAddress is Base58String => {
+            return isBase58(nativeAddress);
+        },
+        normalizedToNative: (address) => {
+            return {
+                nativeAddress: bs58.encode(
+                    hexToBytes(address as unknown as HexString),
+                ) as Base58String,
+                chainName,
+            };
+        },
+        normalizedToNativeString: (address) => {
+            return addressParser(chainName).normalizedToNative(address).nativeAddress;
+        },
+        nativeToNormalized: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            const hex = bytesToHexPrefixed(bs58.decode(address));
+            return normalizeHex(hex);
+        },
+        nativeToBytes32Hex: (nativeAddress) => {
+            // naturally solana is 32 bytes, pad it anyway
+            return hexZeroPad(
+                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,
+                32,
+            );
+        },
+        nativeToBytes: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            return bs58.decode(address);
+        },
+        nativeToBytes32: (nativeAddress) => {
+            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
+        },
+        parseNative: (nativeAddress) => {
+            if (!validateNative(nativeAddress, chainName)) {
+                throw new Error('Invalid native address: ' + nativeAddress);
+            }
+            return addressParser(chainName).nativeToNormalized(nativeAddress);
+        },
+        parseNativeToHex: (nativeAddress) => {
+            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
+        },
+        encoding: AddressEncoding.BASE58,
+    };
+};
+
+export const hexAddressParser = (
+    chainName: ChainsByEncoding[HexString],
+): AddressParser<ChainsByEncoding[HexString]> => {
+    const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName as ChainName);
+
+    return {
+        validateNative: (nativeAddress): nativeAddress is HexString => {
+            return isHexString(nativeAddress);
+        },
+        normalizedToNative: (address) => {
+            return {
+                // we could have EIP-55 here, but omitted for now
+                nativeAddress: hexZeroPad(address as unknown as HexString, nativeByteLength),
+                chainName,
+            };
+        },
+        normalizedToNativeString: (address) => {
+            return hexZeroPad(address as unknown as HexString, nativeByteLength);
+        },
+        nativeToNormalized: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            return normalizeHex(address);
+        },
+        nativeToBytes: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            return hexToBytes(address);
+        },
+        nativeToBytes32Hex: (nativeAddress) => {
+            const address = getAddress(nativeAddress);
+            validateNative(address, chainName);
+            return hexZeroPad(address, 32);
+        },
+        nativeToBytes32: (nativeAddress) => {
+            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
+        },
+        parseNative: (nativeAddress) => {
+            // Specific case to make tron a little less flaky, handle the 41 prefix
+            if (chainName === ChainName.TRON) {
+                nativeAddress = nativeAddress.startsWith('41')
+                    ? `0x${nativeAddress.slice(2)}`
+                    : nativeAddress;
+            }
+
+            if (!validateNative(nativeAddress, chainName)) {
+                throw new Error('Invalid native address: ' + nativeAddress);
+            }
+            return addressParser(chainName).nativeToNormalized(nativeAddress);
+        },
+        parseNativeToHex: (nativeAddress) => {
+            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
+        },
+        encoding: AddressEncoding.HEX,
+    };
+};

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from './addresses';
+export * from './addressParser';
 export * from './utils';

package/dist/223VIKVV.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/utils.ts"],"names":["getNetworkName","__name","chainName","environment","includes"],"mappings":";;;;;AAAO,IAAMA,cAAAA,mBAAiBC,mBAAA,CAAA,CAACC,SAAAA,EAAmBC,WAAAA,KAAAA;AAC9C,EAAA,OAAO;AAAC,IAAA,UAAA;AAAY,IAAA;IAAWC,QAAAA,CAASD,WAAAA,IAClC,CAAA,EAAGD,SAAAA,mBACH,CAAA,EAAGA,SAAAA,IAAaC,WAAAA,CAAAA,CAAAA;AAC1B,CAAA,EAJ8B,gBAAA","file":"223VIKVV.cjs","sourcesContent":["export const getNetworkName = (chainName: string, environment: string) => {\n    return ['localnet', 'sandbox'].includes(environment)\n        ? `${chainName}-sandbox-local`\n        : `${chainName}-${environment}`;\n};\n"]}