@layerzerolabs/chain-utils 0.2.58 → 0.2.59

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var QNFJ2P5R_cjs = require('./QNFJ2P5R.cjs');
+var X46YPLVF_cjs = require('./X46YPLVF.cjs');
 var KHVGLVR5_cjs = require('./KHVGLVR5.cjs');
 
 // src/index.ts
@@ -8,35 +8,35 @@ KHVGLVR5_cjs.init_cjs_shims();
 
 Object.defineProperty(exports, "AddressEncoding", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.AddressEncoding; }
+  get: function () { return X46YPLVF_cjs.AddressEncoding; }
 });
 Object.defineProperty(exports, "addressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.addressParser; }
+  get: function () { return X46YPLVF_cjs.addressParser; }
 });
 Object.defineProperty(exports, "base58AddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.base58AddressParser; }
+  get: function () { return X46YPLVF_cjs.base58AddressParser; }
 });
 Object.defineProperty(exports, "hexAddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.hexAddressParser; }
+  get: function () { return X46YPLVF_cjs.hexAddressParser; }
 });
 Object.defineProperty(exports, "initiaAddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.initiaAddressParser; }
+  get: function () { return X46YPLVF_cjs.initiaAddressParser; }
 });
 Object.defineProperty(exports, "starknetAddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.starknetAddressParser; }
+  get: function () { return X46YPLVF_cjs.starknetAddressParser; }
 });
 Object.defineProperty(exports, "stellarAddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.stellarAddressParser; }
+  get: function () { return X46YPLVF_cjs.stellarAddressParser; }
 });
 Object.defineProperty(exports, "tonAddressParser", {
   enumerable: true,
-  get: function () { return QNFJ2P5R_cjs.tonAddressParser; }
+  get: function () { return X46YPLVF_cjs.tonAddressParser; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,4 +1,4 @@
-export { AddressEncoding, addressParser, base58AddressParser, hexAddressParser, initiaAddressParser, starknetAddressParser, stellarAddressParser, tonAddressParser } from './3457WEGJ.js';
+export { AddressEncoding, addressParser, base58AddressParser, hexAddressParser, initiaAddressParser, starknetAddressParser, stellarAddressParser, tonAddressParser } from './OVN7SCH2.js';
 import { init_esm_shims } from './CWKWODSW.js';
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/chain-utils",
-  "version": "0.2.58",
+  "version": "0.2.59",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -18,18 +18,18 @@
     "@stellar/stellar-sdk": "^14.1.1",
     "@ton/ton": "npm:@layerzerolabs/ton@15.1.0-rc.9",
     "bs58": "^5.0.0",
-    "@layerzerolabs/common-chain-model": "0.2.58",
-    "@layerzerolabs/common-encoding-utils": "0.2.58",
-    "@layerzerolabs/common-ton": "0.2.58",
-    "@layerzerolabs/layerzero-definitions": "0.2.58",
-    "@layerzerolabs/static-chain-info": "0.2.58"
+    "@layerzerolabs/common-chain-model": "0.2.59",
+    "@layerzerolabs/common-encoding-utils": "0.2.59",
+    "@layerzerolabs/layerzero-definitions": "0.2.59",
+    "@layerzerolabs/common-ton": "0.2.59",
+    "@layerzerolabs/static-chain-info": "0.2.59"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.58",
-    "@layerzerolabs/typescript-configuration": "0.2.58",
-    "@layerzerolabs/typescript-utils": "0.2.58"
+    "@layerzerolabs/tsup-configuration": "0.2.59",
+    "@layerzerolabs/typescript-utils": "0.2.59",
+    "@layerzerolabs/typescript-configuration": "0.2.59"
   },
   "publishConfig": {
     "access": "restricted",

package/src/addressParser.test.ts

@@ -1,8 +1,8 @@
 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 type { HexString, NormalizedHexString } from '@layerzerolabs/common-chain-model';
+import { NORMALIZED_HEX_ZERO, normalizeHex } from '@layerzerolabs/common-chain-model';
 import { bytesToHexPrefixed, hexToBytes, hexZeroPad } from '@layerzerolabs/common-encoding-utils';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 
@@ -70,7 +70,7 @@ describe('addressParser - hex/EVM chains', () => {
         runPropertyTest(() => {
             const byteLength = Math.floor(Math.random() * 32) + 1; // 1-32 bytes
             const input = randomHex(byteLength);
-            const padded = addressParser.normalizedToBytes32Hex(input);
+            const padded = addressParser(ChainName.ETHEREUM).normalizedToBytes32Hex(input);
             expect(padded.length).toBe(66); // 32 bytes -> 64 hex chars + 0x
             expect(padded).toBe(hexZeroPad(input as any, 32));
         });
@@ -551,6 +551,29 @@ describe('addressParser - Stellar', () => {
         });
     });
 
+    describe('normalizedToBytes32 operations', () => {
+        it('produces same result as nativeToBytes32Hex for contract address (C...)', () => {
+            const stellarAddress = validTestAddresses.contract;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+
+            const fromNative = parser.nativeToBytes32Hex(stellarAddress as any)!;
+            const fromNormalized = parser.normalizedToBytes32Hex(normalized)!;
+
+            expect(fromNormalized).toBe(fromNative);
+        });
+
+        it('normalizedToBytes32 returns correct Uint8Array', () => {
+            const stellarAddress = validTestAddresses.account;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+
+            const bytes32Hex = parser.normalizedToBytes32Hex(normalized)!;
+            const bytes32 = parser.normalizedToBytes32(normalized)!;
+
+            expect(bytes32.length).toBe(32);
+            expect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+        });
+    });
+
     describe('address type preservation', () => {
         it('preserves address type information through conversion', () => {
             const addresses = [
@@ -615,3 +638,158 @@ describe('addressParser - Stellar', () => {
         });
     });
 });
+
+describe('addressParser - normalizedToBytes32Hex (cross-chain)', () => {
+    const testCases: { name: string; chainName: ChainName; nativeAddr: string }[] = [
+        {
+            name: 'EVM (Ethereum)',
+            chainName: ChainName.ETHEREUM,
+            nativeAddr: '0x1234567890abcdef1234567890abcdef12345678',
+        },
+        {
+            name: 'Solana',
+            chainName: ChainName.SOLANA,
+            nativeAddr: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+        },
+        {
+            name: 'TON',
+            chainName: ChainName.TON,
+            nativeAddr: 'EQDtFpEwcFAEcRe5mLVh2N6C0x-_hJEM7W61_JLnSF74p4q2',
+        },
+        {
+            name: 'Stellar',
+            chainName: ChainName.STELLAR,
+            nativeAddr: 'GAAZI4TCR3TY5OJHCTJC2A4QSY6CJWJH5IAJTGKIN2ER7LBNVKOCCWN7',
+        },
+        {
+            name: 'Aptos',
+            chainName: ChainName.APTOS,
+            nativeAddr: '0x1',
+        },
+        {
+            name: 'Starknet',
+            chainName: ChainName.STARKNET,
+            nativeAddr: '0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7',
+        },
+        {
+            name: 'Initia',
+            chainName: ChainName.INITIA,
+            nativeAddr: '0x1',
+        },
+    ];
+
+    testCases.forEach(({ name, chainName, nativeAddr }) => {
+        it(`${name}: normalizedToBytes32Hex(normalized) === nativeToBytes32Hex(native)`, () => {
+            const p = addressParser(chainName);
+            const normalized = p.nativeToNormalized(nativeAddr as any);
+
+            const fromNormalized = p.normalizedToBytes32Hex(normalized)!;
+            const fromNative = p.nativeToBytes32Hex(nativeAddr as any)!;
+
+            expect(fromNormalized).toBe(fromNative);
+            expect(fromNormalized.length).toBe(66);
+            expect(fromNormalized).toMatch(/^0x[0-9a-f]{64}$/);
+        });
+    });
+
+    it('normalizedToBytes32Hex is consistent across chain parsers for ≤32 byte hex', () => {
+        const evmParser = addressParser(ChainName.ETHEREUM);
+        const solanaParser = addressParser(ChainName.SOLANA);
+        const normalized = normalizeHex('0x1234567890abcdef1234567890abcdef12345678');
+        expect(evmParser.normalizedToBytes32Hex(normalized)).toBe(
+            solanaParser.normalizedToBytes32Hex(normalized),
+        );
+    });
+
+    it('normalizedToBytes32 returns correct Uint8Array', () => {
+        const p = addressParser(ChainName.ETHEREUM);
+        const normalized = normalizeHex('0x1234567890abcdef1234567890abcdef12345678');
+        const bytes32Hex = p.normalizedToBytes32Hex(normalized)!;
+        const bytes32 = p.normalizedToBytes32(normalized)!;
+        expect(bytes32.length).toBe(32);
+        expect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+
+    it('returns undefined for undefined input', () => {
+        const p = addressParser(ChainName.ETHEREUM);
+        expect(p.normalizedToBytes32Hex(undefined as any)).toBeUndefined();
+        expect(p.normalizedToBytes32(undefined as any)).toBeUndefined();
+    });
+});
+
+describe('addressParser - bytes32ToNormalized', () => {
+    const ZERO_BYTES32 = ('0x' + '00'.repeat(32)) as HexString;
+
+    describe('round-trip: bytes32ToNormalized(nativeToBytes32Hex(native)) === nativeToNormalized(native)', () => {
+        const cases = [
+            {
+                name: 'EVM',
+                chainName: ChainName.ETHEREUM,
+                native: '0x1234567890abcdef1234567890abcdef12345678',
+            },
+            {
+                name: 'Solana',
+                chainName: ChainName.SOLANA,
+                native: 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB',
+            },
+            {
+                name: 'TON',
+                chainName: ChainName.TON,
+                native: 'EQDtFpEwcFAEcRe5mLVh2N6C0x-_hJEM7W61_JLnSF74p4q2',
+            },
+            { name: 'Initia', chainName: ChainName.INITIA, native: '0x1' },
+            {
+                name: 'Starknet',
+                chainName: ChainName.STARKNET,
+                native: '0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7',
+            },
+            { name: 'Aptos', chainName: ChainName.APTOS, native: '0x1' },
+        ];
+
+        cases.forEach(({ name, chainName, native }) => {
+            it(`${name}: round-trip`, () => {
+                const p = addressParser(chainName);
+                const normalized = p.nativeToNormalized(native as any);
+                const bytes32Hex = p.nativeToBytes32Hex(native as any)!;
+                expect(p.bytes32ToNormalized(bytes32Hex)).toBe(normalized);
+            });
+        });
+
+        it('Stellar contract: round-trip', () => {
+            const p = addressParser(ChainName.STELLAR);
+            const contractAddr = 'CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUWDA';
+            const normalized = p.nativeToNormalized(contractAddr as any);
+            const bytes32Hex = p.nativeToBytes32Hex(contractAddr as any)!;
+            expect(p.bytes32ToNormalized(bytes32Hex)).toBe(normalized);
+        });
+    });
+
+    it('undefined input returns undefined', () => {
+        const p = addressParser(ChainName.ETHEREUM);
+        expect(p.bytes32ToNormalized(undefined as any)).toBeUndefined();
+    });
+
+    it('non-Stellar: bytes32ToNative === normalizeHex for same input', () => {
+        const chains = [ChainName.ETHEREUM, ChainName.SOLANA, ChainName.TON, ChainName.STARKNET];
+        const bytes32 =
+            '0x0000000000000000000000001234567890abcdef1234567890abcdef12345678' as HexString;
+        chains.forEach((chainName) => {
+            expect(addressParser(chainName).bytes32ToNormalized(bytes32)).toBe(
+                normalizeHex(bytes32),
+            );
+        });
+    });
+
+    it('zero bytes32: EVM returns NORMALIZED_HEX_ZERO', () => {
+        const p = addressParser(ChainName.ETHEREUM);
+        expect(p.bytes32ToNormalized(ZERO_BYTES32)).toBe(NORMALIZED_HEX_ZERO);
+    });
+
+    it('zero bytes32: Stellar returns C-address for zero contract ID (not undefined)', () => {
+        const p = addressParser(ChainName.STELLAR);
+        const result = p.bytes32ToNormalized(ZERO_BYTES32);
+        // Should be a valid C-address string encoded as UTF-8 normalized hex, not undefined
+        expect(result).toBeDefined();
+        expect(result).not.toBe(NORMALIZED_HEX_ZERO);
+    });
+});

package/src/addressParser.ts

@@ -69,6 +69,15 @@ export type AddressParser<T extends ChainName> = {
     nativeToBytes32: <Address extends NativeOrString<T> | undefined>(
         nativeAddress: Address,
     ) => MaybeUndefinedMapped<Address, Uint8Array>;
+    normalizedToBytes32Hex: <Address extends NormalizedHexString | undefined>(
+        address: Address,
+    ) => MaybeUndefinedMapped<Address, HexString>;
+    normalizedToBytes32: <Address extends NormalizedHexString | undefined>(
+        address: Address,
+    ) => MaybeUndefinedMapped<Address, Uint8Array>;
+    bytes32ToNormalized: <B extends HexString | undefined>(
+        bytes32Hex: B,
+    ) => MaybeUndefinedMapped<B, NormalizedHexString>;
     validateNative: (
         nativeAddress: string | undefined,
     ) => nativeAddress is ResolvedEncodingForChainName<T>;
@@ -99,18 +108,10 @@ export function addressParser<T extends ChainName>(chainName: T): AddressParser<
 }
 
 export namespace addressParser {
-    export const normalizedToBytes32Hex = (address: NormalizedHexString) => {
-        return hexZeroPad(address as unknown as HexString, 32);
-    };
-
     export const normalizedToUnpaddedString = (address: NormalizedHexString) => {
         return address.toString() as HexString;
     };
 
-    export const normalizedToBytes32 = (address: NormalizedHexString) => {
-        return hexToBytes(normalizedToBytes32Hex(address));
-    };
-
     export const normalizedToBigInt = (address: NormalizedHexString) => {
         return BigInt(address as unknown as HexString);
     };
@@ -188,6 +189,18 @@ export const tonAddressParser: (
             if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
+        normalizedToBytes32Hex: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexZeroPad(address as unknown as HexString, 32);
+        },
+        normalizedToBytes32: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexToBytes(addressParser(chainName).normalizedToBytes32Hex(address));
+        },
+        bytes32ToNormalized: (bytes32Hex) => {
+            if (bytes32Hex === undefined) return undefined as any;
+            return normalizeHex(bytes32Hex);
+        },
         parseNative: (nativeAddress) => {
             assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
@@ -258,6 +271,18 @@ export const initiaAddressParser: (
             if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
+        normalizedToBytes32Hex: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexZeroPad(address as unknown as HexString, 32);
+        },
+        normalizedToBytes32: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexToBytes(addressParser(chainName).normalizedToBytes32Hex(address));
+        },
+        bytes32ToNormalized: (bytes32Hex) => {
+            if (bytes32Hex === undefined) return undefined as any;
+            return normalizeHex(bytes32Hex);
+        },
         parseNative: (nativeAddress) => {
             assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
@@ -315,6 +340,18 @@ export const base58AddressParser = (
             if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
+        normalizedToBytes32Hex: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexZeroPad(address as unknown as HexString, 32);
+        },
+        normalizedToBytes32: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexToBytes(addressParser(chainName).normalizedToBytes32Hex(address));
+        },
+        bytes32ToNormalized: (bytes32Hex) => {
+            if (bytes32Hex === undefined) return undefined as any;
+            return normalizeHex(bytes32Hex);
+        },
         parseNative: (nativeAddress) => {
             assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
@@ -372,6 +409,18 @@ export const hexAddressParser = (
             if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
+        normalizedToBytes32Hex: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexZeroPad(address as unknown as HexString, 32);
+        },
+        normalizedToBytes32: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexToBytes(addressParser(chainName).normalizedToBytes32Hex(address));
+        },
+        bytes32ToNormalized: (bytes32Hex) => {
+            if (bytes32Hex === undefined) return undefined as any;
+            return normalizeHex(bytes32Hex);
+        },
         parseNative: (nativeAddress) => {
             // Specific case to make tron a little less flaky, handle the 41 prefix
             if (chainName === ChainName.TRON && nativeAddress) {
@@ -390,6 +439,27 @@ export const hexAddressParser = (
     };
 };
 
+const BYTES32_HEX_LENGTH = 64;
+
+/**
+ * If the input is a 0x-prefixed bytes32 hex string (raw contract ID),
+ * convert it to native Stellar base32 format. Only accepts exactly
+ * 32 bytes (64 hex chars) to avoid silent corruption from other hex
+ * representations (e.g. the UTF-8 "normalized" encoding which is 56 bytes,
+ * or a 20-byte EVM address).
+ */
+const hexToStellarNative = (address: string | undefined): string | undefined => {
+    if (!address || !address.startsWith('0x') || !isHexString(address)) return address;
+    const hexPayload = address.slice(2);
+    if (hexPayload.length !== BYTES32_HEX_LENGTH) {
+        throw new Error(
+            `Stellar hex address must be exactly 32 bytes (${BYTES32_HEX_LENGTH} hex chars), got ${hexPayload.length}: ${address}`,
+        );
+    }
+    const raw = Buffer.from(hexPayload, 'hex');
+    return StrKey.encodeContract(raw);
+};
+
 export const stellarAddressParser: (
     chainName: InferChainNamesForChainType<ChainType.STELLAR>,
 ) => AddressParser<InferChainNamesForChainType<ChainType.STELLAR>> = (chainName) => {
@@ -514,11 +584,32 @@ export const stellarAddressParser: (
             const hex = addressParser(chainName).nativeToBytes32Hex(nativeAddress);
             return hexToBytes(hex);
         },
+        normalizedToBytes32Hex: (address) => {
+            if (address === undefined) return undefined as any;
+            // Stellar normalized hex is UTF-8 of ASCII address (56 bytes), not raw bytes.
+            // Route through native string to extract the raw 32-byte StrKey payload.
+            return addressParser(chainName).nativeToBytes32Hex(
+                addressParser(chainName).normalizedToNativeString(address),
+            );
+        },
+        normalizedToBytes32: (address) => {
+            if (address === undefined) return undefined as any;
+            return hexToBytes(addressParser(chainName).normalizedToBytes32Hex(address));
+        },
+        bytes32ToNormalized: (bytes32Hex) => {
+            if (bytes32Hex === undefined) return undefined as any;
+            // Always assumes contract address type — G-address→bytes32 is a lossy upcast
+            return stellarAsciiToNormalized(
+                StrKey.encodeContract(Buffer.from(hexToBytes(bytes32Hex))),
+            );
+        },
         parseNative: (nativeAddress) => {
+            nativeAddress = hexToStellarNative(nativeAddress);
             assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
         },
         parseNativeToUnpaddedHex: (nativeAddress) => {
+            nativeAddress = hexToStellarNative(nativeAddress);
             assertNative(nativeAddress, chainName);
             const normalized = addressParser(chainName).nativeToNormalized(nativeAddress);
             return normalized as unknown as HexString;

package/dist/3457WEGJ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addressParser.ts"],"names":["AddressEncoding","addressParser","chainName","ChainName","TON","tonAddressParser","SOLANA","base58AddressParser","INITIA","initiaAddressParser","STELLAR","stellarAddressParser","STARKNET","starknetAddressParser","hexAddressParser","normalizedToBytes32Hex","address","hexZeroPad","normalizedToUnpaddedString","toString","normalizedToBytes32","hexToBytes","normalizedToBigInt","BigInt","parseNative","nativeAddress","assertNative","expectedChainName","validateNative","Error","getAddress","undefined","parseTonAddress","normalizedToNative","numericalValue","bigintToAddress","normalizedToNativeString","nativeToNormalized","normalizeHex","addressToHex","nativeToBytes32Hex","nativeToBytes","nativeToBytes32","parseNativeToUnpaddedHex","tonToNormalized","tonAddress","encoding","isHexString","test","AccAddress","fromHex","toHex","isBase58","bs58","encode","hex","bytesToHexPrefixed","decode","nativeByteLength","StaticChainConfigs","getAddressSizeInBytes","TRON","startsWith","slice","isValidStellarAddress","StrKey","isValidEd25519PublicKey","isValidContract","isValidMed25519PublicKey","isValidLiquidityPool","isValidClaimableBalance","isValidSignedPayload","stellarTextEncoder","TextEncoder","stellarAsciiToNormalized","bytes","stellarTextDecoder","TextDecoder","normalizedToStellarAscii","normalizedHex","stellarAddress","rawBytes","decodeEd25519PublicKey","decodeContract","decodeLiquidityPool","fullBytes","decodeClaimableBalance","subarray","normalized"],"mappings":"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","file":"3457WEGJ.js","sourcesContent":["import { AccAddress } from '@initia/initia.js';\nimport { StrKey } from '@stellar/stellar-sdk';\nimport type { Address } from '@ton/ton';\nimport bs58 from 'bs58';\n\nimport type { HexString, NormalizedHexString } from '@layerzerolabs/common-chain-model';\nimport { normalizeHex } from '@layerzerolabs/common-chain-model';\nimport {\n    bytesToHexPrefixed,\n    hexToBytes,\n    hexZeroPad,\n    isBase58,\n    isHexString,\n} from '@layerzerolabs/common-encoding-utils';\nimport { addressToHex, bigintToAddress, parseTonAddress } from '@layerzerolabs/common-ton';\nimport type {\n    Base58String,\n    ChainsByEncoding,\n    ChainType,\n    InferChainNamesForChainType,\n    InferChainTypeForChainName,\n    InitiaString,\n    NativeAddress,\n    ResolvedEncodingForChainName,\n    StellarString,\n} from '@layerzerolabs/layerzero-definitions';\nimport type { ChainNativeAddress } from '@layerzerolabs/layerzero-definitions';\nimport { ChainName } from '@layerzerolabs/layerzero-definitions';\nimport { StaticChainConfigs } from '@layerzerolabs/static-chain-info';\nimport type { MaybeUndefinedMapped } from '@layerzerolabs/typescript-utils';\n\ntype NativeOrString<T extends ChainName> = ChainNativeAddress<T> | ResolvedEncodingForChainName<T>;\n\nexport enum AddressEncoding {\n    HEX = 'hex',\n    BASE58 = 'base58',\n    TON = 'ton',\n    INITIA = 'initia',\n    STELLAR = 'stellar',\n}\n\nexport type ExtensionByChainType = {\n    ton: {\n        tonToNormalized: (tonAddress: Address) => NormalizedHexString;\n    };\n};\n\nexport type InferExtensionByChainName<T extends ChainName> =\n    InferChainTypeForChainName<T> extends keyof ExtensionByChainType\n        ? ExtensionByChainType[InferChainTypeForChainName<T>]\n        : {};\n\nexport type AddressParser<T extends ChainName> = {\n    normalizedToNative: <Address extends NormalizedHexString | undefined>(\n        address: Address,\n    ) => MaybeUndefinedMapped<Address, ChainNativeAddress<T>>;\n    normalizedToNativeString: <Address extends NormalizedHexString | undefined>(\n        address: Address,\n    ) => MaybeUndefinedMapped<Address, ResolvedEncodingForChainName<T>>;\n    nativeToNormalized: <Address extends NativeOrString<T> | undefined>(\n        nativeAddress: Address,\n    ) => MaybeUndefinedMapped<Address, NormalizedHexString>;\n    nativeToBytes: <Address extends NativeOrString<T> | undefined>(\n        nativeAddress: Address,\n    ) => MaybeUndefinedMapped<Address, Uint8Array>;\n    nativeToBytes32Hex: <Address extends NativeOrString<T> | undefined>(\n        nativeAddress: Address,\n    ) => MaybeUndefinedMapped<Address, HexString>;\n    nativeToBytes32: <Address extends NativeOrString<T> | undefined>(\n        nativeAddress: Address,\n    ) => MaybeUndefinedMapped<Address, Uint8Array>;\n    validateNative: (\n        nativeAddress: string | undefined,\n    ) => nativeAddress is ResolvedEncodingForChainName<T>;\n    /**\n     * Parse a native address to a string if it is valid.\n     * Throws an error if the native address is invalid.\n     * @param nativeAddress - The native address to parse.\n     * @returns The parsed native address.\n     */\n    parseNative: (nativeAddress: string | undefined) => NormalizedHexString;\n    parseNativeToUnpaddedHex: (nativeAddress: string | undefined) => HexString;\n    encoding: AddressEncoding;\n} & InferExtensionByChainName<T>;\n\nexport function addressParser<T extends ChainName>(chainName: T): AddressParser<T> {\n    // FIXME: figure out a way to not have to cast here\n    if (chainName === ChainName.TON)\n        return tonAddressParser(chainName) as unknown as AddressParser<T>;\n    if (chainName === ChainName.SOLANA)\n        return base58AddressParser(chainName) as unknown as AddressParser<T>;\n    if (chainName === ChainName.INITIA)\n        return initiaAddressParser(chainName) as unknown as AddressParser<T>;\n    if (chainName === ChainName.STELLAR)\n        return stellarAddressParser(chainName) as unknown as AddressParser<T>;\n    if (chainName === ChainName.STARKNET)\n        return starknetAddressParser(chainName) as unknown as AddressParser<T>;\n    return hexAddressParser(chainName) as unknown as AddressParser<T>;\n}\n\nexport namespace addressParser {\n    export const normalizedToBytes32Hex = (address: NormalizedHexString) => {\n        return hexZeroPad(address as unknown as HexString, 32);\n    };\n\n    export const normalizedToUnpaddedString = (address: NormalizedHexString) => {\n        return address.toString() as HexString;\n    };\n\n    export const normalizedToBytes32 = (address: NormalizedHexString) => {\n        return hexToBytes(normalizedToBytes32Hex(address));\n    };\n\n    export const normalizedToBigInt = (address: NormalizedHexString) => {\n        return BigInt(address as unknown as HexString);\n    };\n\n    export const parseNative = (nativeAddress: NativeAddress) => {\n        return addressParser(nativeAddress.chainName).parseNative(nativeAddress.nativeAddress);\n    };\n}\n\nfunction assertNative<T extends ChainName>(\n    nativeAddress: string | undefined,\n    expectedChainName: T,\n): asserts nativeAddress is ResolvedEncodingForChainName<T> {\n    if (!addressParser(expectedChainName).validateNative(nativeAddress)) {\n        throw new Error(\n            'Cannot convert: \"' +\n                nativeAddress +\n                '\" - The native address does not match the expected format for the chain: ' +\n                expectedChainName,\n        );\n    }\n}\n\nconst getAddress = <T extends ChainName>(nativeAddress: NativeOrString<T>) => {\n    return typeof nativeAddress === 'object' ? nativeAddress.nativeAddress : nativeAddress;\n};\n\nexport const tonAddressParser: (\n    chainName: InferChainNamesForChainType<ChainType.TON>,\n) => AddressParser<InferChainNamesForChainType<ChainType.TON>> = (chainName) => {\n    return {\n        validateNative: (nativeAddress): nativeAddress is HexString => {\n            if (nativeAddress === undefined) {\n                return false;\n            }\n            try {\n                parseTonAddress(nativeAddress);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) return undefined as any;\n            const numericalValue = addressParser.normalizedToBigInt(address);\n            return {\n                // FIXME this is wrong\n                nativeAddress: bigintToAddress(numericalValue).toString() as HexString,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            return normalizeHex(addressToHex(address));\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            // naturally ton is 32 bytes, pad it anyway\n            if (nativeAddress === undefined) return undefined as any;\n            return hexZeroPad(\n                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,\n                32,\n            );\n        },\n        nativeToBytes: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        nativeToBytes32: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToUnpaddedHex: (nativeAddress) => {\n            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;\n        },\n        tonToNormalized: (tonAddress) => {\n            return addressParser(chainName).parseNative(addressToHex(tonAddress));\n        },\n        encoding: AddressEncoding.TON,\n    };\n};\n\nexport const initiaAddressParser: (\n    chainName: ChainsByEncoding[InitiaString],\n) => AddressParser<ChainsByEncoding[InitiaString]> = (chainName) => {\n    return {\n        validateNative: (nativeAddress): nativeAddress is InitiaString => {\n            if (nativeAddress === undefined) {\n                return false;\n            }\n            try {\n                // Both formats are native for the chain and are used kind of randomly.\n                return (\n                    isHexString(nativeAddress) ||\n                    /^(init)1(['qpzry9x8gf2tvdw0s3jn54khce6mua7l]{38,66})$/.test(nativeAddress)\n                );\n            } catch {\n                return false;\n            }\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) {\n                return undefined as any;\n            }\n            return {\n                nativeAddress: AccAddress.fromHex(address as unknown as HexString) as InitiaString,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            if (isHexString(address)) {\n                return normalizeHex(address);\n            }\n            return normalizeHex(AccAddress.toHex(nativeAddress.toString()) as HexString);\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            // naturally ton is 32 bytes, pad it anyway\n            return hexZeroPad(\n                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,\n                32,\n            );\n        },\n        nativeToBytes: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        nativeToBytes32: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToUnpaddedHex: (nativeAddress) => {\n            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;\n        },\n        encoding: AddressEncoding.INITIA,\n    };\n};\n\nexport const base58AddressParser = (\n    chainName: ChainsByEncoding[Base58String],\n): AddressParser<ChainsByEncoding[Base58String]> => {\n    return {\n        validateNative: (nativeAddress): nativeAddress is Base58String => {\n            if (nativeAddress === undefined) return false;\n            return isBase58(nativeAddress);\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) return undefined as any;\n            return {\n                nativeAddress: bs58.encode(\n                    hexToBytes(address as unknown as HexString),\n                ) as Base58String,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            const hex = bytesToHexPrefixed(bs58.decode(address));\n            return normalizeHex(hex);\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            // naturally solana is 32 bytes, pad it anyway\n            if (nativeAddress === undefined) return undefined as any;\n            return hexZeroPad(\n                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,\n                32,\n            );\n        },\n        nativeToBytes: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            return bs58.decode(address);\n        },\n        nativeToBytes32: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToUnpaddedHex: (nativeAddress) => {\n            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;\n        },\n        encoding: AddressEncoding.BASE58,\n    };\n};\n\nexport const hexAddressParser = (\n    chainName: ChainsByEncoding[HexString],\n): AddressParser<ChainsByEncoding[HexString]> => {\n    return {\n        validateNative: (nativeAddress): nativeAddress is HexString => {\n            if (nativeAddress === undefined) return false;\n            return isHexString(nativeAddress);\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) return undefined as any;\n            // we fetch here instead of storing by chain because some chains may not have this defined,\n            // so we should only throw on those chains if they try to use these methods that need the native byte length\n            const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName);\n            return {\n                // we could have EIP-55 here, but omitted for now\n                nativeAddress: hexZeroPad(address as unknown as HexString, nativeByteLength),\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName);\n            return hexZeroPad(address as unknown as HexString, nativeByteLength);\n        },\n        nativeToNormalized: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            return normalizeHex(address);\n        },\n        nativeToBytes: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            return hexToBytes(address);\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            return hexZeroPad(address, 32);\n        },\n        nativeToBytes32: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            // Specific case to make tron a little less flaky, handle the 41 prefix\n            if (chainName === ChainName.TRON && nativeAddress) {\n                nativeAddress = nativeAddress.startsWith('41')\n                    ? `0x${nativeAddress.slice(2)}`\n                    : nativeAddress;\n            }\n\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToUnpaddedHex: (nativeAddress) => {\n            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;\n        },\n        encoding: AddressEncoding.HEX,\n    };\n};\n\nexport const stellarAddressParser: (\n    chainName: InferChainNamesForChainType<ChainType.STELLAR>,\n) => AddressParser<InferChainNamesForChainType<ChainType.STELLAR>> = (chainName) => {\n    /**\n     * Validate if a string is a valid Stellar address.\n     *\n     * According to SEP-0023 (https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md),\n     * Stellar supports multiple address types encoded as base32 ASCII strings:\n     * - Account addresses starting with 'G' (56 chars, Ed25519 public key)\n     * - Contract addresses starting with 'C' (56 chars, contract ID)\n     * - Muxed addresses starting with 'M' (69 chars, muxed account with ID)\n     * - Liquidity pool addresses starting with 'L' (56 chars, pool ID)\n     * - Claimable balance addresses starting with 'B' (56 chars, balance ID)\n     * - Signed payload starting with 'P' (variable length)\n     *\n     * All addresses are stored in their native ASCII format to preserve type information.\n     */\n    const isValidStellarAddress = (address: string): boolean => {\n        if (!address) return false;\n        // Use the StrKey validation methods for all supported address types\n        return (\n            StrKey.isValidEd25519PublicKey(address) ||\n            StrKey.isValidContract(address) ||\n            StrKey.isValidMed25519PublicKey(address) ||\n            StrKey.isValidLiquidityPool(address) ||\n            StrKey.isValidClaimableBalance(address) ||\n            StrKey.isValidSignedPayload(address)\n        );\n    };\n\n    /**\n     * Convert Stellar ASCII address to normalized hex by encoding the ASCII string as UTF-8 bytes.\n     * This preserves the full address including type prefix and allows round-trip conversion.\n     */\n    const stellarTextEncoder = new TextEncoder();\n    const stellarAsciiToNormalized = (address: string): NormalizedHexString => {\n        // Convert ASCII address string to UTF-8 bytes, then to hex\n        const bytes = stellarTextEncoder.encode(address);\n        return normalizeHex(bytesToHexPrefixed(bytes));\n    };\n\n    /**\n     * Convert normalized hex back to Stellar ASCII address by decoding UTF-8 bytes.\n     */\n    const stellarTextDecoder = new TextDecoder();\n    const normalizedToStellarAscii = (normalizedHex: NormalizedHexString): string => {\n        // Convert hex to bytes, then decode as UTF-8 string\n        const bytes = hexToBytes(normalizedHex as unknown as HexString);\n        return stellarTextDecoder.decode(bytes);\n    };\n\n    return {\n        validateNative: (nativeAddress): nativeAddress is StellarString => {\n            if (nativeAddress === undefined) return false;\n            return isValidStellarAddress(nativeAddress);\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) return undefined as any;\n            // Decode normalized hex back to ASCII Stellar address\n            const stellarAddress = normalizedToStellarAscii(address);\n            return {\n                nativeAddress: stellarAddress as StellarString,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            return normalizedToStellarAscii(address) as StellarString;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            // Convert ASCII address to normalized hex\n            return stellarAsciiToNormalized(address);\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            // Decode the Stellar address to its raw 32-byte payload based on type\n            let rawBytes: Buffer;\n            if (StrKey.isValidEd25519PublicKey(address)) {\n                // Account addresses (G...) - Ed25519 public key (32 bytes)\n                rawBytes = StrKey.decodeEd25519PublicKey(address);\n            } else if (StrKey.isValidContract(address)) {\n                // Contract addresses (C...) - contract ID (32 bytes)\n                rawBytes = StrKey.decodeContract(address);\n            } else if (StrKey.isValidLiquidityPool(address)) {\n                // Liquidity pool addresses (L...) - pool ID (32 bytes)\n                rawBytes = StrKey.decodeLiquidityPool(address);\n            } else if (StrKey.isValidClaimableBalance(address)) {\n                // Claimable balance addresses (B...) - balance ID (33 bytes: 1-byte version + 32-byte hash)\n                // Per SEP-0023: first byte is the claimable balance type (0x00 = V0), followed by 32-byte SHA256 hash\n                const fullBytes = StrKey.decodeClaimableBalance(address);\n                rawBytes = fullBytes.subarray(1); // Skip the first byte (version), return the 32-byte hash\n            } else if (StrKey.isValidMed25519PublicKey(address)) {\n                // Muxed addresses (M...) contain additional data beyond 32 bytes\n                throw new Error(\n                    'nativeToBytes32 is not supported for Stellar muxed addresses (M...)',\n                );\n            } else if (StrKey.isValidSignedPayload(address)) {\n                // Signed payload (P...) has variable length\n                throw new Error(\n                    'nativeToBytes32 is not supported for Stellar signed payload addresses (P...)',\n                );\n            } else {\n                throw new Error(`Unknown Stellar address type: ${address}`);\n            }\n            return bytesToHexPrefixed(rawBytes);\n        },\n        nativeToBytes: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            const address = getAddress(nativeAddress);\n            assertNative(address, chainName);\n            // Convert ASCII address to UTF-8 bytes\n            return stellarTextEncoder.encode(address);\n        },\n        nativeToBytes32: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            // Use nativeToBytes32Hex and convert to Uint8Array\n            const hex = addressParser(chainName).nativeToBytes32Hex(nativeAddress);\n            return hexToBytes(hex);\n        },\n        parseNative: (nativeAddress) => {\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToUnpaddedHex: (nativeAddress) => {\n            assertNative(nativeAddress, chainName);\n            const normalized = addressParser(chainName).nativeToNormalized(nativeAddress);\n            return normalized as unknown as HexString;\n        },\n        encoding: AddressEncoding.STELLAR,\n    };\n};\n\n// Starknet addresses do not handle hex-zero padding, so we just return the address as is\nexport const starknetAddressParser = (\n    chainName: ChainsByEncoding[HexString],\n): AddressParser<ChainsByEncoding[HexString]> => {\n    return {\n        ...hexAddressParser(chainName),\n        validateNative: (nativeAddress): nativeAddress is HexString => {\n            if (nativeAddress === undefined) return false;\n            return isHexString(nativeAddress);\n        },\n        parseNative: (nativeAddress) => {\n            if (nativeAddress === undefined) return undefined as any;\n            // We can't trust starknet.js strings, they may actually be bigints!\n            // so just convert everything to hex first, then convert to normalized\n            nativeAddress = `0x${BigInt(nativeAddress).toString(16)}`;\n            assertNative(nativeAddress, chainName);\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        normalizedToNative: (address) => {\n            if (address === undefined) return undefined as any;\n            return {\n                nativeAddress: address,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            if (address === undefined) return undefined as any;\n            return address;\n        },\n    };\n};\n"]}