@layerzerolabs/chain-utils 0.0.66 → 0.0.73

package/src/addressParser.ts

@@ -1,4 +1,5 @@
 import { AccAddress } from '@initia/initia.js';
+import { StrKey } from '@stellar/stellar-sdk';
 import type { Address } from '@ton/ton';
 import bs58 from 'bs58';
 
@@ -21,10 +22,12 @@ import type {
     InitiaString,
     NativeAddress,
     ResolvedEncodingForChainName,
+    StellarString,
 } from '@layerzerolabs/layerzero-definitions';
 import type { ChainNativeAddress } from '@layerzerolabs/layerzero-definitions';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 import { StaticChainConfigs } from '@layerzerolabs/static-chain-info';
+import type { MaybeUndefinedMapped } from '@layerzerolabs/typescript-utils';
 
 type NativeOrString<T extends ChainName> = ChainNativeAddress<T> | ResolvedEncodingForChainName<T>;
 
@@ -33,6 +36,7 @@ export enum AddressEncoding {
     BASE58 = 'base58',
     TON = 'ton',
     INITIA = 'initia',
+    STELLAR = 'stellar',
 }
 
 export type ExtensionByChainType = {
@@ -47,21 +51,35 @@ export type InferExtensionByChainName<T extends ChainName> =
         : {};
 
 export type AddressParser<T extends 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>;
+    normalizedToNative: <Address extends NormalizedHexString | undefined>(
+        address: Address,
+    ) => MaybeUndefinedMapped<Address, ChainNativeAddress<T>>;
+    normalizedToNativeString: <Address extends NormalizedHexString | undefined>(
+        address: Address,
+    ) => MaybeUndefinedMapped<Address, ResolvedEncodingForChainName<T>>;
+    nativeToNormalized: <Address extends NativeOrString<T> | undefined>(
+        nativeAddress: Address,
+    ) => MaybeUndefinedMapped<Address, NormalizedHexString>;
+    nativeToBytes: <Address extends NativeOrString<T> | undefined>(
+        nativeAddress: Address,
+    ) => MaybeUndefinedMapped<Address, Uint8Array>;
+    nativeToBytes32Hex: <Address extends NativeOrString<T> | undefined>(
+        nativeAddress: Address,
+    ) => MaybeUndefinedMapped<Address, HexString>;
+    nativeToBytes32: <Address extends NativeOrString<T> | undefined>(
+        nativeAddress: Address,
+    ) => MaybeUndefinedMapped<Address, Uint8Array>;
+    validateNative: (
+        nativeAddress: string | undefined,
+    ) => 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;
+    parseNative: (nativeAddress: string | undefined) => NormalizedHexString;
+    parseNativeToUnpaddedHex: (nativeAddress: string | undefined) => HexString;
     encoding: AddressEncoding;
 } & InferExtensionByChainName<T>;
 
@@ -73,6 +91,10 @@ export function addressParser<T extends ChainName>(chainName: T): AddressParser<
         return base58AddressParser(chainName) as unknown as AddressParser<T>;
     if (chainName === ChainName.INITIA)
         return initiaAddressParser(chainName) as unknown as AddressParser<T>;
+    if (chainName === ChainName.STELLAR)
+        return stellarAddressParser(chainName) as unknown as AddressParser<T>;
+    if (chainName === ChainName.STARKNET)
+        return starknetAddressParser(chainName) as unknown as AddressParser<T>;
     return hexAddressParser(chainName) as unknown as AddressParser<T>;
 }
 
@@ -80,34 +102,39 @@ 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 normalizedToAlignedString = (address: NormalizedHexString) => {
+        const hex = address.toString();
+        // Unpadded but aligned to a byte length, so its transformable to a byte array
+        return (hex.length % 2 === 0 ? hex : `0x0${hex.slice(2)}`) as HexString;
     };
+
     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>(
-    nativeAddress: string,
+function assertNative<T extends ChainName>(
+    nativeAddress: string | undefined,
     expectedChainName: T,
-): nativeAddress is ResolvedEncodingForChainName<T> => {
+): asserts nativeAddress is ResolvedEncodingForChainName<T> {
     if (!addressParser(expectedChainName).validateNative(nativeAddress)) {
         throw new Error(
-            'Cannot convert: ' +
+            'Cannot convert: "' +
                 nativeAddress +
-                ' - The native address does not match the expected format for the chain: ' +
+                '" - The native address does not match the expected format for the chain: ' +
                 expectedChainName,
         );
     }
-    return true;
-};
+}
 
 const getAddress = <T extends ChainName>(nativeAddress: NativeOrString<T>) => {
     return typeof nativeAddress === 'object' ? nativeAddress.nativeAddress : nativeAddress;
@@ -118,6 +145,9 @@ export const tonAddressParser: (
 ) => AddressParser<InferChainNamesForChainType<ChainType.TON>> = (chainName) => {
     return {
         validateNative: (nativeAddress): nativeAddress is HexString => {
+            if (nativeAddress === undefined) {
+                return false;
+            }
             try {
                 parseTonAddress(nativeAddress);
                 return true;
@@ -126,6 +156,7 @@ export const tonAddressParser: (
             }
         },
         normalizedToNative: (address) => {
+            if (address === undefined) return undefined as any;
             const numericalValue = addressParser.normalizedToBigInt(address);
             return {
                 // FIXME this is wrong
@@ -134,33 +165,36 @@ export const tonAddressParser: (
             };
         },
         normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
             return addressParser(chainName).normalizedToNative(address).nativeAddress;
         },
         nativeToNormalized: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             return normalizeHex(addressToHex(address));
         },
         nativeToBytes32Hex: (nativeAddress) => {
             // naturally ton is 32 bytes, pad it anyway
+            if (nativeAddress === undefined) return undefined as any;
             return hexZeroPad(
                 addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,
                 32,
             );
         },
         nativeToBytes: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
         nativeToBytes32: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
         parseNative: (nativeAddress) => {
-            if (!validateNative(nativeAddress, chainName)) {
-                throw new Error('Invalid native address: ' + nativeAddress);
-            }
+            assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
         },
-        parseNativeToHex: (nativeAddress) => {
+        parseNativeToUnpaddedHex: (nativeAddress) => {
             return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
         },
         tonToNormalized: (tonAddress) => {
@@ -175,6 +209,9 @@ export const initiaAddressParser: (
 ) => AddressParser<ChainsByEncoding[InitiaString]> = (chainName) => {
     return {
         validateNative: (nativeAddress): nativeAddress is InitiaString => {
+            if (nativeAddress === undefined) {
+                return false;
+            }
             try {
                 // Both formats are native for the chain and are used kind of randomly.
                 return (
@@ -186,41 +223,48 @@ export const initiaAddressParser: (
             }
         },
         normalizedToNative: (address) => {
+            if (address === undefined) {
+                return undefined as any;
+            }
             return {
                 nativeAddress: AccAddress.fromHex(address as unknown as HexString) as InitiaString,
                 chainName,
             };
         },
         normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
             return addressParser(chainName).normalizedToNative(address).nativeAddress;
         },
         nativeToNormalized: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             if (isHexString(address)) {
                 return normalizeHex(address);
             }
             return normalizeHex(AccAddress.toHex(nativeAddress.toString()) as HexString);
         },
         nativeToBytes32Hex: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            // naturally ton is 32 bytes, pad it anyway
             return hexZeroPad(
                 addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,
                 32,
             );
         },
         nativeToBytes: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
         nativeToBytes32: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
         parseNative: (nativeAddress) => {
-            if (!validateNative(nativeAddress, chainName)) {
-                throw new Error('Invalid native address: ' + nativeAddress);
-            }
+            assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
         },
-        parseNativeToHex: (nativeAddress) => {
+        parseNativeToUnpaddedHex: (nativeAddress) => {
             return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
         },
         encoding: AddressEncoding.INITIA,
@@ -232,9 +276,11 @@ export const base58AddressParser = (
 ): AddressParser<ChainsByEncoding[Base58String]> => {
     return {
         validateNative: (nativeAddress): nativeAddress is Base58String => {
+            if (nativeAddress === undefined) return false;
             return isBase58(nativeAddress);
         },
         normalizedToNative: (address) => {
+            if (address === undefined) return undefined as any;
             return {
                 nativeAddress: bs58.encode(
                     hexToBytes(address as unknown as HexString),
@@ -243,36 +289,39 @@ export const base58AddressParser = (
             };
         },
         normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
             return addressParser(chainName).normalizedToNative(address).nativeAddress;
         },
         nativeToNormalized: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             const hex = bytesToHexPrefixed(bs58.decode(address));
             return normalizeHex(hex);
         },
         nativeToBytes32Hex: (nativeAddress) => {
             // naturally solana is 32 bytes, pad it anyway
+            if (nativeAddress === undefined) return undefined as any;
             return hexZeroPad(
                 addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,
                 32,
             );
         },
         nativeToBytes: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             return bs58.decode(address);
         },
         nativeToBytes32: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));
         },
         parseNative: (nativeAddress) => {
-            if (!validateNative(nativeAddress, chainName)) {
-                throw new Error('Invalid native address: ' + nativeAddress);
-            }
+            assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
         },
-        parseNativeToHex: (nativeAddress) => {
+        parseNativeToUnpaddedHex: (nativeAddress) => {
             return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
         },
         encoding: AddressEncoding.BASE58,
@@ -282,13 +331,16 @@ export const base58AddressParser = (
 export const hexAddressParser = (
     chainName: ChainsByEncoding[HexString],
 ): AddressParser<ChainsByEncoding[HexString]> => {
-    const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName as ChainName);
-
     return {
         validateNative: (nativeAddress): nativeAddress is HexString => {
+            if (nativeAddress === undefined) return false;
             return isHexString(nativeAddress);
         },
         normalizedToNative: (address) => {
+            if (address === undefined) return undefined as any;
+            // we fetch here instead of storing by chain because some chains may not have this defined,
+            // so we should only throw on those chains if they try to use these methods that need the native byte length
+            const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName);
             return {
                 // we could have EIP-55 here, but omitted for now
                 nativeAddress: hexZeroPad(address as unknown as HexString, nativeByteLength),
@@ -296,42 +348,215 @@ export const hexAddressParser = (
             };
         },
         normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
+            const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName);
             return hexZeroPad(address as unknown as HexString, nativeByteLength);
         },
         nativeToNormalized: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             return normalizeHex(address);
         },
         nativeToBytes: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             return hexToBytes(address);
         },
         nativeToBytes32Hex: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             const address = getAddress(nativeAddress);
-            validateNative(address, chainName);
+            assertNative(address, chainName);
             return hexZeroPad(address, 32);
         },
         nativeToBytes32: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
             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) {
+            if (chainName === ChainName.TRON && nativeAddress) {
                 nativeAddress = nativeAddress.startsWith('41')
                     ? `0x${nativeAddress.slice(2)}`
                     : nativeAddress;
             }
 
-            if (!validateNative(nativeAddress, chainName)) {
-                throw new Error('Invalid native address: ' + nativeAddress);
-            }
+            assertNative(nativeAddress, chainName);
             return addressParser(chainName).nativeToNormalized(nativeAddress);
         },
-        parseNativeToHex: (nativeAddress) => {
+        parseNativeToUnpaddedHex: (nativeAddress) => {
             return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;
         },
         encoding: AddressEncoding.HEX,
     };
 };
+
+export const stellarAddressParser: (
+    chainName: InferChainNamesForChainType<ChainType.STELLAR>,
+) => AddressParser<InferChainNamesForChainType<ChainType.STELLAR>> = (chainName) => {
+    /**
+     * Validate if a string is a valid Stellar address.
+     *
+     * According to SEP-0023 (https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md),
+     * Stellar supports multiple address types encoded as base32 ASCII strings:
+     * - Account addresses starting with 'G' (56 chars, Ed25519 public key)
+     * - Contract addresses starting with 'C' (56 chars, contract ID)
+     * - Muxed addresses starting with 'M' (69 chars, muxed account with ID)
+     * - Liquidity pool addresses starting with 'L' (56 chars, pool ID)
+     * - Claimable balance addresses starting with 'B' (56 chars, balance ID)
+     * - Signed payload starting with 'P' (variable length)
+     *
+     * All addresses are stored in their native ASCII format to preserve type information.
+     */
+    const isValidStellarAddress = (address: string): boolean => {
+        if (!address) return false;
+        // Use the StrKey validation methods for all supported address types
+        return (
+            StrKey.isValidEd25519PublicKey(address) ||
+            StrKey.isValidContract(address) ||
+            StrKey.isValidMed25519PublicKey(address) ||
+            StrKey.isValidLiquidityPool(address) ||
+            StrKey.isValidClaimableBalance(address) ||
+            StrKey.isValidSignedPayload(address)
+        );
+    };
+
+    /**
+     * Convert Stellar ASCII address to normalized hex by encoding the ASCII string as UTF-8 bytes.
+     * This preserves the full address including type prefix and allows round-trip conversion.
+     */
+    const stellarTextEncoder = new TextEncoder();
+    const stellarAsciiToNormalized = (address: string): NormalizedHexString => {
+        // Convert ASCII address string to UTF-8 bytes, then to hex
+        const bytes = stellarTextEncoder.encode(address);
+        return normalizeHex(bytesToHexPrefixed(bytes));
+    };
+
+    /**
+     * Convert normalized hex back to Stellar ASCII address by decoding UTF-8 bytes.
+     */
+    const stellarTextDecoder = new TextDecoder();
+    const normalizedToStellarAscii = (normalizedHex: NormalizedHexString): string => {
+        // Convert hex to bytes, then decode as UTF-8 string
+        const bytes = hexToBytes(normalizedHex as unknown as HexString);
+        return stellarTextDecoder.decode(bytes);
+    };
+
+    return {
+        validateNative: (nativeAddress): nativeAddress is StellarString => {
+            if (nativeAddress === undefined) return false;
+            return isValidStellarAddress(nativeAddress);
+        },
+        normalizedToNative: (address) => {
+            if (address === undefined) return undefined as any;
+            // Decode normalized hex back to ASCII Stellar address
+            const stellarAddress = normalizedToStellarAscii(address);
+            return {
+                nativeAddress: stellarAddress as StellarString,
+                chainName,
+            };
+        },
+        normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
+            return normalizedToStellarAscii(address) as StellarString;
+        },
+        nativeToNormalized: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            const address = getAddress(nativeAddress);
+            assertNative(address, chainName);
+            // Convert ASCII address to normalized hex
+            return stellarAsciiToNormalized(address);
+        },
+        nativeToBytes32Hex: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            const address = getAddress(nativeAddress);
+            assertNative(address, chainName);
+            // Decode the Stellar address to its raw 32-byte payload based on type
+            let rawBytes: Buffer;
+            if (StrKey.isValidEd25519PublicKey(address)) {
+                // Account addresses (G...) - Ed25519 public key (32 bytes)
+                rawBytes = StrKey.decodeEd25519PublicKey(address);
+            } else if (StrKey.isValidContract(address)) {
+                // Contract addresses (C...) - contract ID (32 bytes)
+                rawBytes = StrKey.decodeContract(address);
+            } else if (StrKey.isValidLiquidityPool(address)) {
+                // Liquidity pool addresses (L...) - pool ID (32 bytes)
+                rawBytes = StrKey.decodeLiquidityPool(address);
+            } else if (StrKey.isValidClaimableBalance(address)) {
+                // Claimable balance addresses (B...) - balance ID (33 bytes: 1-byte version + 32-byte hash)
+                // Per SEP-0023: first byte is the claimable balance type (0x00 = V0), followed by 32-byte SHA256 hash
+                const fullBytes = StrKey.decodeClaimableBalance(address);
+                rawBytes = fullBytes.subarray(1); // Skip the first byte (version), return the 32-byte hash
+            } else if (StrKey.isValidMed25519PublicKey(address)) {
+                // Muxed addresses (M...) contain additional data beyond 32 bytes
+                throw new Error(
+                    'nativeToBytes32 is not supported for Stellar muxed addresses (M...)',
+                );
+            } else if (StrKey.isValidSignedPayload(address)) {
+                // Signed payload (P...) has variable length
+                throw new Error(
+                    'nativeToBytes32 is not supported for Stellar signed payload addresses (P...)',
+                );
+            } else {
+                throw new Error(`Unknown Stellar address type: ${address}`);
+            }
+            return bytesToHexPrefixed(rawBytes);
+        },
+        nativeToBytes: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            const address = getAddress(nativeAddress);
+            assertNative(address, chainName);
+            // Convert ASCII address to UTF-8 bytes
+            return stellarTextEncoder.encode(address);
+        },
+        nativeToBytes32: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            // Use nativeToBytes32Hex and convert to Uint8Array
+            const hex = addressParser(chainName).nativeToBytes32Hex(nativeAddress);
+            return hexToBytes(hex);
+        },
+        parseNative: (nativeAddress) => {
+            assertNative(nativeAddress, chainName);
+            return addressParser(chainName).nativeToNormalized(nativeAddress);
+        },
+        parseNativeToUnpaddedHex: (nativeAddress) => {
+            assertNative(nativeAddress, chainName);
+            const normalized = addressParser(chainName).nativeToNormalized(nativeAddress);
+            return normalized as unknown as HexString;
+        },
+        encoding: AddressEncoding.STELLAR,
+    };
+};
+
+// Starknet addresses do not have handle hexzero padding, so we just return the address as is
+export const starknetAddressParser = (
+    chainName: ChainsByEncoding[HexString],
+): AddressParser<ChainsByEncoding[HexString]> => {
+    return {
+        ...hexAddressParser(chainName),
+        validateNative: (nativeAddress): nativeAddress is HexString => {
+            if (nativeAddress === undefined) return false;
+            return isHexString(nativeAddress);
+        },
+        parseNative: (nativeAddress) => {
+            if (nativeAddress === undefined) return undefined as any;
+            // We can't trust starknet.js strings, they may actually be bigints!
+            // so just convert everything to hex first, then convert to normalized
+            nativeAddress = `0x${BigInt(nativeAddress).toString(16)}`;
+            assertNative(nativeAddress, chainName);
+            return addressParser(chainName).nativeToNormalized(nativeAddress);
+        },
+        normalizedToNative: (address) => {
+            if (address === undefined) return undefined as any;
+            return {
+                nativeAddress: address,
+                chainName,
+            };
+        },
+        normalizedToNativeString: (address) => {
+            if (address === undefined) return undefined as any;
+            return address;
+        },
+    };
+};

