@layerzerolabs/common-canton 1.2.69 → 1.2.71

package/test/client/topology/utils.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { buildChannelCredentials } from '../../../src/client/topology/utils';
-
-describe('admin API channel credentials', () => {
-    it('encrypts a conventional admin port', () => {
-        expect(buildChannelCredentials('participant.example.com:5002')._isSecure()).toBe(true);
-    });
-
-    it('encrypts the HTTPS port', () => {
-        expect(buildChannelCredentials('participant.example.com:443')._isSecure()).toBe(true);
-    });
-
-    it('encrypts a loopback host by default', () => {
-        expect(buildChannelCredentials('localhost:2902')._isSecure()).toBe(true);
-    });
-
-    it('drops encryption for a loopback name', () => {
-        expect(buildChannelCredentials('localhost:2902', true)._isSecure()).toBe(false);
-    });
-
-    it('drops encryption for a loopback address', () => {
-        expect(buildChannelCredentials('127.0.0.1:2902', true)._isSecure()).toBe(false);
-    });
-
-    it('drops encryption for a bracketed IPv6 loopback address', () => {
-        expect(buildChannelCredentials('[::1]:2902', true)._isSecure()).toBe(false);
-    });
-
-    it('rejects an unencrypted channel to a remote host', () => {
-        expect(() => buildChannelCredentials('participant.example.com:5002', true)).toThrow(
-            /requires an encrypted channel/,
-        );
-    });
-
-    it('rejects an unencrypted channel to a host merely named after loopback', () => {
-        expect(() => buildChannelCredentials('localhost.example.com:5002', true)).toThrow(
-            /requires an encrypted channel/,
-        );
-    });
-
-    it('rejects an unencrypted channel to a public address in the loopback range shape', () => {
-        expect(() => buildChannelCredentials('128.0.0.1:2902', true)).toThrow(
-            /requires an encrypted channel/,
-        );
-    });
-});

package/test/crypto.test.ts

@@ -1,52 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-    derEncodeSignature,
-    publicKeyToSpkiDer,
-    SECP256K1_SPKI_DER_HEADER,
-    SECP256K1_SPKI_DER_HEADER_HEX,
-} from '../src/crypto';
-
-// A throwaway uncompressed secp256k1 public key shape (0x04 ‖ X ‖ Y, 65 bytes).
-const UNCOMPRESSED_KEY = `04${'ab'.repeat(64)}`;
-
-describe('SECP256K1_SPKI_DER_HEADER', () => {
-    it('is the canonical 23-byte secp256k1 SPKI-DER header', () => {
-        expect(SECP256K1_SPKI_DER_HEADER).toHaveLength(23);
-        expect(SECP256K1_SPKI_DER_HEADER_HEX).toBe(
-            '3056301006072a8648ce3d020106052b8104000a034200',
-        );
-        expect(SECP256K1_SPKI_DER_HEADER_HEX).toHaveLength(46);
-    });
-});
-
-describe('publicKeyToSpkiDer', () => {
-    it('prepends the SPKI-DER header to the uncompressed key body', () => {
-        const spki = publicKeyToSpkiDer(`0x${UNCOMPRESSED_KEY}`);
-        expect(spki).toBe(SECP256K1_SPKI_DER_HEADER_HEX + UNCOMPRESSED_KEY);
-        expect(spki).toHaveLength(46 + 130);
-    });
-
-    it('lowercases and tolerates a missing 0x prefix', () => {
-        expect(publicKeyToSpkiDer(UNCOMPRESSED_KEY.toUpperCase())).toBe(
-            SECP256K1_SPKI_DER_HEADER_HEX + UNCOMPRESSED_KEY,
-        );
-    });
-
-    it('rejects a non-uncompressed (wrong-length or non-0x04) key', () => {
-        expect(() => publicKeyToSpkiDer('0x02abcd')).toThrow();
-        expect(() => publicKeyToSpkiDer(`03${'ab'.repeat(64)}`)).toThrow();
-    });
-});
-
-describe('derEncodeSignature', () => {
-    it('DER-encodes (r, s) as SEQUENCE { INTEGER r, INTEGER s } with minimal integers', () => {
-        // r = 1, s = 2 → 30 06 02 01 01 02 01 02
-        expect(derEncodeSignature('01', '02')).toBe('3006020101020102');
-    });
-
-    it('prepends 0x00 to an integer whose high bit is set', () => {
-        // r = 0xff (high bit set, needs a leading 0x00), s = 1
-        expect(derEncodeSignature('ff', '01')).toBe('3007020200ff020101');
-    });
-});

package/test/daml-serde.test.ts

@@ -1,140 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import {
-    assertHexLength,
-    codePointLength,
-    formatDamlDecimal,
-    intToHex,
-    keccak256Hex,
-    padLeft,
-    showBool,
-    showInt,
-    textToHex,
-    timeToUnixSeconds,
-    toBigInt,
-} from '../src/daml-serde';
-import { IntLikeSchema } from '../src/types';
-
-describe('toBigInt', () => {
-    it('passes through bigints and converts safe-integer numbers', () => {
-        expect(toBigInt(5)).toBe(5n);
-        expect(toBigInt(7n)).toBe(7n);
-    });
-
-    it('rejects unsafe-integer numbers', () => {
-        expect(() => toBigInt(2 ** 53)).toThrow(/safe integer/);
-    });
-});
-
-describe('IntLikeSchema', () => {
-    it('accepts bigints and safe-integer numbers (incl. negatives)', () => {
-        expect(IntLikeSchema.parse(5)).toBe(5);
-        expect(IntLikeSchema.parse(-5)).toBe(-5);
-        expect(IntLikeSchema.parse(2n ** 64n)).toBe(2n ** 64n);
-    });
-
-    it('rejects unsafe-integer numbers (must use a bigint)', () => {
-        expect(IntLikeSchema.safeParse(2 ** 53).success).toBe(false);
-    });
-});
-
-describe('textToHex', () => {
-    it('encodes ASCII two hex digits per char', () => {
-        expect(textToHex('01')).toBe('3031');
-        expect(textToHex('setSeed')).toBe('73657453656564');
-    });
-
-    it('rejects non-ASCII code points', () => {
-        expect(() => textToHex('café')).toThrow(/Non-ASCII/);
-    });
-});
-
-describe('intToHex', () => {
-    it('is minimal and lowercase', () => {
-        expect(intToHex(0)).toBe('0');
-        expect(intToHex(255)).toBe('ff');
-        expect(intToHex(2n ** 63n - 1n)).toBe('7fffffffffffffff');
-    });
-
-    it('rejects negative values', () => {
-        expect(() => intToHex(-1)).toThrow(/negative/);
-    });
-});
-
-describe('padLeft', () => {
-    it('left-pads with zeros and rejects oversize values', () => {
-        expect(padLeft(16, '15180')).toBe('0000000000015180');
-        expect(() => padLeft(2, 'abc')).toThrow(/exceeds pad width/);
-    });
-});
-
-describe('assertHexLength', () => {
-    it('returns stripped lowercase hex of the exact length', () => {
-        expect(assertHexLength(4, '0xABcd')).toBe('abcd');
-    });
-
-    it('rejects wrong length, odd length, and non-hex', () => {
-        expect(() => assertHexLength(4, 'abc')).toThrow();
-        expect(() => assertHexLength(4, 'abcde')).toThrow();
-        expect(() => assertHexLength(4, 'zzzz')).toThrow();
-    });
-});
-
-describe('show helpers', () => {
-    it('showBool capitalizes like DAML', () => {
-        expect(showBool(true)).toBe('True');
-        expect(showBool(false)).toBe('False');
-    });
-
-    it('showInt is base-10', () => {
-        expect(showInt(0)).toBe('0');
-        expect(showInt(-5)).toBe('-5');
-        expect(showInt(123n)).toBe('123');
-    });
-});
-
-describe('formatDamlDecimal', () => {
-    it('keeps at least one fractional digit and strips trailing zeros', () => {
-        expect(formatDamlDecimal('1.50')).toBe('1.5');
-        expect(formatDamlDecimal('100')).toBe('100.0');
-        expect(formatDamlDecimal('0')).toBe('0.0');
-        expect(formatDamlDecimal('-1.5')).toBe('-1.5');
-    });
-
-    it('rejects more than 10 fractional digits and exponent notation', () => {
-        expect(() => formatDamlDecimal('0.123456789012')).toThrow();
-        expect(() => formatDamlDecimal(1e-12)).toThrow();
-    });
-});
-
-describe('keccak256Hex', () => {
-    it('hashes the bytes denoted by the hex string', () => {
-        // keccak256 of the empty byte string.
-        expect(keccak256Hex('')).toBe(
-            'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
-        );
-        // keccak256 of the single byte 0x00.
-        expect(keccak256Hex('00')).toBe(
-            'bc36789e7a1e281436464229828f817d6612f7b477d66591ff96a9e064bcc98a',
-        );
-    });
-
-    it('rejects malformed hex rather than hashing raw text', () => {
-        expect(() => keccak256Hex('xyz')).toThrow(/valid hex/);
-        expect(() => keccak256Hex('abc')).toThrow(/valid hex/);
-    });
-});
-
-describe('codePointLength', () => {
-    it('counts Unicode code points', () => {
-        expect(codePointLength('alice')).toBe(5);
-        expect(codePointLength('𝔸')).toBe(1);
-    });
-});
-
-describe('timeToUnixSeconds', () => {
-    it('returns whole seconds since the unix epoch', () => {
-        expect(timeToUnixSeconds(new Date('1970-01-01T00:00:01.000Z'))).toBe(1n);
-        expect(timeToUnixSeconds(new Date('2021-01-01T00:00:00.000Z'))).toBe(1609459200n);
-    });
-});

