@layerzerolabs/chain-utils 0.0.67 → 0.0.73

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var K6ILVJZQ_cjs = require('./K6ILVJZQ.cjs');
+var QOTVRPBZ_cjs = require('./QOTVRPBZ.cjs');
 var NOJYY7DN_cjs = require('./NOJYY7DN.cjs');
 var J6P5K7DC_cjs = require('./J6P5K7DC.cjs');
 
@@ -9,27 +9,35 @@ J6P5K7DC_cjs.init_cjs_shims();
 
 Object.defineProperty(exports, "AddressEncoding", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.AddressEncoding; }
+  get: function () { return QOTVRPBZ_cjs.AddressEncoding; }
 });
 Object.defineProperty(exports, "addressParser", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.addressParser; }
+  get: function () { return QOTVRPBZ_cjs.addressParser; }
 });
 Object.defineProperty(exports, "base58AddressParser", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.base58AddressParser; }
+  get: function () { return QOTVRPBZ_cjs.base58AddressParser; }
 });
 Object.defineProperty(exports, "hexAddressParser", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.hexAddressParser; }
+  get: function () { return QOTVRPBZ_cjs.hexAddressParser; }
 });
 Object.defineProperty(exports, "initiaAddressParser", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.initiaAddressParser; }
+  get: function () { return QOTVRPBZ_cjs.initiaAddressParser; }
+});
+Object.defineProperty(exports, "starknetAddressParser", {
+  enumerable: true,
+  get: function () { return QOTVRPBZ_cjs.starknetAddressParser; }
+});
+Object.defineProperty(exports, "stellarAddressParser", {
+  enumerable: true,
+  get: function () { return QOTVRPBZ_cjs.stellarAddressParser; }
 });
 Object.defineProperty(exports, "tonAddressParser", {
   enumerable: true,
-  get: function () { return K6ILVJZQ_cjs.tonAddressParser; }
+  get: function () { return QOTVRPBZ_cjs.tonAddressParser; }
 });
 Object.defineProperty(exports, "getNetworkName", {
   enumerable: true,

package/dist/index.js

@@ -1,4 +1,4 @@
-export { AddressEncoding, addressParser, base58AddressParser, hexAddressParser, initiaAddressParser, tonAddressParser } from './MR2I35UU.js';
+export { AddressEncoding, addressParser, base58AddressParser, hexAddressParser, initiaAddressParser, starknetAddressParser, stellarAddressParser, tonAddressParser } from './L4WCMHVM.js';
 export { getNetworkName } from './FJIAQ3QL.js';
 import { init_esm_shims } from './YXE7PREU.js';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/chain-utils",
-  "version": "0.0.67",
+  "version": "0.0.73",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -15,20 +15,21 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "@initia/initia.js": "1.0.4",
+    "@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.0.67",
-    "@layerzerolabs/common-ton": "0.0.67",
-    "@layerzerolabs/layerzero-definitions": "0.0.67",
-    "@layerzerolabs/static-chain-info": "0.0.67",
-    "@layerzerolabs/common-utils": "0.0.67"
+    "@layerzerolabs/common-chain-model": "0.0.73",
+    "@layerzerolabs/common-ton": "0.0.73",
+    "@layerzerolabs/common-utils": "0.0.73",
+    "@layerzerolabs/static-chain-info": "0.0.73",
+    "@layerzerolabs/layerzero-definitions": "0.0.73"
   },
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.0.67",
-    "@layerzerolabs/typescript-configuration": "0.0.67",
-    "@layerzerolabs/typescript-utils": "0.0.67"
+    "@layerzerolabs/tsup-configuration": "0.0.73",
+    "@layerzerolabs/typescript-configuration": "0.0.73",
+    "@layerzerolabs/typescript-utils": "0.0.73"
   },
   "publishConfig": {
     "access": "restricted",

package/src/addressParser.test.ts

@@ -172,7 +172,7 @@ describe('addressParser - chain validation', () => {
         const result = parser.nativeToNormalized(randomAddress as any);
         expect(result).toBe(normalizeHex(randomAddress as any));
 
-        const padded = parser.nativeToBytes32Hex(randomAddress as any);
+        const padded = parser.nativeToBytes32Hex(randomAddress as any)!;
         expect(padded.length).toBe(66);
 
         const bytes = parser.nativeToBytes(randomAddress as any);
@@ -229,7 +229,7 @@ describe('addressParser - TON', () => {
             const byteLength = Math.floor(Math.random() * 32) + 1;
             const input = randomHex(byteLength);
             const native = parser.normalizedToNativeString(input);
-            const padded = parser.nativeToBytes32Hex(native);
+            const padded = parser.nativeToBytes32Hex(native)!;
 
             expect(padded.length).toBe(66); // 32 bytes -> 64 hex chars + 0x
 
@@ -267,3 +267,351 @@ describe('addressParser - TON', () => {
         expect(parser.validateNative('invalid-ton-address')).toBe(false);
     });
 });
+
+describe('addressParser - Stellar', () => {
+    const parser = addressParser(ChainName.STELLAR);
+
+    // Valid test addresses from SEP-0023 specification
+    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 as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+            expect(native.chainName).toBe(ChainName.STELLAR);
+        });
+
+        it('maintains roundtrip invariant for contract addresses (C...)', () => {
+            const stellarAddress = validTestAddresses.contract;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+        });
+
+        it('maintains roundtrip invariant for muxed addresses (M...)', () => {
+            const stellarAddress = validTestAddresses.muxed;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+        });
+
+        it('maintains roundtrip invariant for liquidity pool addresses (L...)', () => {
+            const stellarAddress = validTestAddresses.liquidityPool;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+        });
+
+        it('maintains roundtrip invariant for claimable balance addresses (B...)', () => {
+            const stellarAddress = validTestAddresses.claimableBalance;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+        });
+
+        it('maintains roundtrip invariant for signed payload (P...)', () => {
+            const stellarAddress = validTestAddresses.signedPayload;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const native = parser.normalizedToNative(normalized)!;
+
+            expect(native.nativeAddress).toBe(stellarAddress);
+        });
+    });
+
+    describe('validation', () => {
+        it('validates all valid Stellar address types', () => {
+            expect(parser.validateNative(validTestAddresses.account)).toBe(true);
+            expect(parser.validateNative(validTestAddresses.contract)).toBe(true);
+            expect(parser.validateNative(validTestAddresses.muxed)).toBe(true);
+            expect(parser.validateNative(validTestAddresses.liquidityPool)).toBe(true);
+            expect(parser.validateNative(validTestAddresses.claimableBalance)).toBe(true);
+            expect(parser.validateNative(validTestAddresses.signedPayload)).toBe(true);
+        });
+
+        it('rejects invalid Stellar addresses', () => {
+            // Invalid addresses from SEP-0023 test cases
+            const invalidAddresses = [
+                'GAAAAAAAACGC6', // Invalid length
+                'GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZA', // Invalid length
+                'G47QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVP2I', // Invalid algorithm
+                'invalid-stellar-address',
+                '',
+                '0x1234567890abcdef', // EVM address
+            ];
+
+            invalidAddresses.forEach((addr) => {
+                expect(parser.validateNative(addr)).toBe(false);
+            });
+        });
+
+        it('rejects undefined addresses', () => {
+            expect(parser.validateNative(undefined)).toBe(false);
+        });
+    });
+
+    describe('ASCII encoding/decoding', () => {
+        it('converts Stellar address to UTF-8 bytes correctly', () => {
+            const stellarAddress = validTestAddresses.account;
+            const bytes = parser.nativeToBytes(stellarAddress as any)!;
+
+            // Verify it's UTF-8 encoded ASCII
+            const decoder = new TextDecoder();
+            const decoded = decoder.decode(bytes);
+            expect(decoded).toBe(stellarAddress);
+        });
+
+        it('preserves address length in byte representation', () => {
+            // Account address (56 chars)
+            const accountBytes = parser.nativeToBytes(validTestAddresses.account as any)!;
+            expect(accountBytes.length).toBe(56);
+
+            // Muxed address (69 chars)
+            const muxedBytes = parser.nativeToBytes(validTestAddresses.muxed as any)!;
+            expect(muxedBytes.length).toBe(69);
+
+            // Signed payload (variable length)
+            const payloadBytes = parser.nativeToBytes(validTestAddresses.signedPayload as any)!;
+            expect(payloadBytes.length).toBeGreaterThan(56);
+        });
+
+        it('normalizedToNativeString returns the address string', () => {
+            const stellarAddress = validTestAddresses.account;
+            const normalized = parser.nativeToNormalized(stellarAddress as any);
+            const nativeString = parser.normalizedToNativeString(normalized);
+
+            expect(nativeString).toBe(stellarAddress);
+        });
+    });
+
+    describe('parseNative', () => {
+        it('parses valid Stellar addresses', () => {
+            const stellarAddress = validTestAddresses.account;
+            const normalized = parser.parseNative(stellarAddress as any);
+
+            // Should return normalized hex representation
+            expect(normalized).toMatch(/^0x[0-9a-f]+$/);
+        });
+
+        it('throws on invalid addresses', () => {
+            expect(() => parser.parseNative('invalid-stellar-address' as any)).toThrow(
+                /Cannot convert/,
+            );
+        });
+
+        it('parseNativeToUnpaddedHex returns hex string', () => {
+            const stellarAddress = validTestAddresses.account;
+            const hex = parser.parseNativeToUnpaddedHex(stellarAddress as any);
+
+            expect(hex).toMatch(/^0x[0-9a-f]+$/);
+            expect(hex).toBe(parser.parseNative(stellarAddress as any));
+        });
+    });
+
+    describe('bytes32 operations', () => {
+        it('decodes account address (G...) to 32 bytes', () => {
+            const stellarAddress = validTestAddresses.account;
+            const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress as any)!;
+            const bytes32 = parser.nativeToBytes32(stellarAddress as any)!;
+
+            // Should be 32 bytes (64 hex chars + 0x)
+            expect(bytes32Hex.length).toBe(66);
+            expect(bytes32Hex).toMatch(/^0x[0-9a-f]{64}$/);
+
+            // Bytes should be 32 bytes
+            expect(bytes32.length).toBe(32);
+
+            // Both methods should produce consistent results
+            expect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+        });
+
+        it('decodes contract address (C...) to 32 bytes', () => {
+            const stellarAddress = validTestAddresses.contract;
+            const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress as any)!;
+            const bytes32 = parser.nativeToBytes32(stellarAddress as any)!;
+
+            expect(bytes32Hex.length).toBe(66);
+            expect(bytes32.length).toBe(32);
+            expect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+        });
+
+        it('decodes liquidity pool address (L...) to 32 bytes', () => {
+            const stellarAddress = validTestAddresses.liquidityPool;
+            const bytes32Hex = parser.nativeToBytes32Hex(stellarAddress as any)!;
+            const bytes32 = parser.nativeToBytes32(stellarAddress as any)!;
+
+            expect(bytes32Hex.length).toBe(66);
+            expect(bytes32.length).toBe(32);
+            expect(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 as any)!;
+            const bytes32 = parser.nativeToBytes32(stellarAddress as any)!;
+
+            // Should be 32 bytes (64 hex chars + 0x)
+            expect(bytes32Hex.length).toBe(66);
+            expect(bytes32Hex).toMatch(/^0x[0-9a-f]{64}$/);
+
+            // Bytes should be 32 bytes (the hash, without the version byte)
+            expect(bytes32.length).toBe(32);
+
+            // Both methods should produce consistent results
+            expect(bytesToHexPrefixed(bytes32)).toBe(bytes32Hex);
+        });
+
+        it('throws error for muxed address (M...) - not 32 bytes', () => {
+            const stellarAddress = validTestAddresses.muxed;
+
+            expect(() => parser.nativeToBytes32Hex(stellarAddress as any)).toThrow(
+                /nativeToBytes32 is not supported for Stellar muxed addresses/,
+            );
+            expect(() => parser.nativeToBytes32(stellarAddress as any)).toThrow(
+                /nativeToBytes32 is not supported for Stellar muxed addresses/,
+            );
+        });
+
+        it('throws error for signed payload (P...) - variable length', () => {
+            const stellarAddress = validTestAddresses.signedPayload;
+
+            expect(() => parser.nativeToBytes32Hex(stellarAddress as any)).toThrow(
+                /nativeToBytes32 is not supported for Stellar signed payload addresses/,
+            );
+            expect(() => parser.nativeToBytes32(stellarAddress as any)).toThrow(
+                /nativeToBytes32 is not supported for Stellar signed payload addresses/,
+            );
+        });
+
+        it('returns undefined for undefined input', () => {
+            expect(parser.nativeToBytes32Hex(undefined as any)).toBeUndefined();
+            expect(parser.nativeToBytes32(undefined as any)).toBeUndefined();
+        });
+
+        it('decodes all supported address types to 32 bytes', () => {
+            // Account (G), contract (C), liquidity pool (L), and claimable balance (B) addresses can be converted to 32 bytes
+            const accountBytes = parser.nativeToBytes32(validTestAddresses.account as any)!;
+            const contractBytes = parser.nativeToBytes32(validTestAddresses.contract as any)!;
+            const poolBytes = parser.nativeToBytes32(validTestAddresses.liquidityPool as any)!;
+            const balanceBytes = parser.nativeToBytes32(
+                validTestAddresses.claimableBalance as any,
+            )!;
+
+            // All should be exactly 32 bytes
+            expect(accountBytes.length).toBe(32);
+            expect(contractBytes.length).toBe(32);
+            expect(poolBytes.length).toBe(32);
+            expect(balanceBytes.length).toBe(32);
+
+            // Should produce consistent hex conversions
+            const accountHex = parser.nativeToBytes32Hex(validTestAddresses.account as any)!;
+            const contractHex = parser.nativeToBytes32Hex(validTestAddresses.contract as any)!;
+            const poolHex = parser.nativeToBytes32Hex(validTestAddresses.liquidityPool as any)!;
+            const balanceHex = parser.nativeToBytes32Hex(
+                validTestAddresses.claimableBalance as any,
+            )!;
+
+            expect(bytesToHexPrefixed(accountBytes)).toBe(accountHex);
+            expect(bytesToHexPrefixed(contractBytes)).toBe(contractHex);
+            expect(bytesToHexPrefixed(poolBytes)).toBe(poolHex);
+            expect(bytesToHexPrefixed(balanceBytes)).toBe(balanceHex);
+        });
+
+        it('handles ChainNativeAddress objects for bytes32 operations', () => {
+            const nativeObj = {
+                chainName: ChainName.STELLAR,
+                nativeAddress: validTestAddresses.account,
+            };
+
+            const bytes32Hex = parser.nativeToBytes32Hex(nativeObj as any)!;
+            const bytes32 = parser.nativeToBytes32(nativeObj as any)!;
+
+            expect(bytes32Hex.length).toBe(66);
+            expect(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 as any);
+                const recovered = parser.normalizedToNative(normalized)!;
+
+                // Should preserve the prefix indicating address type
+                expect(recovered.nativeAddress.startsWith(prefix)).toBe(true);
+                expect(recovered.nativeAddress).toBe(addr);
+            });
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles ChainNativeAddress objects', () => {
+            const nativeObj = {
+                chainName: ChainName.STELLAR,
+                nativeAddress: validTestAddresses.account,
+            };
+
+            const normalized = parser.nativeToNormalized(nativeObj as any);
+            expect(normalized).toMatch(/^0x[0-9a-f]+$/);
+        });
+
+        it('returns undefined for undefined inputs', () => {
+            expect(parser.normalizedToNative(undefined as any)).toBeUndefined();
+            expect(parser.normalizedToNativeString(undefined as any)).toBeUndefined();
+            expect(parser.nativeToNormalized(undefined as any)).toBeUndefined();
+            expect(parser.nativeToBytes(undefined as any)).toBeUndefined();
+        });
+
+        it('handles different address lengths correctly', () => {
+            // 56-char addresses
+            const short = validTestAddresses.account;
+            const shortBytes = parser.nativeToBytes(short as any)!;
+            expect(shortBytes.length).toBe(56);
+
+            // 69-char addresses (muxed)
+            const medium = validTestAddresses.muxed;
+            const mediumBytes = parser.nativeToBytes(medium as any)!;
+            expect(mediumBytes.length).toBe(69);
+
+            // Variable-length (signed payload)
+            const long = validTestAddresses.signedPayload;
+            const longBytes = parser.nativeToBytes(long as any)!;
+            expect(longBytes.length).toBeGreaterThan(69);
+        });
+    });
+
+    describe('encoding type', () => {
+        it('has STELLAR encoding type', () => {
+            expect(parser.encoding).toBe('stellar');
+        });
+    });
+});