package/dist/K6ILVJZQ.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/addressParser.ts"],"names":["init_cjs_shims","AddressEncoding","addressParser","chainName","ChainName","TON","tonAddressParser","SOLANA","base58AddressParser","INITIA","initiaAddressParser","hexAddressParser","normalizedToBytes32Hex","address","hexZeroPad","normalizedToUnpaddedString","toString","normalizedToBytes32","hexToBytes","normalizedToBigInt","BigInt","parseNative","nativeAddress","validateNative","__name","expectedChainName","Error","getAddress","parseTonAddress","normalizedToNative","numericalValue","bigintToAddress","normalizedToNativeString","nativeToNormalized","normalizeHex","addressToHex","nativeToBytes32Hex","nativeToBytes","nativeToBytes32","parseNativeToHex","tonToNormalized","tonAddress","encoding","isHexString","test","AccAddress","fromHex","toHex","isBase58","bs58","encode","hex","bytesToHexPrefixed","decode","nativeByteLength","StaticChainConfigs","getAddressSizeInBytes","TRON","startsWith","slice"],"mappings":"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","file":"K6ILVJZQ.cjs","sourcesContent":["import { AccAddress } from '@initia/initia.js';\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 { addressToHex, bigintToAddress, parseTonAddress } from '@layerzerolabs/common-ton';\nimport {\n    bytesToHexPrefixed,\n    hexToBytes,\n    hexZeroPad,\n    isBase58,\n    isHexString,\n} from '@layerzerolabs/common-utils';\nimport type {\n    Base58String,\n    ChainsByEncoding,\n    ChainType,\n    InferChainNamesForChainType,\n    InferChainTypeForChainName,\n    InitiaString,\n    NativeAddress,\n    ResolvedEncodingForChainName,\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';\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}\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: NormalizedHexString) => ChainNativeAddress<T>;\n    normalizedToNativeString: (address: NormalizedHexString) => ResolvedEncodingForChainName<T>;\n    nativeToNormalized: (nativeAddress: NativeOrString<T>) => NormalizedHexString;\n    nativeToBytes: (nativeAddress: NativeOrString<T>) => Uint8Array;\n    nativeToBytes32Hex: (nativeAddress: NativeOrString<T>) => HexString;\n    nativeToBytes32: (nativeAddress: NativeOrString<T>) => Uint8Array;\n    validateNative: (nativeAddress: string) => 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) => NormalizedHexString;\n    parseNativeToHex: (nativeAddress: string) => 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    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    export const normalizedToUnpaddedString = (address: NormalizedHexString) => {\n        return address.toString() as HexString;\n    };\n    export const normalizedToBytes32 = (address: NormalizedHexString) => {\n        return hexToBytes(normalizedToBytes32Hex(address));\n    };\n    export const normalizedToBigInt = (address: NormalizedHexString) => {\n        return BigInt(address as unknown as HexString);\n    };\n    export const parseNative = (nativeAddress: NativeAddress) => {\n        return addressParser(nativeAddress.chainName).parseNative(nativeAddress.nativeAddress);\n    };\n}\n\nconst validateNative = <T extends ChainName>(\n    nativeAddress: string,\n    expectedChainName: T,\n): 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    return true;\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            try {\n                parseTonAddress(nativeAddress);\n                return true;\n            } catch {\n                return false;\n            }\n        },\n        normalizedToNative: (address) => {\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            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(address, chainName);\n            return normalizeHex(addressToHex(address));\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\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            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        nativeToBytes32: (nativeAddress) => {\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            if (!validateNative(nativeAddress, chainName)) {\n                throw new Error('Invalid native address: ' + nativeAddress);\n            }\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToHex: (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            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            return {\n                nativeAddress: AccAddress.fromHex(address as unknown as HexString) as InitiaString,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(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            return hexZeroPad(\n                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,\n                32,\n            );\n        },\n        nativeToBytes: (nativeAddress) => {\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        nativeToBytes32: (nativeAddress) => {\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            if (!validateNative(nativeAddress, chainName)) {\n                throw new Error('Invalid native address: ' + nativeAddress);\n            }\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToHex: (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            return isBase58(nativeAddress);\n        },\n        normalizedToNative: (address) => {\n            return {\n                nativeAddress: bs58.encode(\n                    hexToBytes(address as unknown as HexString),\n                ) as Base58String,\n                chainName,\n            };\n        },\n        normalizedToNativeString: (address) => {\n            return addressParser(chainName).normalizedToNative(address).nativeAddress;\n        },\n        nativeToNormalized: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(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            return hexZeroPad(\n                addressParser(chainName).nativeToNormalized(nativeAddress) as unknown as HexString,\n                32,\n            );\n        },\n        nativeToBytes: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(address, chainName);\n            return bs58.decode(address);\n        },\n        nativeToBytes32: (nativeAddress) => {\n            return hexToBytes(addressParser(chainName).nativeToBytes32Hex(nativeAddress));\n        },\n        parseNative: (nativeAddress) => {\n            if (!validateNative(nativeAddress, chainName)) {\n                throw new Error('Invalid native address: ' + nativeAddress);\n            }\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToHex: (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    const nativeByteLength = StaticChainConfigs.getAddressSizeInBytes(chainName as ChainName);\n\n    return {\n        validateNative: (nativeAddress): nativeAddress is HexString => {\n            return isHexString(nativeAddress);\n        },\n        normalizedToNative: (address) => {\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            return hexZeroPad(address as unknown as HexString, nativeByteLength);\n        },\n        nativeToNormalized: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(address, chainName);\n            return normalizeHex(address);\n        },\n        nativeToBytes: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(address, chainName);\n            return hexToBytes(address);\n        },\n        nativeToBytes32Hex: (nativeAddress) => {\n            const address = getAddress(nativeAddress);\n            validateNative(address, chainName);\n            return hexZeroPad(address, 32);\n        },\n        nativeToBytes32: (nativeAddress) => {\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) {\n                nativeAddress = nativeAddress.startsWith('41')\n                    ? `0x${nativeAddress.slice(2)}`\n                    : nativeAddress;\n            }\n\n            if (!validateNative(nativeAddress, chainName)) {\n                throw new Error('Invalid native address: ' + nativeAddress);\n            }\n            return addressParser(chainName).nativeToNormalized(nativeAddress);\n        },\n        parseNativeToHex: (nativeAddress) => {\n            return addressParser(chainName).parseNative(nativeAddress) as unknown as HexString;\n        },\n        encoding: AddressEncoding.HEX,\n    };\n};\n"]}