package/test/deferredValue.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { NonRetryableError } from '@layerzerolabs/common-error-utils';
-
-import {
-    CANTON_DEFERRED_SENDER,
-    isCantonDeferredSender,
-    isCantonDeferredSentinel,
-    isCantonPlaceholder,
-    parseCantonDeferredValue,
-    parseCantonDeferredValueOrThrow,
-} from '../src/deferredValue';
-
-describe('CANTON_DEFERRED_SENDER', () => {
-    it('is the typed sender token', () => {
-        expect(isCantonDeferredSender(CANTON_DEFERRED_SENDER)).toBe(true);
-        expect(isCantonDeferredSender('alice::1220ab')).toBe(false);
-    });
-});
-
-describe('parseCantonDeferredValueOrThrow', () => {
-    it('returns undefined for non-sentinels', () => {
-        expect(parseCantonDeferredValueOrThrow('00abc')).toBeUndefined();
-        expect(parseCantonDeferredValueOrThrow({ type: 'senderParty' })).toBeUndefined();
-    });
-
-    it('parses a valid sentinel', () => {
-        expect(
-            parseCantonDeferredValueOrThrow('<<CANTON_DEFERRED:{"type":"senderParty"}>>'),
-        ).toEqual({ type: 'senderParty' });
-    });
-
-    it('throws NonRetryableError for a framed but invalid sentinel', () => {
-        const malformed = '<<CANTON_DEFERRED:{"type":"activeContractId","templateId":"#pkg:T"}>>';
-        expect(isCantonDeferredSentinel(malformed)).toBe(true);
-        expect(parseCantonDeferredValue(malformed)).toBeUndefined();
-        expect(isCantonPlaceholder(malformed)).toBe(false);
-        expect(() => parseCantonDeferredValueOrThrow(malformed)).toThrow(NonRetryableError);
-    });
-});

package/test/events.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { findMatchingCreatedEvent } from '../src/events';
-import type { CreatedEvent } from '../src/open-api/models';
-
-const OFT_ADMIN = 'oft-admin::namespace';
-const OTHER = 'other::namespace';
-const LEDGER_OFT_SELF = '1220deadbeef:OftSelf:OftSelf';
-const PACKAGE_NAME_OFT_SELF = '#layerzero-oft:OftSelf:OftSelf';
-
-const createdEvent = (templateId: string, signatories = [OFT_ADMIN]): CreatedEvent => ({
-    offset: 1,
-    nodeId: 0,
-    contractId: `cid-${templateId}`,
-    templateId,
-    createArgument: { instrumentId: { admin: OFT_ADMIN, id: 'OFT' } },
-    createdEventBlob: '',
-    signatories,
-    observers: [],
-    createdAt: '',
-    packageName: 'layerzero-oft',
-    representativePackageId: '1220deadbeef',
-    acsDelta: true,
-});
-
-describe('findMatchingCreatedEvent', () => {
-    it.each([
-        { name: 'its #package-name form', expectedTemplateId: PACKAGE_NAME_OFT_SELF },
-        { name: 'the identical package-id form', expectedTemplateId: LEDGER_OFT_SELF },
-    ])('matches a package-id ledger event against $name', ({ expectedTemplateId }) => {
-        const event = createdEvent(LEDGER_OFT_SELF);
-        expect(findMatchingCreatedEvent([event], expectedTemplateId, [OFT_ADMIN])).toBe(event);
-    });
-
-    it.each([
-        {
-            name: 'a different template in the same package',
-            event: createdEvent('1220deadbeef:OftSelfConfig:OftSelfConfig'),
-        },
-        {
-            name: 'the same entity name in a different module',
-            event: createdEvent('1220deadbeef:OftSelfConfig:OftSelf'),
-        },
-        {
-            name: 'a signatory outside the expected parties',
-            event: createdEvent(LEDGER_OFT_SELF, [OFT_ADMIN, OTHER]),
-        },
-        { name: 'no signatories', event: createdEvent(LEDGER_OFT_SELF, []) },
-    ])('rejects an event with $name', ({ event }) => {
-        expect(
-            findMatchingCreatedEvent([event], PACKAGE_NAME_OFT_SELF, [OFT_ADMIN]),
-        ).toBeUndefined();
-    });
-});