@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/sdk/test/counter-sml.test.ts

@@ -0,0 +1,376 @@
+import { StrKey } from '@stellar/stellar-sdk';
+import path from 'path';
+import { beforeAll, describe, expect, inject, it } from 'vitest';
+
+import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
+import { Options, 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 ExecutorHelperClient } from '../src/generated/executor_helper';
+import { Client as SMLClient } from '../src/generated/sml';
+import {
+    DEFAULT_DEPLOYER,
+    EID,
+    EXECUTOR_ADMIN,
+    MSG_TYPE_ABA,
+    MSG_TYPE_VANILLA,
+    NETWORK_PASSPHRASE,
+} from './suites/constants';
+import { deployContract } from './suites/deploy';
+import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
+import { assertTransactionSucceeded, createClient, signAndSendWithExecutorAuth } from './utils';
+
+// Protocol addresses (will be injected from globalSetup in beforeAll)
+let protocolAddresses: ReturnType<typeof inject<'protocolAddresses'>>;
+
+// Counter-specific address
+let counterAddress = '';
+
+// Clients
+let endpointClient: EndpointClient;
+let smlClient: SMLClient;
+let counterClient: CounterClient;
+let executorHelperClient: ExecutorHelperClient;
+
+// NOTE: run `stellar contract build --features sandbox` before running the test
+
+describe('Counter with SML testing', async () => {
+    const repoRoot = await getFullyQualifiedRepoRootPath();
+    const wasmDir = path.join(
+        repoRoot,
+        'contracts',
+        'protocol',
+        'stellar',
+        'target',
+        'wasm32v1-none',
+        'release',
+    );
+
+    const COUNTER_WASM_PATH = path.join(wasmDir, 'counter.wasm');
+
+    beforeAll(async () => {
+        // Inject protocol addresses from globalSetup
+        protocolAddresses = inject('protocolAddresses');
+
+        console.log('\n📋 Protocol addresses injected from globalSetup');
+        console.log('  Endpoint:', protocolAddresses.endpointV2);
+        console.log('  SML:', protocolAddresses.sml);
+        console.log('  Executor:', protocolAddresses.executor);
+        console.log('  Executor Helper:', protocolAddresses.executorHelper);
+
+        // Create clients for protocol contracts
+        endpointClient = createClient(EndpointClient, protocolAddresses.endpointV2);
+        smlClient = createClient(SMLClient, protocolAddresses.sml);
+        executorHelperClient = createClient(ExecutorHelperClient, protocolAddresses.executorHelper);
+    });
+
+    describe('Deploy Counter', () => {
+        it('Deploy Counter', async () => {
+            counterClient = await deployContract<CounterClient>(
+                CounterClient,
+                COUNTER_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: protocolAddresses.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            counterAddress = counterClient.options.contractId;
+            console.log('✅ Counter deployed:', counterAddress);
+        });
+    });
+
+    describe('Wire Counter to use SML', () => {
+        it('Set Counter Send Library to SML', async () => {
+            // Override default library (ULN302) with SML for this Counter
+            const assembledTx = await endpointClient.set_send_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                sender: counterAddress,
+                dst_eid: EID,
+                new_lib: protocolAddresses.sml,
+            });
+            await assembledTx.signAndSend();
+
+            const { result: sendLib } = await endpointClient.get_send_library({
+                sender: counterAddress,
+                dst_eid: EID,
+            });
+            expect(sendLib.lib).toBe(protocolAddresses.sml);
+            expect(sendLib.is_default).toBe(false); // It's OApp-specific, not default
+            console.log('✅ Counter send library set to SML');
+        });
+
+        it('Set Counter Receive Library to SML', async () => {
+            const assembledTx = await endpointClient.set_receive_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                receiver: counterAddress,
+                src_eid: EID,
+                new_lib: protocolAddresses.sml,
+                grace_period: 0n,
+            });
+            await assembledTx.signAndSend();
+
+            const { result: receiveLib } = await endpointClient.get_receive_library({
+                receiver: counterAddress,
+                src_eid: EID,
+            });
+            expect(receiveLib.lib).toBe(protocolAddresses.sml);
+            expect(receiveLib.is_default).toBe(false); // It's OApp-specific, not default
+            console.log('✅ Counter receive library set to SML');
+        });
+
+        it('Set Counter Peer', async () => {
+            const peerBytes = StrKey.decodeContract(counterAddress);
+
+            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 ABA Messaging', async () => {
+        let incrementLedger = 0;
+        let responseLedger = 0;
+        let packetSentEvent: PacketSentEvent;
+        let responsePacketSentEvent: PacketSentEvent;
+        let guid: Buffer;
+        let message: Buffer;
+        let responseGuid: Buffer;
+        let responseMessage: Buffer;
+        let abaReturnFee: bigint;
+
+        it('Counter Increment (ABA)', async () => {
+            // First quote the return fee (for the ABA to send back a response message)
+            const returnOptions = Options.newOptions().addExecutorLzReceiveOption(200000n, 0n);
+
+            const { result: returnFee } = await counterClient.quote({
+                dst_eid: EID,
+                msg_type: MSG_TYPE_VANILLA,
+                options: Buffer.from(returnOptions.toBytes()),
+                pay_in_zro: false,
+            });
+            console.log('✅ Return fee for ABA:', returnFee);
+
+            // Add 1% buffer to the return fee
+            abaReturnFee = (returnFee.native_fee * 101n) / 100n;
+
+            // Build ABA options with lzReceive gas + value for return message fee
+            const abaOptions = Options.newOptions().addExecutorLzReceiveOption(
+                200000n,
+                abaReturnFee,
+            );
+            const optionsBuffer = Buffer.from(abaOptions.toBytes());
+
+            const { result: fee } = await counterClient.quote({
+                dst_eid: EID,
+                msg_type: MSG_TYPE_ABA,
+                options: optionsBuffer,
+                pay_in_zro: true,
+            });
+            console.log('✅ ABA Fee:', fee);
+
+            const assembledTx = await counterClient.increment({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                dst_eid: EID,
+                msg_type: MSG_TYPE_ABA,
+                options: optionsBuffer,
+                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 (ABA), outbound count:', outboundCount);
+        });
+
+        it('Scan PacketSent Events', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                protocolAddresses.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({
+                header_bytes: Buffer.from(packetHeader.replace('0x', ''), 'hex'),
+                payload_hash: Buffer.from(payloadHash.replace('0x', ''), 'hex'),
+            });
+            await assembledTx.signAndSend();
+            console.log('✅ ABA request packet validated');
+        });
+
+        it('Receive Counter Message (ABA - triggers response)', async () => {
+            // ABA message: receives message and automatically sends response
+            const origin = {
+                nonce: 1n,
+                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
+                src_eid: EID,
+            };
+
+            const assembledTx = await executorHelperClient.native_drop_and_execute(
+                {
+                    executor: protocolAddresses.executor,
+                    admin: EXECUTOR_ADMIN.publicKey(),
+                    origin,
+                    dst_eid: EID,
+                    oapp: counterAddress,
+                    // Native drop: send 100 stroops to counter contract
+                    native_drop_params: [
+                        {
+                            receiver: counterAddress,
+                            amount: 100n,
+                        },
+                    ],
+                    execute_params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid,
+                        message,
+                        origin,
+                        receiver: counterAddress,
+                        value: abaReturnFee, // Value that will be used as fee for the ABA response
+                    },
+                },
+                {
+                    simulate: false, // Don't auto-simulate, we'll do it with record_allow_nonroot
+                },
+            );
+
+            // Sign and send using non-root auth flow
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            assertTransactionSucceeded(txResult, 'LzReceive (ABA)');
+
+            if ('ledger' in txResult) {
+                responseLedger = txResult.ledger;
+            }
+
+            // Verify the ABA message was received and inbound count increased
+            const { result: inboundCount } = await counterClient.inbound_count({
+                eid: EID,
+            });
+            expect(inboundCount).toBe(1n);
+
+            // Verify the outbound count increased (ABA response was sent)
+            const { result: outboundCount } = await counterClient.outbound_count({
+                eid: EID,
+            });
+            expect(outboundCount).toBe(2n); // 1 from initial increment + 1 from ABA response
+            console.log(
+                '✅ ABA message received and response sent, outbound count:',
+                outboundCount,
+            );
+        });
+
+        it('Scan ABA Response PacketSent Events', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                protocolAddresses.endpointV2,
+                responseLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            responsePacketSentEvent = packetSentEvents[0];
+            console.log(
+                `✅ ABA response PacketSent events scanned. Found ${packetSentEvents.length} events`,
+            );
+        });
+
+        it('Verify ABA Response Message', async () => {
+            const packet = PacketSerializer.deserialize(responsePacketSentEvent.encoded_packet);
+            responseGuid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
+            responseMessage = 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({
+                header_bytes: Buffer.from(packetHeader.replace('0x', ''), 'hex'),
+                payload_hash: Buffer.from(payloadHash.replace('0x', ''), 'hex'),
+            });
+            await assembledTx.signAndSend();
+            console.log('✅ ABA response packet validated');
+        });
+
+        it('Receive ABA Response Message', async () => {
+            // Receive the response message (vanilla type)
+            const origin = {
+                nonce: 2n,
+                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
+                src_eid: EID,
+            };
+
+            const assembledTx = await executorHelperClient.execute(
+                {
+                    executor: protocolAddresses.executor,
+                    params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid: responseGuid,
+                        message: responseMessage,
+                        origin,
+                        receiver: counterAddress,
+                        value: 10n, // Response message includes value: 10
+                    },
+                    value_payer: EXECUTOR_ADMIN.publicKey(),
+                },
+                {
+                    simulate: false, // Don't auto-simulate, we'll do it with record_allow_nonroot
+                },
+            );
+
+            // Sign and send using non-root auth flow
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            assertTransactionSucceeded(txResult, 'LzReceive (ABA Response)');
+
+            // Verify the response was received and inbound count increased again
+            const { result: inboundCount } = await counterClient.inbound_count({
+                eid: EID,
+            });
+            expect(inboundCount).toBe(2n); // 1 from ABA request + 1 from ABA response
+            console.log('✅ ABA response received, total inbound count:', inboundCount);
+
+            console.log('\n🎉 ABA round-trip completed successfully!');
+            console.log('   Request: Counter → Counter (ABA)');
+            console.log('   Response: Counter → Counter (Vanilla)');
+        });
+    });
+});