@layerzerolabs/chain-utils 0.0.67 → 0.0.74

package/dist/addressParser.test.js

@@ -1,4 +1,4 @@
-import { addressParser } from './MR2I35UU.js';
+import { addressParser } from './L4WCMHVM.js';
 import { __commonJS, init_esm_shims, __name, __require, __toESM } from './YXE7PREU.js';
 import * as bs58 from 'bs58';
 import { isatty } from 'tty';
@@ -18174,6 +18174,273 @@ describe("addressParser - TON", () => {
     globalExpect(parser.validateNative("invalid-ton-address")).toBe(false);
   });
 });
+describe("addressParser - Stellar", () => {
+  const parser = addressParser(ChainName.STELLAR);
+  const validTestAddresses = {
+    // Account address (G...)
+    account: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
+    // Contract address (C...)
+    contract: "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUWDA",
+    // Muxed address (M...)
+    muxed: "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAACJUQ",
+    // Liquidity pool address (L...)
+    liquidityPool: "LA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUPJN",
+    // Claimable balance address (B...)
+    claimableBalance: "BAAD6DBUX6J22DMZOHIEZTEQ64CVCHEDRKWZONFEUL5Q26QD7R76RGR4TU",
+    // Signed payload (P...)
+    signedPayload: "PA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAQACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6IBZGM"
+  };
+  describe("roundtrip conversions", () => {
+    it("maintains roundtrip invariant for account addresses (G...)", () => {
+      const stellarAddress = validTestAddresses.account;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+      globalExpect(native.chainName).toBe(ChainName.STELLAR);
+    });
+    it("maintains roundtrip invariant for contract addresses (C...)", () => {
+      const stellarAddress = validTestAddresses.contract;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+    });
+    it("maintains roundtrip invariant for muxed addresses (M...)", () => {
+      const stellarAddress = validTestAddresses.muxed;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+    });
+    it("maintains roundtrip invariant for liquidity pool addresses (L...)", () => {
+      const stellarAddress = validTestAddresses.liquidityPool;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+    });
+    it("maintains roundtrip invariant for claimable balance addresses (B...)", () => {
+      const stellarAddress = validTestAddresses.claimableBalance;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+    });
+    it("maintains roundtrip invariant for signed payload (P...)", () => {
+      const stellarAddress = validTestAddresses.signedPayload;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const native = parser.normalizedToNative(normalized);
+      globalExpect(native.nativeAddress).toBe(stellarAddress);
+    });
+  });
+  describe("validation", () => {
+    it("validates all valid Stellar address types", () => {
+      globalExpect(parser.validateNative(validTestAddresses.account)).toBe(true);
+      globalExpect(parser.validateNative(validTestAddresses.contract)).toBe(true);
+      globalExpect(parser.validateNative(validTestAddresses.muxed)).toBe(true);
+      globalExpect(parser.validateNative(validTestAddresses.liquidityPool)).toBe(true);
+      globalExpect(parser.validateNative(validTestAddresses.claimableBalance)).toBe(true);
+      globalExpect(parser.validateNative(validTestAddresses.signedPayload)).toBe(true);
+    });
+    it("rejects invalid Stellar addresses", () => {
+      const invalidAddresses = [
+        "GAAAAAAAACGC6",
+        "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZA",
+        "G47QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVP2I",
+        "invalid-stellar-address",
+        "",
+        "0x1234567890abcdef"
+      ];
+      invalidAddresses.forEach((addr) => {
+        globalExpect(parser.validateNative(addr)).toBe(false);
+      });
+    });
+    it("rejects undefined addresses", () => {
+      globalExpect(parser.validateNative(void 0)).toBe(false);
+    });
+  });
+  describe("ASCII encoding/decoding", () => {
+    it("converts Stellar address to UTF-8 bytes correctly", () => {
+      const stellarAddress = validTestAddresses.account;
+      const bytes = parser.nativeToBytes(stellarAddress);
+      const decoder = new TextDecoder();
+      const decoded = decoder.decode(bytes);
+      globalExpect(decoded).toBe(stellarAddress);
+    });
+    it("preserves address length in byte representation", () => {
+      const accountBytes = parser.nativeToBytes(validTestAddresses.account);
+      globalExpect(accountBytes.length).toBe(56);
+      const muxedBytes = parser.nativeToBytes(validTestAddresses.muxed);
+      globalExpect(muxedBytes.length).toBe(69);
+      const payloadBytes = parser.nativeToBytes(validTestAddresses.signedPayload);
+      globalExpect(payloadBytes.length).toBeGreaterThan(56);
+    });
+    it("normalizedToNativeString returns the address string", () => {
+      const stellarAddress = validTestAddresses.account;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const nativeString = parser.normalizedToNativeString(normalized);
+      globalExpect(nativeString).toBe(stellarAddress);
+    });
+  });
+  describe("parseNative", () => {
+    it("parses valid Stellar addresses", () => {
+      const stellarAddress = validTestAddresses.account;
+      const normalized = parser.parseNative(stellarAddress);
+      globalExpect(normalized).toMatch(/^0x[0-9a-f]+$/);
+    });
+    it("throws on invalid addresses", () => {
+      globalExpect(() => parser.parseNative("invalid-stellar-address")).toThrow(/Cannot convert/);
+    });
+    it("parseNativeToUnpaddedHex returns hex string", () => {
+      const stellarAddress = validTestAddresses.account;
+      const hex3 = parser.parseNativeToUnpaddedHex(stellarAddress);
+      globalExpect(hex3).toMatch(/^0x[0-9a-f]+$/);
+      globalExpect(hex3).toBe(parser.parseNative(stellarAddress));
+    });
+  });
+  describe("bytes32 operations", () => {
+    it("decodes account address (G...) to 32 bytes", () => {
+      const stellarAddress = validTestAddresses.account;
+      const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress);
+      const bytes32 = parser.nativeToBytes32(stellarAddress);
+      globalExpect(bytes32Hex.length).toBe(66);
+      globalExpect(bytes32Hex).toMatch(/^0x[0-9a-f]{64}$/);
+      globalExpect(bytes32.length).toBe(32);
+      globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+    it("decodes contract address (C...) to 32 bytes", () => {
+      const stellarAddress = validTestAddresses.contract;
+      const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress);
+      const bytes32 = parser.nativeToBytes32(stellarAddress);
+      globalExpect(bytes32Hex.length).toBe(66);
+      globalExpect(bytes32.length).toBe(32);
+      globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+    it("decodes liquidity pool address (L...) to 32 bytes", () => {
+      const stellarAddress = validTestAddresses.liquidityPool;
+      const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress);
+      const bytes32 = parser.nativeToBytes32(stellarAddress);
+      globalExpect(bytes32Hex.length).toBe(66);
+      globalExpect(bytes32.length).toBe(32);
+      globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+    it("decodes claimable balance address (B...) to 32 bytes (skipping version byte)", () => {
+      const stellarAddress = validTestAddresses.claimableBalance;
+      const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress);
+      const bytes32 = parser.nativeToBytes32(stellarAddress);
+      globalExpect(bytes32Hex.length).toBe(66);
+      globalExpect(bytes32Hex).toMatch(/^0x[0-9a-f]{64}$/);
+      globalExpect(bytes32.length).toBe(32);
+      globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+    it("throws error for muxed address (M...) - not 32 bytes", () => {
+      const stellarAddress = validTestAddresses.muxed;
+      globalExpect(() => parser.nativeToBytes32Hex(stellarAddress)).toThrow(/nativeToBytes32 is not supported for Stellar muxed addresses/);
+      globalExpect(() => parser.nativeToBytes32(stellarAddress)).toThrow(/nativeToBytes32 is not supported for Stellar muxed addresses/);
+    });
+    it("throws error for signed payload (P...) - variable length", () => {
+      const stellarAddress = validTestAddresses.signedPayload;
+      globalExpect(() => parser.nativeToBytes32Hex(stellarAddress)).toThrow(/nativeToBytes32 is not supported for Stellar signed payload addresses/);
+      globalExpect(() => parser.nativeToBytes32(stellarAddress)).toThrow(/nativeToBytes32 is not supported for Stellar signed payload addresses/);
+    });
+    it("returns undefined for undefined input", () => {
+      globalExpect(parser.nativeToBytes32Hex(void 0)).toBeUndefined();
+      globalExpect(parser.nativeToBytes32(void 0)).toBeUndefined();
+    });
+    it("decodes all supported address types to 32 bytes", () => {
+      const accountBytes = parser.nativeToBytes32(validTestAddresses.account);
+      const contractBytes = parser.nativeToBytes32(validTestAddresses.contract);
+      const poolBytes = parser.nativeToBytes32(validTestAddresses.liquidityPool);
+      const balanceBytes = parser.nativeToBytes32(validTestAddresses.claimableBalance);
+      globalExpect(accountBytes.length).toBe(32);
+      globalExpect(contractBytes.length).toBe(32);
+      globalExpect(poolBytes.length).toBe(32);
+      globalExpect(balanceBytes.length).toBe(32);
+      const accountHex = parser.nativeToBytes32Hex(validTestAddresses.account);
+      const contractHex = parser.nativeToBytes32Hex(validTestAddresses.contract);
+      const poolHex = parser.nativeToBytes32Hex(validTestAddresses.liquidityPool);
+      const balanceHex = parser.nativeToBytes32Hex(validTestAddresses.claimableBalance);
+      globalExpect(bytesToHexPrefixed(accountBytes)).toBe(accountHex);
+      globalExpect(bytesToHexPrefixed(contractBytes)).toBe(contractHex);
+      globalExpect(bytesToHexPrefixed(poolBytes)).toBe(poolHex);
+      globalExpect(bytesToHexPrefixed(balanceBytes)).toBe(balanceHex);
+    });
+    it("handles ChainNativeAddress objects for bytes32 operations", () => {
+      const nativeObj = {
+        chainName: ChainName.STELLAR,
+        nativeAddress: validTestAddresses.account
+      };
+      const bytes32Hex = parser.nativeToBytes32Hex(nativeObj);
+      const bytes32 = parser.nativeToBytes32(nativeObj);
+      globalExpect(bytes32Hex.length).toBe(66);
+      globalExpect(bytes32.length).toBe(32);
+    });
+  });
+  describe("address type preservation", () => {
+    it("preserves address type information through conversion", () => {
+      const addresses = [
+        {
+          addr: validTestAddresses.account,
+          prefix: "G"
+        },
+        {
+          addr: validTestAddresses.contract,
+          prefix: "C"
+        },
+        {
+          addr: validTestAddresses.muxed,
+          prefix: "M"
+        },
+        {
+          addr: validTestAddresses.liquidityPool,
+          prefix: "L"
+        },
+        {
+          addr: validTestAddresses.claimableBalance,
+          prefix: "B"
+        },
+        {
+          addr: validTestAddresses.signedPayload,
+          prefix: "P"
+        }
+      ];
+      addresses.forEach(({ addr, prefix }) => {
+        const normalized = parser.nativeToNormalized(addr);
+        const recovered = parser.normalizedToNative(normalized);
+        globalExpect(recovered.nativeAddress.startsWith(prefix)).toBe(true);
+        globalExpect(recovered.nativeAddress).toBe(addr);
+      });
+    });
+  });
+  describe("edge cases", () => {
+    it("handles ChainNativeAddress objects", () => {
+      const nativeObj = {
+        chainName: ChainName.STELLAR,
+        nativeAddress: validTestAddresses.account
+      };
+      const normalized = parser.nativeToNormalized(nativeObj);
+      globalExpect(normalized).toMatch(/^0x[0-9a-f]+$/);
+    });
+    it("returns undefined for undefined inputs", () => {
+      globalExpect(parser.normalizedToNative(void 0)).toBeUndefined();
+      globalExpect(parser.normalizedToNativeString(void 0)).toBeUndefined();
+      globalExpect(parser.nativeToNormalized(void 0)).toBeUndefined();
+      globalExpect(parser.nativeToBytes(void 0)).toBeUndefined();
+    });
+    it("handles different address lengths correctly", () => {
+      const short = validTestAddresses.account;
+      const shortBytes = parser.nativeToBytes(short);
+      globalExpect(shortBytes.length).toBe(56);
+      const medium = validTestAddresses.muxed;
+      const mediumBytes = parser.nativeToBytes(medium);
+      globalExpect(mediumBytes.length).toBe(69);
+      const long = validTestAddresses.signedPayload;
+      const longBytes = parser.nativeToBytes(long);
+      globalExpect(longBytes.length).toBeGreaterThan(69);
+    });
+  });
+  describe("encoding type", () => {
+    it("has STELLAR encoding type", () => {
+      globalExpect(parser.encoding).toBe("stellar");
+    });
+  });
+});
 /*! Bundled license information:
 
 @vitest/pretty-format/dist/index.js: