@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

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

@@ -11,31 +11,39 @@ import { Client as ExecutorHelperClient } from '../src/generated/executor_helper
 import { Client as SMLClient } from '../src/generated/sml';
 import {
     DEFAULT_DEPLOYER,
-    EID,
+    EID_A,
+    EID_B,
     EXECUTOR_ADMIN,
     MSG_TYPE_ABA,
     MSG_TYPE_VANILLA,
     NETWORK_PASSPHRASE,
 } from './suites/constants';
 import { deployContract } from './suites/deploy';
+import type { ChainAddresses } from './suites/globalSetup';
 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'>>;
+// Chain addresses (injected from globalSetup)
+let chainA: ChainAddresses;
+let chainB: ChainAddresses;
 
-// Counter-specific address
-let counterAddress = '';
+// Counter addresses (deployed per-chain)
+let counterAAddress = '';
+let counterBAddress = '';
 
-// Clients
-let endpointClient: EndpointClient;
-let smlClient: SMLClient;
-let counterClient: CounterClient;
-let executorHelperClient: ExecutorHelperClient;
+// Chain A Clients
+let endpointClientA: EndpointClient;
+let smlClientA: SMLClient;
+let counterClientA: CounterClient;
+let executorHelperClientA: ExecutorHelperClient;
 
-// NOTE: run `stellar contract build --features sandbox` before running the test
+// Chain B Clients
+let endpointClientB: EndpointClient;
+let smlClientB: SMLClient;
+let counterClientB: CounterClient;
+let executorHelperClientB: ExecutorHelperClient;
 
-describe('Counter with SML testing', async () => {
+describe('Counter Cross-Chain Testing (SML)', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
     const wasmDir = path.join(
         repoRoot,
@@ -50,96 +58,170 @@ describe('Counter with SML testing', async () => {
     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);
+        // Inject chain addresses from globalSetup
+        chainA = inject('chainA');
+        chainB = inject('chainB');
+
+        console.log('\n📋 Chain A addresses (EID: ' + EID_A + ')');
+        console.log('  Endpoint:', chainA.endpointV2);
+        console.log('  SML:', chainA.sml);
+        console.log('  Executor:', chainA.executor);
+
+        console.log('\n📋 Chain B addresses (EID: ' + EID_B + ')');
+        console.log('  Endpoint:', chainB.endpointV2);
+        console.log('  SML:', chainB.sml);
+        console.log('  Executor:', chainB.executor);
+
+        // Create clients for Chain A protocol contracts
+        endpointClientA = createClient(EndpointClient, chainA.endpointV2);
+        smlClientA = createClient(SMLClient, chainA.sml);
+        executorHelperClientA = createClient(ExecutorHelperClient, chainA.executorHelper);
+
+        // Create clients for Chain B protocol contracts
+        endpointClientB = createClient(EndpointClient, chainB.endpointV2);
+        smlClientB = createClient(SMLClient, chainB.sml);
+        executorHelperClientB = createClient(ExecutorHelperClient, chainB.executorHelper);
     });
 
-    describe('Deploy Counter', () => {
-        it('Deploy Counter', async () => {
-            counterClient = await deployContract<CounterClient>(
+    describe('Deploy Counters on Both Chains', () => {
+        it('Deploy Counter A on Chain A', async () => {
+            counterClientA = await deployContract<CounterClient>(
                 CounterClient,
                 COUNTER_WASM_PATH,
                 {
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: protocolAddresses.endpointV2,
+                    endpoint: chainA.endpointV2,
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                 },
                 DEFAULT_DEPLOYER,
             );
 
-            counterAddress = counterClient.options.contractId;
-            console.log('✅ Counter deployed:', counterAddress);
+            counterAAddress = counterClientA.options.contractId;
+            console.log('✅ Counter A deployed on Chain A:', counterAAddress);
+        });
+
+        it('Deploy Counter B on Chain B', async () => {
+            counterClientB = await deployContract<CounterClient>(
+                CounterClient,
+                COUNTER_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: chainB.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            counterBAddress = counterClientB.options.contractId;
+            console.log('✅ Counter B deployed on Chain B:', counterBAddress);
         });
     });
 
-    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({
+    describe('Wire Counters to use SML (Cross-Chain)', () => {
+        it('Set Counter A Send Library to SML (for sending to Chain B)', async () => {
+            const assembledTx = await endpointClientA.set_send_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                sender: counterAAddress,
+                dst_eid: EID_B,
+                new_lib: chainA.sml,
+            });
+            await assembledTx.signAndSend();
+
+            const { result: sendLib } = await endpointClientA.get_send_library({
+                sender: counterAAddress,
+                dst_eid: EID_B,
+            });
+            expect(sendLib.lib).toBe(chainA.sml);
+            console.log('✅ Counter A send library set to SML for EID_B');
+        });
+
+        it('Set Counter A Receive Library to SML (for receiving from Chain B)', async () => {
+            const assembledTx = await endpointClientA.set_receive_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                receiver: counterAAddress,
+                src_eid: EID_B,
+                new_lib: chainA.sml,
+                grace_period: 0n,
+            });
+            await assembledTx.signAndSend();
+
+            const { result: receiveLib } = await endpointClientA.get_receive_library({
+                receiver: counterAAddress,
+                src_eid: EID_B,
+            });
+            expect(receiveLib.lib).toBe(chainA.sml);
+            console.log('✅ Counter A receive library set to SML for EID_B');
+        });
+
+        it('Set Counter B Send Library to SML (for sending to Chain A)', async () => {
+            const assembledTx = await endpointClientB.set_send_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
-                sender: counterAddress,
-                dst_eid: EID,
-                new_lib: protocolAddresses.sml,
+                sender: counterBAddress,
+                dst_eid: EID_A,
+                new_lib: chainB.sml,
             });
             await assembledTx.signAndSend();
 
-            const { result: sendLib } = await endpointClient.get_send_library({
-                sender: counterAddress,
-                dst_eid: EID,
+            const { result: sendLib } = await endpointClientB.get_send_library({
+                sender: counterBAddress,
+                dst_eid: EID_A,
             });
-            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');
+            expect(sendLib.lib).toBe(chainB.sml);
+            console.log('✅ Counter B send library set to SML for EID_A');
         });
 
-        it('Set Counter Receive Library to SML', async () => {
-            const assembledTx = await endpointClient.set_receive_library({
+        it('Set Counter B Receive Library to SML (for receiving from Chain A)', async () => {
+            const assembledTx = await endpointClientB.set_receive_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
-                receiver: counterAddress,
-                src_eid: EID,
-                new_lib: protocolAddresses.sml,
+                receiver: counterBAddress,
+                src_eid: EID_A,
+                new_lib: chainB.sml,
                 grace_period: 0n,
             });
             await assembledTx.signAndSend();
 
-            const { result: receiveLib } = await endpointClient.get_receive_library({
-                receiver: counterAddress,
-                src_eid: EID,
+            const { result: receiveLib } = await endpointClientB.get_receive_library({
+                receiver: counterBAddress,
+                src_eid: EID_A,
+            });
+            expect(receiveLib.lib).toBe(chainB.sml);
+            console.log('✅ Counter B receive library set to SML for EID_A');
+        });
+
+        it('Set Counter A Peer to Counter B', async () => {
+            const peerBBytes = StrKey.decodeContract(counterBAddress);
+
+            const assembledTx = await counterClientA.set_peer({
+                eid: EID_B,
+                peer: Buffer.from(peerBBytes),
+            });
+            await assembledTx.signAndSend();
+
+            const { result: peer } = await counterClientA.peer({
+                eid: EID_B,
             });
-            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');
+            expect(peer?.toString()).toBe(Buffer.from(peerBBytes).toString());
+            console.log('✅ Counter A peer set to Counter B for EID_B');
         });
 
-        it('Set Counter Peer', async () => {
-            const peerBytes = StrKey.decodeContract(counterAddress);
+        it('Set Counter B Peer to Counter A', async () => {
+            const peerABytes = StrKey.decodeContract(counterAAddress);
 
-            const assembledTx = await counterClient.set_peer({
-                eid: EID,
-                peer: Buffer.from(peerBytes),
+            const assembledTx = await counterClientB.set_peer({
+                eid: EID_A,
+                peer: Buffer.from(peerABytes),
             });
             await assembledTx.signAndSend();
 
-            const { result: peer } = await counterClient.peer({
-                eid: EID,
+            const { result: peer } = await counterClientB.peer({
+                eid: EID_A,
             });
-            expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
-            console.log('✅ Counter peer set for EID', EID);
+            expect(peer?.toString()).toBe(Buffer.from(peerABytes).toString());
+            console.log('✅ Counter B peer set to Counter A for EID_A');
         });
     });
 
-    describe('Counter ABA Messaging', async () => {
+    describe('Cross-Chain ABA Messaging (A → B → A)', async () => {
         let incrementLedger = 0;
         let responseLedger = 0;
         let packetSentEvent: PacketSentEvent;
@@ -150,17 +232,17 @@ describe('Counter with SML testing', async () => {
         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)
+        it('Counter A Increment (ABA) - sends to Chain B', async () => {
+            // Quote the return fee (for Counter B to send response back to Chain A)
             const returnOptions = Options.newOptions().addExecutorLzReceiveOption(200000n, 0n);
 
-            const { result: returnFee } = await counterClient.quote({
-                dst_eid: EID,
+            const { result: returnFee } = await counterClientB.quote({
+                dst_eid: EID_A,
                 msg_type: MSG_TYPE_VANILLA,
                 options: Buffer.from(returnOptions.toBytes()),
                 pay_in_zro: false,
             });
-            console.log('✅ Return fee for ABA:', returnFee);
+            console.log('✅ Return fee for ABA (B→A):', returnFee);
 
             // Add 1% buffer to the return fee
             abaReturnFee = (returnFee.native_fee * 101n) / 100n;
@@ -172,82 +254,79 @@ describe('Counter with SML testing', async () => {
             );
             const optionsBuffer = Buffer.from(abaOptions.toBytes());
 
-            const { result: fee } = await counterClient.quote({
-                dst_eid: EID,
+            const { result: fee } = await counterClientA.quote({
+                dst_eid: EID_B,
                 msg_type: MSG_TYPE_ABA,
                 options: optionsBuffer,
                 pay_in_zro: true,
             });
-            console.log('✅ ABA Fee:', fee);
+            console.log('✅ ABA Fee (A→B):', fee);
 
-            const assembledTx = await counterClient.increment({
+            const assembledTx = await counterClientA.increment({
                 caller: DEFAULT_DEPLOYER.publicKey(),
-                dst_eid: EID,
+                dst_eid: EID_B,
                 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,
+            const { result: outboundCount } = await counterClientA.outbound_count({
+                eid: EID_B,
             });
             expect(outboundCount).toBe(1n);
-            console.log('✅ Counter incremented (ABA), outbound count:', outboundCount);
+            console.log('✅ Counter A incremented (ABA to B), outbound count:', outboundCount);
         });
 
-        it('Scan PacketSent Events', async () => {
-            const packetSentEvents = await scanPacketSentEvents(
-                protocolAddresses.endpointV2,
-                incrementLedger,
-            );
+        it('Scan PacketSent Events (A → B)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(chainA.endpointV2, incrementLedger);
             expect(packetSentEvents.length).toBeGreaterThan(0);
             packetSentEvent = packetSentEvents[0];
             console.log(
-                `✅ PacketSent events scanned successfully. Found ${packetSentEvents.length} events`,
+                `✅ PacketSent events scanned from Chain A. Found ${packetSentEvents.length} events`,
             );
         });
 
-        it('Verify Counter Message', async () => {
+        it('Verify Counter Message on Chain B (via SML)', 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({
+
+            // Validate on Chain B's SML
+            const assembledTx = await smlClientB.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');
+            console.log('✅ ABA request packet validated on Chain B');
         });
 
-        it('Receive Counter Message (ABA - triggers response)', async () => {
-            // ABA message: receives message and automatically sends response
+        it('Receive Counter Message on Chain B (ABA - triggers response to A)', async () => {
             const origin = {
                 nonce: 1n,
-                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
-                src_eid: EID,
+                sender: Buffer.from(StrKey.decodeContract(counterAAddress)),
+                src_eid: EID_A,
             };
 
-            const assembledTx = await executorHelperClient.native_drop_and_execute(
+            // Execute on Chain B using Chain B's executor
+            const assembledTx = await executorHelperClientB.native_drop_and_execute(
                 {
-                    executor: protocolAddresses.executor,
+                    executor: chainB.executor,
                     admin: EXECUTOR_ADMIN.publicKey(),
                     origin,
-                    dst_eid: EID,
-                    oapp: counterAddress,
-                    // Native drop: send 100 stroops to counter contract
+                    dst_eid: EID_B,
+                    oapp: counterBAddress,
                     native_drop_params: [
                         {
-                            receiver: counterAddress,
+                            receiver: counterBAddress,
                             amount: 100n,
                         },
                     ],
@@ -257,120 +336,117 @@ describe('Counter with SML testing', async () => {
                         guid,
                         message,
                         origin,
-                        receiver: counterAddress,
-                        value: abaReturnFee, // Value that will be used as fee for the ABA response
+                        receiver: counterBAddress,
+                        value: abaReturnFee,
                     },
                 },
                 {
-                    simulate: false, // Don't auto-simulate, we'll do it with record_allow_nonroot
+                    simulate: false,
                 },
             );
 
-            // Sign and send using non-root auth flow
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainB.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'LzReceive (ABA)');
+            assertTransactionSucceeded(txResult, 'LzReceive on Chain B (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,
+            // Verify Counter B received the message
+            const { result: inboundCount } = await counterClientB.inbound_count({
+                eid: EID_A,
             });
             expect(inboundCount).toBe(1n);
 
-            // Verify the outbound count increased (ABA response was sent)
-            const { result: outboundCount } = await counterClient.outbound_count({
-                eid: EID,
+            // Verify Counter B sent the response back to Chain A
+            const { result: outboundCount } = await counterClientB.outbound_count({
+                eid: EID_A,
             });
-            expect(outboundCount).toBe(2n); // 1 from initial increment + 1 from ABA response
+            expect(outboundCount).toBe(1n);
             console.log(
-                '✅ ABA message received and response sent, outbound count:',
+                '✅ Counter B received ABA message and sent response, outbound count:',
                 outboundCount,
             );
         });
 
-        it('Scan ABA Response PacketSent Events', async () => {
-            const packetSentEvents = await scanPacketSentEvents(
-                protocolAddresses.endpointV2,
-                responseLedger,
-            );
+        it('Scan ABA Response PacketSent Events (B → A)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(chainB.endpointV2, responseLedger);
             expect(packetSentEvents.length).toBeGreaterThan(0);
             responsePacketSentEvent = packetSentEvents[0];
             console.log(
-                `✅ ABA response PacketSent events scanned. Found ${packetSentEvents.length} events`,
+                `✅ ABA response PacketSent events scanned from Chain B. Found ${packetSentEvents.length} events`,
             );
         });
 
-        it('Verify ABA Response Message', async () => {
+        it('Verify ABA Response Message on Chain A (via SML)', 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({
+
+            // Validate on Chain A's SML
+            const assembledTx = await smlClientA.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');
+            console.log('✅ ABA response packet validated on Chain A');
         });
 
-        it('Receive ABA Response Message', async () => {
-            // Receive the response message (vanilla type)
+        it('Receive ABA Response Message on Chain A', async () => {
             const origin = {
-                nonce: 2n,
-                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
-                src_eid: EID,
+                nonce: 1n,
+                sender: Buffer.from(StrKey.decodeContract(counterBAddress)),
+                src_eid: EID_B,
             };
 
-            const assembledTx = await executorHelperClient.execute(
+            // Execute on Chain A using Chain A's executor
+            const assembledTx = await executorHelperClientA.execute(
                 {
-                    executor: protocolAddresses.executor,
+                    executor: chainA.executor,
                     params: {
                         extra_data: Buffer.from([]),
                         gas_limit: 0n,
                         guid: responseGuid,
                         message: responseMessage,
                         origin,
-                        receiver: counterAddress,
-                        value: 10n, // Response message includes value: 10
+                        receiver: counterAAddress,
+                        value: 10n,
                     },
                     value_payer: EXECUTOR_ADMIN.publicKey(),
                 },
                 {
-                    simulate: false, // Don't auto-simulate, we'll do it with record_allow_nonroot
+                    simulate: false,
                 },
             );
 
-            // Sign and send using non-root auth flow
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainA.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'LzReceive (ABA Response)');
+            assertTransactionSucceeded(txResult, 'LzReceive on Chain A (ABA Response)');
 
-            // Verify the response was received and inbound count increased again
-            const { result: inboundCount } = await counterClient.inbound_count({
-                eid: EID,
+            // Verify Counter A received the response
+            const { result: inboundCount } = await counterClientA.inbound_count({
+                eid: EID_B,
             });
-            expect(inboundCount).toBe(2n); // 1 from ABA request + 1 from ABA response
-            console.log('✅ ABA response received, total inbound count:', inboundCount);
+            expect(inboundCount).toBe(1n);
+            console.log('✅ Counter A received ABA response, inbound count:', inboundCount);
 
-            console.log('\n🎉 ABA round-trip completed successfully!');
-            console.log('   Request: Counter → Counter (ABA)');
-            console.log('   Response: Counter → Counter (Vanilla)');
+            console.log('\n🎉 Cross-chain ABA round-trip completed successfully!');
+            console.log('   Request:  Counter A (Chain A) → Counter B (Chain B) [ABA]');
+            console.log('   Response: Counter B (Chain B) → Counter A (Chain A) [Vanilla]');
         });
     });
 });