@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/sdk/test/index.test.ts

@@ -1,375 +0,0 @@
-import { Keypair, StrKey, TransactionBuilder } from '@stellar/stellar-sdk';
-import path from 'path';
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { $ } from 'zx';
-
-import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
-import { PacketSerializer, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities';
-
-import { Client as CounterClient } from '../src/generated/counter';
-import { Client as EndpointClient } from '../src/generated/endpoint';
-import { Client as ExecutorClient } from '../src/generated/executor';
-import { Client as ExecutorHelperClient } from '../src/generated/executor_helper';
-import { Client as SMLClient } from '../src/generated/sml';
-import {
-    DEFAULT_DEPLOYER,
-    EID,
-    MSG_TYPE_VANILLA,
-    NATIVE_TOKEN_ADDRESS,
-    NETWORK_PASSPHRASE,
-    ZRO_TOKEN_ADDRESS,
-} from './suites/constants';
-import { deployContract } from './suites/deploy';
-import { fundAccount, startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
-import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
-import { assertTransactionsSucceeded, signExecutorAuthEntries } from './utils';
-
-$.verbose = true;
-$.stdio = ['inherit', 'pipe', process.stderr];
-
-const CONTRACT_ADDRESSES = {
-    endpointV2: '',
-    sml: '',
-    counter: '',
-    executor: '',
-    executorHelper: '',
-};
-
-let endpointClient: EndpointClient;
-let smlClient: SMLClient;
-let counterClient: CounterClient;
-let executorClient: ExecutorClient;
-let executorHelperClient: ExecutorHelperClient;
-
-const EXECUTOR_ADMIN = Keypair.random();
-
-// NOTE: run `stellar contract build --features sandbox` before running the test
-
-describe('Protocol testing', async () => {
-    const repoRoot = await getFullyQualifiedRepoRootPath();
-    const wasmDir = path.join(
-        repoRoot,
-        'contracts',
-        'protocol',
-        'stellar',
-        'target',
-        'wasm32v1-none',
-        'release',
-    );
-
-    const ENDPOINT_WASM_PATH = path.join(wasmDir, 'endpoint_v2.wasm');
-    const SML_WASM_PATH = path.join(wasmDir, 'simple_message_lib.wasm');
-    const COUNTER_WASM_PATH = path.join(wasmDir, 'counter.wasm');
-    const EXECUTOR_WASM_PATH = path.join(wasmDir, 'executor.wasm');
-    const EXECUTOR_HELPER_WASM_PATH = path.join(wasmDir, 'executor_helper.wasm');
-
-    beforeAll(async () => {
-        await startStellarLocalnet();
-        await fundAccount(EXECUTOR_ADMIN.publicKey());
-    }, 120000); // 2 minute timeout for setup
-
-    afterAll(async () => {
-        await stopStellarLocalnet();
-    });
-
-    describe('Contract Deployments', () => {
-        it('Deploy Endpoint', async () => {
-            endpointClient = await deployContract<EndpointClient>(
-                EndpointClient,
-                ENDPOINT_WASM_PATH,
-                {
-                    eid: EID,
-                    owner: DEFAULT_DEPLOYER.publicKey(),
-                    native_token: NATIVE_TOKEN_ADDRESS,
-                },
-                DEFAULT_DEPLOYER,
-            );
-
-            CONTRACT_ADDRESSES.endpointV2 = endpointClient.options.contractId;
-            console.log('✅ Endpoint deployed:', CONTRACT_ADDRESSES.endpointV2);
-        });
-
-        it('Deploy SimpleMessageLib', async () => {
-            smlClient = await deployContract<SMLClient>(
-                SMLClient,
-                SML_WASM_PATH,
-                {
-                    owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: CONTRACT_ADDRESSES.endpointV2,
-                    fee_recipient: DEFAULT_DEPLOYER.publicKey(),
-                },
-                DEFAULT_DEPLOYER,
-            );
-
-            CONTRACT_ADDRESSES.sml = smlClient.options.contractId;
-            console.log('✅ SimpleMessageLib deployed:', CONTRACT_ADDRESSES.sml);
-        });
-
-        it('Deploy Executor Helper', async () => {
-            // Deploy ExecutorHelper first (it's stateless) so we can pass it to Executor
-            executorHelperClient = await deployContract<ExecutorHelperClient>(
-                ExecutorHelperClient,
-                EXECUTOR_HELPER_WASM_PATH,
-                undefined,
-                DEFAULT_DEPLOYER,
-            );
-            CONTRACT_ADDRESSES.executorHelper = executorHelperClient.options.contractId;
-            console.log('✅ Executor Helper deployed:', CONTRACT_ADDRESSES.executorHelper);
-        });
-
-        it('Deploy Executor', async () => {
-            // Whitelist ExecutorHelper entry points
-            const whitelist = [
-                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'native_drop_and_execute' },
-                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'execute' },
-                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'compose' },
-            ];
-
-            executorClient = await deployContract<ExecutorClient>(
-                ExecutorClient,
-                EXECUTOR_WASM_PATH,
-                {
-                    owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: CONTRACT_ADDRESSES.endpointV2,
-                    whitelist,
-                    admins: [EXECUTOR_ADMIN.publicKey()],
-                    message_libs: [CONTRACT_ADDRESSES.sml],
-                    // FIXME: Add price feed
-                    price_feed: CONTRACT_ADDRESSES.endpointV2,
-                    default_multiplier_bps: 10000,
-                },
-                DEFAULT_DEPLOYER,
-            );
-            CONTRACT_ADDRESSES.executor = executorClient.options.contractId;
-            console.log('✅ Executor deployed:', CONTRACT_ADDRESSES.executor);
-        });
-
-        it('Deploy Counter', async () => {
-            counterClient = await deployContract<CounterClient>(
-                CounterClient,
-                COUNTER_WASM_PATH,
-                {
-                    owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: CONTRACT_ADDRESSES.endpointV2,
-                    delegate: DEFAULT_DEPLOYER.publicKey(),
-                },
-                DEFAULT_DEPLOYER,
-            );
-
-            CONTRACT_ADDRESSES.counter = counterClient.options.contractId;
-            console.log('✅ Counter deployed:', CONTRACT_ADDRESSES.counter);
-        });
-
-        it('Verify all contracts deployed', () => {
-            console.log('\n📋 All deployed contracts:');
-            console.log('  Endpoint:', CONTRACT_ADDRESSES.endpointV2);
-            console.log('  SimpleMessageLib:', CONTRACT_ADDRESSES.sml);
-            console.log('  Counter:', CONTRACT_ADDRESSES.counter);
-            console.log('  Executor:', CONTRACT_ADDRESSES.executor);
-            console.log('  Executor Helper:', CONTRACT_ADDRESSES.executorHelper);
-        });
-    });
-
-    describe('Wire Contracts', async () => {
-        it('Register Library', async () => {
-            const assembledTx = await endpointClient.register_library({
-                new_lib: CONTRACT_ADDRESSES.sml,
-            });
-            await assembledTx.signAndSend();
-            const { result: libs } = await endpointClient.get_registered_libraries({
-                start: 0,
-                max_count: 100,
-            });
-            expect(libs.length).toBe(1);
-            expect(libs[0]).toBe(CONTRACT_ADDRESSES.sml);
-            console.log('✅ Library registered');
-        });
-
-        it('Set Default Send Library', async () => {
-            const assembledTx = await endpointClient.set_default_send_library({
-                dst_eid: EID,
-                new_lib: CONTRACT_ADDRESSES.sml,
-            });
-            await assembledTx.signAndSend();
-            const { result: defaultSendLib } = await endpointClient.default_send_library({
-                dst_eid: EID,
-            });
-            expect(defaultSendLib).toBe(CONTRACT_ADDRESSES.sml);
-            console.log('✅ Default send library set');
-        });
-
-        it('Set Default Receive Library', async () => {
-            const assembledTx = await endpointClient.set_default_receive_library({
-                src_eid: EID,
-                new_lib: CONTRACT_ADDRESSES.sml,
-                grace_period: 0n,
-            });
-            await assembledTx.signAndSend();
-            const { result: defaultReceiveLib } = await endpointClient.default_receive_library({
-                src_eid: EID,
-            });
-            expect(defaultReceiveLib).toBe(CONTRACT_ADDRESSES.sml);
-            console.log('✅ Default receive library set');
-        });
-
-        it('Set ZRO Token (Required even for 0 fee)', async () => {
-            const setZroTx = await endpointClient.set_zro({
-                zro: ZRO_TOKEN_ADDRESS,
-            });
-            await setZroTx.signAndSend();
-
-            const { result: newZroToken } = await endpointClient.zro();
-            expect(newZroToken).toBe(ZRO_TOKEN_ADDRESS);
-            console.log('✅ ZRO token set:', ZRO_TOKEN_ADDRESS);
-        });
-
-        it('Set Counter Peer', async () => {
-            const peerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.counter);
-
-            const assembledTx = await counterClient.set_peer({
-                eid: EID,
-                peer: Buffer.from(peerBytes),
-            });
-            await assembledTx.signAndSend();
-
-            const { result: peer } = await counterClient.peer({
-                eid: EID,
-            });
-            expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
-            console.log('✅ Counter peer set for EID', EID);
-        });
-    });
-
-    describe('Counter', async () => {
-        let incrementLedger = 0;
-        let packetSentEvent: PacketSentEvent;
-        let guid: Buffer;
-        let message: Buffer;
-        it('Counter Increment', async () => {
-            const { result: fee } = await counterClient.quote({
-                dst_eid: EID,
-                msg_type: MSG_TYPE_VANILLA,
-                options: Buffer.from([]),
-                pay_in_zro: true,
-            });
-            console.log('✅ Fee:', fee);
-
-            const assembledTx = await counterClient.increment({
-                caller: DEFAULT_DEPLOYER.publicKey(),
-                dst_eid: EID,
-                msg_type: MSG_TYPE_VANILLA,
-                options: Buffer.from([]),
-                fee: fee,
-            });
-            const sentTx = await assembledTx.signAndSend();
-
-            // Extract ledger number from transaction response
-            const txResponse = sentTx.getTransactionResponse;
-            if (txResponse && 'ledger' in txResponse) {
-                incrementLedger = txResponse.ledger;
-            }
-
-            const { result: outboundCount } = await counterClient.outbound_count({
-                eid: EID,
-            });
-            expect(outboundCount).toBe(1n);
-            console.log('✅ Counter incremented, outbound count:', outboundCount);
-        });
-
-        it('Scan PacketSent Events', async () => {
-            const packetSentEvents = await scanPacketSentEvents(
-                CONTRACT_ADDRESSES.endpointV2,
-                incrementLedger,
-            );
-            expect(packetSentEvents.length).toBeGreaterThan(0);
-            packetSentEvent = packetSentEvents[0];
-            console.log(
-                `✅ PacketSent events scanned successfully. Found ${packetSentEvents.length} events`,
-            );
-        });
-
-        it('Verify Counter Message', async () => {
-            const packet = PacketSerializer.deserialize(packetSentEvent.encoded_packet);
-            guid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
-            message = Buffer.from(packet.message.replace('0x', ''), 'hex');
-            const codec = PacketV1Codec.from(packet);
-            const packetHeader = codec.header();
-            const payloadHash = codec.payloadHash();
-            const assembledTx = await smlClient.validate_packet({
-                // caller: DEFAULT_DEPLOYER.publicKey(),
-                header_bytes: Buffer.from(packetHeader.replace('0x', ''), 'hex'),
-                payload_hash: Buffer.from(payloadHash.replace('0x', ''), 'hex'),
-            });
-            await assembledTx.signAndSend();
-        });
-
-        it('Receive Counter Message (with native_drop)', async () => {
-            // Use native_drop_and_execute to test both native_drop and lz_receive
-            const origin = {
-                nonce: 1n,
-                sender: Buffer.from(StrKey.decodeContract(CONTRACT_ADDRESSES.counter)),
-                src_eid: EID,
-            };
-
-            const assembledTx = await executorHelperClient.native_drop_and_execute({
-                executor: CONTRACT_ADDRESSES.executor,
-                admin: EXECUTOR_ADMIN.publicKey(),
-                origin,
-                dst_eid: EID,
-                oapp: CONTRACT_ADDRESSES.counter,
-                // Native drop: send 100 stroops to counter contract
-                native_drop_params: [
-                    {
-                        receiver: CONTRACT_ADDRESSES.counter,
-                        amount: 100n,
-                    },
-                ],
-                execute_params: {
-                    extra_data: Buffer.from([]),
-                    gas_limit: 0n,
-                    guid,
-                    message,
-                    origin,
-                    receiver: CONTRACT_ADDRESSES.counter,
-                    value: 11n,
-                },
-            });
-
-            // Step 1: Sign the Executor's auth entries with the admin address as signature
-            await signExecutorAuthEntries(
-                CONTRACT_ADDRESSES.executor,
-                EXECUTOR_ADMIN,
-                assembledTx,
-                NETWORK_PASSPHRASE,
-            );
-
-            // Step 2: Sign and send the transaction by Executor Admin
-            const sentTx = await assembledTx.signAndSend();
-
-            // Assert that the transaction success
-            assertTransactionsSucceeded(sentTx, 'LzReceive');
-
-            const txResponse = sentTx.getTransactionResponse;
-            // Extract and print the transaction fee from the result
-            if (txResponse && 'envelopeXdr' in txResponse && txResponse.envelopeXdr) {
-                try {
-                    const txXdr = txResponse.envelopeXdr.toXDR('base64');
-                    const parsedTx = TransactionBuilder.fromXDR(txXdr, NETWORK_PASSPHRASE);
-                    const fee = parsedTx.fee;
-                    console.log(
-                        `💰 lz_receive transaction fee: ${fee} stroops (${(Number(fee) / 10000000).toFixed(7)} XLM)`,
-                    );
-                } catch (_e) {
-                    // Ignore if we can't extract the fee
-                }
-            }
-
-            // Verify the message was received
-            const { result: inboundCount } = await counterClient.inbound_count({
-                eid: EID,
-            });
-            expect(inboundCount).toBe(1n);
-            console.log('✅ Counter message received, inbox count:', inboundCount);
-        });
-    });
-});