@layerzerolabs/chain-utils 0.2.58 → 0.2.60

package/dist/addressParser.test.js

@@ -1,8 +1,8 @@
-import { addressParser } from './3457WEGJ.js';
+import { addressParser } from './OVN7SCH2.js';
 import { __commonJS, init_esm_shims, __name, __toESM } from './CWKWODSW.js';
 import * as bs58 from 'bs58';
 import { isatty } from 'tty';
-import { normalizeHex } from '@layerzerolabs/common-chain-model';
+import { normalizeHex, NORMALIZED_HEX_ZERO } from '@layerzerolabs/common-chain-model';
 import { hexToBytes, hexZeroPad, bytesToHexPrefixed } from '@layerzerolabs/common-encoding-utils';
 import { ChainName } from '@layerzerolabs/layerzero-definitions';
 
@@ -18131,7 +18131,7 @@ describe("addressParser - hex/EVM chains", () => {
     runPropertyTest(() => {
       const byteLength = Math.floor(Math.random() * 32) + 1;
       const input = randomHex(byteLength);
-      const padded = addressParser.normalizedToBytes32Hex(input);
+      const padded = addressParser(ChainName.ETHEREUM).normalizedToBytes32Hex(input);
       globalExpect(padded.length).toBe(66);
       globalExpect(padded).toBe(hexZeroPad(input, 32));
     });
@@ -18467,6 +18467,23 @@ describe("addressParser - Stellar", () => {
       globalExpect(bytes32.length).toBe(32);
     });
   });
+  describe("normalizedToBytes32 operations", () => {
+    it("produces same result as nativeToBytes32Hex for contract address (C...)", () => {
+      const stellarAddress = validTestAddresses.contract;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const fromNative = parser.nativeToBytes32Hex(stellarAddress);
+      const fromNormalized = parser.normalizedToBytes32Hex(normalized);
+      globalExpect(fromNormalized).toBe(fromNative);
+    });
+    it("normalizedToBytes32 returns correct Uint8Array", () => {
+      const stellarAddress = validTestAddresses.account;
+      const normalized = parser.nativeToNormalized(stellarAddress);
+      const bytes32Hex = parser.normalizedToBytes32Hex(normalized);
+      const bytes32 = parser.normalizedToBytes32(normalized);
+      globalExpect(bytes32.length).toBe(32);
+      globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+    });
+  });
   describe("address type preservation", () => {
     it("preserves address type information through conversion", () => {
       const addresses = [
@@ -18536,6 +18553,153 @@ describe("addressParser - Stellar", () => {
     });
   });
 });
+describe("addressParser - normalizedToBytes32Hex (cross-chain)", () => {
+  const testCases = [
+    {
+      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 p3 = addressParser(chainName);
+      const normalized = p3.nativeToNormalized(nativeAddr);
+      const fromNormalized = p3.normalizedToBytes32Hex(normalized);
+      const fromNative = p3.nativeToBytes32Hex(nativeAddr);
+      globalExpect(fromNormalized).toBe(fromNative);
+      globalExpect(fromNormalized.length).toBe(66);
+      globalExpect(fromNormalized).toMatch(/^0x[0-9a-f]{64}$/);
+    });
+  });
+  it("normalizedToBytes32Hex is consistent across chain parsers for \u226432 byte hex", () => {
+    const evmParser = addressParser(ChainName.ETHEREUM);
+    const solanaParser = addressParser(ChainName.SOLANA);
+    const normalized = normalizeHex("0x1234567890abcdef1234567890abcdef12345678");
+    globalExpect(evmParser.normalizedToBytes32Hex(normalized)).toBe(solanaParser.normalizedToBytes32Hex(normalized));
+  });
+  it("normalizedToBytes32 returns correct Uint8Array", () => {
+    const p3 = addressParser(ChainName.ETHEREUM);
+    const normalized = normalizeHex("0x1234567890abcdef1234567890abcdef12345678");
+    const bytes32Hex = p3.normalizedToBytes32Hex(normalized);
+    const bytes32 = p3.normalizedToBytes32(normalized);
+    globalExpect(bytes32.length).toBe(32);
+    globalExpect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+  });
+  it("returns undefined for undefined input", () => {
+    const p3 = addressParser(ChainName.ETHEREUM);
+    globalExpect(p3.normalizedToBytes32Hex(void 0)).toBeUndefined();
+    globalExpect(p3.normalizedToBytes32(void 0)).toBeUndefined();
+  });
+});
+describe("addressParser - bytes32ToNormalized", () => {
+  const ZERO_BYTES32 = "0x" + "00".repeat(32);
+  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 p3 = addressParser(chainName);
+        const normalized = p3.nativeToNormalized(native);
+        const bytes32Hex = p3.nativeToBytes32Hex(native);
+        globalExpect(p3.bytes32ToNormalized(bytes32Hex)).toBe(normalized);
+      });
+    });
+    it("Stellar contract: round-trip", () => {
+      const p3 = addressParser(ChainName.STELLAR);
+      const contractAddr = "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUWDA";
+      const normalized = p3.nativeToNormalized(contractAddr);
+      const bytes32Hex = p3.nativeToBytes32Hex(contractAddr);
+      globalExpect(p3.bytes32ToNormalized(bytes32Hex)).toBe(normalized);
+    });
+  });
+  it("undefined input returns undefined", () => {
+    const p3 = addressParser(ChainName.ETHEREUM);
+    globalExpect(p3.bytes32ToNormalized(void 0)).toBeUndefined();
+  });
+  it("non-Stellar: bytes32ToNative === normalizeHex for same input", () => {
+    const chains = [
+      ChainName.ETHEREUM,
+      ChainName.SOLANA,
+      ChainName.TON,
+      ChainName.STARKNET
+    ];
+    const bytes32 = "0x0000000000000000000000001234567890abcdef1234567890abcdef12345678";
+    chains.forEach((chainName) => {
+      globalExpect(addressParser(chainName).bytes32ToNormalized(bytes32)).toBe(normalizeHex(bytes32));
+    });
+  });
+  it("zero bytes32: EVM returns NORMALIZED_HEX_ZERO", () => {
+    const p3 = addressParser(ChainName.ETHEREUM);
+    globalExpect(p3.bytes32ToNormalized(ZERO_BYTES32)).toBe(NORMALIZED_HEX_ZERO);
+  });
+  it("zero bytes32: Stellar returns C-address for zero contract ID (not undefined)", () => {
+    const p3 = addressParser(ChainName.STELLAR);
+    const result = p3.bytes32ToNormalized(ZERO_BYTES32);
+    globalExpect(result).toBeDefined();
+    globalExpect(result).not.toBe(NORMALIZED_HEX_ZERO);
+  });
+});
 /*! Bundled license information:
 
 @vitest/pretty-format/dist/index.js: