@layerzerolabs/lz-v2-stellar-sdk 0.2.21 → 0.2.23

package/test/counter-uln.test.ts

@@ -12,13 +12,15 @@ import {
     DEFAULT_DEPLOYER,
     DVN_SIGNER,
     DVN_VID,
-    EID,
+    EID_A,
+    EID_B,
     EXECUTOR_ADMIN,
     MSG_TYPE_COMPOSED_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,
@@ -28,20 +30,25 @@ import {
     signDvnAuthEntries,
 } 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 uln302Client: Uln302Client;
-let counterClient: CounterClient;
-let executorHelperClient: ExecutorHelperClient;
+// Chain A Clients
+let uln302ClientA: Uln302Client;
+let counterClientA: CounterClient;
+let executorHelperClientA: ExecutorHelperClient;
 
-// NOTE: run `stellar contract build --features sandbox` before running the test
+// Chain B Clients
+let uln302ClientB: Uln302Client;
+let counterClientB: CounterClient;
+let executorHelperClientB: ExecutorHelperClient;
 
-describe('Counter with ULN302 testing', async () => {
+describe('Counter Cross-Chain Testing (ULN302)', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
     const wasmDir = path.join(
         repoRoot,
@@ -56,56 +63,98 @@ describe('Counter with ULN302 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('  ULN302:', protocolAddresses.uln302);
-        console.log('  DVN:', protocolAddresses.dvn);
-        console.log('  Executor:', protocolAddresses.executor);
-        console.log('  Executor Helper:', protocolAddresses.executorHelper);
-
-        // Create clients for protocol contracts
-        uln302Client = createClient(Uln302Client, protocolAddresses.uln302);
-        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('  ULN302:', chainA.uln302);
+        console.log('  DVN:', chainA.dvn);
+        console.log('  Executor:', chainA.executor);
+
+        console.log('\n📋 Chain B addresses (EID: ' + EID_B + ')');
+        console.log('  Endpoint:', chainB.endpointV2);
+        console.log('  ULN302:', chainB.uln302);
+        console.log('  DVN:', chainB.dvn);
+        console.log('  Executor:', chainB.executor);
+
+        // Create clients for Chain A protocol contracts
+        uln302ClientA = createClient(Uln302Client, chainA.uln302);
+        executorHelperClientA = createClient(ExecutorHelperClient, chainA.executorHelper);
+
+        // Create clients for Chain B protocol contracts
+        uln302ClientB = createClient(Uln302Client, chainB.uln302);
+        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('Set Counter Peer', async () => {
-            const peerBytes = StrKey.decodeContract(counterAddress);
+        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);
+        });
+
+        it('Set Counter A Peer to Counter B', async () => {
+            const peerBBytes = StrKey.decodeContract(counterBAddress);
 
-            const assembledTx = await counterClient.set_peer({
-                eid: EID,
-                peer: Buffer.from(peerBytes),
+            const assembledTx = await counterClientA.set_peer({
+                eid: EID_B,
+                peer: Buffer.from(peerBBytes),
             });
             await assembledTx.signAndSend();
 
-            const { result: peer } = await counterClient.peer({
-                eid: EID,
+            const { result: peer } = await counterClientA.peer({
+                eid: EID_B,
             });
-            expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
-            console.log('✅ Counter peer set for EID', EID);
+            expect(peer?.toString()).toBe(Buffer.from(peerBBytes).toString());
+            console.log('✅ Counter A peer set to Counter B for EID_B');
+        });
+
+        it('Set Counter B Peer to Counter A', async () => {
+            const peerABytes = StrKey.decodeContract(counterAAddress);
+
+            const assembledTx = await counterClientB.set_peer({
+                eid: EID_A,
+                peer: Buffer.from(peerABytes),
+            });
+            await assembledTx.signAndSend();
+
+            const { result: peer } = await counterClientB.peer({
+                eid: EID_A,
+            });
+            expect(peer?.toString()).toBe(Buffer.from(peerABytes).toString());
+            console.log('✅ Counter B peer set to Counter A for EID_A');
         });
     });
 
-    describe('Counter Increment with Composed ABA and Native Drop', async () => {
+    describe('Counter Increment with Composed ABA and Native Drop (A → B → A)', async () => {
         let incrementLedger = 0;
         let packetSentEvent: PacketSentEvent;
         let guid: Buffer;
@@ -118,24 +167,23 @@ describe('Counter with ULN302 testing', async () => {
         const NATIVE_DROP_AMOUNT = 1000000n; // 0.1 XLM (in stroops)
         let nativeDropReceiver: Buffer;
 
-        it('Counter Increment (Composed ABA with Native Drop)', async () => {
+        it('Counter A Increment (Composed ABA with Native Drop) - sends to Chain B', async () => {
             // Get the native drop receiver address (32 bytes)
             nativeDropReceiver = Buffer.from(
                 StrKey.decodeEd25519PublicKey(DEFAULT_DEPLOYER.publicKey()),
             );
             const nativeDropReceiverHex = '0x' + nativeDropReceiver.toString('hex');
 
-            // First quote the return fee (for the lz_compose to send back a message)
-            // Return message uses vanilla type with lzReceive option
+            // 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 ComposedABA:', returnFee);
+            console.log('✅ Return fee for ComposedABA (B→A):', returnFee);
 
             // Add 1% buffer to the return fee
             const returnFeeWithBuffer = (returnFee.native_fee * 101n) / 100n;
@@ -152,49 +200,48 @@ describe('Counter with ULN302 testing', async () => {
 
             const optionsBuffer = Buffer.from(composedAbaOptions.toBytes());
 
-            const { result: fee } = await counterClient.quote({
-                dst_eid: EID,
+            const { result: fee } = await counterClientA.quote({
+                dst_eid: EID_B,
                 msg_type: MSG_TYPE_COMPOSED_ABA,
                 options: optionsBuffer,
                 pay_in_zro: false,
             });
-            console.log('✅ ComposedABA Fee:', fee);
+            console.log('✅ ComposedABA 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_COMPOSED_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 (Composed ABA), outbound count:', outboundCount);
+            console.log(
+                '✅ Counter A incremented (Composed ABA to B), outbound count:',
+                outboundCount,
+            );
         });
 
-        it('Scan PacketSent Events (Composed ABA)', 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('Extract Packet Header and Payload Hash (Composed ABA)', async () => {
+        it('Extract Packet Header and Payload Hash (A → B)', async () => {
             const packet = PacketSerializer.deserialize(packetSentEvent.encoded_packet);
             guid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
             message = Buffer.from(packet.message.replace('0x', ''), 'hex');
@@ -210,16 +257,18 @@ describe('Counter with ULN302 testing', async () => {
             );
         });
 
-        it('DVN Verifies Message (Composed ABA)', async () => {
-            const verifyTx = await uln302Client.verify({
-                dvn: protocolAddresses.dvn,
+        it('DVN B Verifies Message on Chain B (from Chain A)', async () => {
+            // Chain B's DVN verifies the packet on Chain B's ULN302
+            const verifyTx = await uln302ClientB.verify({
+                dvn: chainB.dvn,
                 packet_header: packetHeader,
                 payload_hash: payloadHash,
                 confirmations: 1n,
             });
 
+            // Sign with DVN_SIGNER (shared between both chains)
             await signDvnAuthEntries(
-                protocolAddresses.dvn,
+                chainB.dvn,
                 DVN_VID,
                 DEFAULT_DEPLOYER,
                 [DVN_SIGNER],
@@ -228,44 +277,43 @@ describe('Counter with ULN302 testing', async () => {
             );
 
             await verifyTx.signAndSend();
-            console.log('✅ DVN verified message (Composed ABA)');
+            console.log('✅ DVN B verified message on Chain B');
 
-            const { result: isVerifiable } = await uln302Client.verifiable({
+            const { result: isVerifiable } = await uln302ClientB.verifiable({
                 packet_header: packetHeader,
                 payload_hash: payloadHash,
             });
             expect(isVerifiable).toBe(true);
         });
 
-        it('Commit Verification (Composed ABA)', async () => {
-            const commitTx = await uln302Client.commit_verification({
+        it('Commit Verification on Chain B', async () => {
+            const commitTx = await uln302ClientB.commit_verification({
                 packet_header: packetHeader,
                 payload_hash: payloadHash,
             });
             await commitTx.signAndSend();
-            console.log('✅ Verification committed to endpoint (Composed ABA)');
+            console.log('✅ Verification committed to endpoint on Chain B');
         });
 
-        it('Execute native_drop_and_execute (Composed ABA)', async () => {
-            // Execute native_drop + lz_receive together
-            // For ComposedABA, lz_receive will queue a compose message via send_compose
+        it('Execute native_drop_and_execute on Chain B', async () => {
             const origin = {
-                nonce: 1n, // First message
-                sender: Buffer.from(StrKey.decodeContract(counterAddress)),
-                src_eid: EID,
+                nonce: 1n,
+                sender: Buffer.from(StrKey.decodeContract(counterAAddress)),
+                src_eid: EID_A,
             };
 
             // Get the balance before native drop
             const balanceBefore = await getNativeBalance(DEFAULT_DEPLOYER.publicKey());
             console.log('💰 Balance before native drop:', balanceBefore);
 
-            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,
+                    dst_eid: EID_B,
+                    oapp: counterBAddress,
                     native_drop_params: [
                         {
                             receiver: DEFAULT_DEPLOYER.publicKey(),
@@ -278,8 +326,8 @@ describe('Counter with ULN302 testing', async () => {
                         guid,
                         message,
                         origin,
-                        receiver: counterAddress,
-                        value: 0n, // No value for lz_receive, value is for lz_compose
+                        receiver: counterBAddress,
+                        value: 0n,
                     },
                 },
                 {
@@ -288,13 +336,13 @@ describe('Counter with ULN302 testing', async () => {
             );
 
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainB.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'native_drop_and_execute (Composed ABA)');
+            assertTransactionSucceeded(txResult, 'native_drop_and_execute on Chain B');
 
             // Verify native drop was received
             const balanceAfter = await getNativeBalance(DEFAULT_DEPLOYER.publicKey());
@@ -303,12 +351,12 @@ describe('Counter with ULN302 testing', async () => {
             expect(balanceIncrease).toBe(NATIVE_DROP_AMOUNT);
             console.log('✅ Native drop received:', NATIVE_DROP_AMOUNT, 'stroops');
 
-            // Verify the counter state
-            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);
-            console.log('✅ Inbound count from EID', EID, ':', inboundCount);
+            console.log('✅ Counter B inbound count from EID_A:', inboundCount);
         });
 
         // Variables for tracking the return message
@@ -319,15 +367,14 @@ describe('Counter with ULN302 testing', async () => {
         let returnPacketHeader: Buffer;
         let returnPayloadHash: Buffer;
 
-        it('Execute lz_compose (Composed ABA)', async () => {
-            // Now execute the compose message that was queued by lz_receive
-            // For ComposedABA, this will send a return message back to source
-            const assembledTx = await executorHelperClient.compose(
+        it('Execute lz_compose on Chain B (sends response to Chain A)', async () => {
+            // Execute the compose message that was queued by lz_receive
+            const assembledTx = await executorHelperClientB.compose(
                 {
-                    executor: protocolAddresses.executor,
+                    executor: chainB.executor,
                     params: {
-                        from: counterAddress, // Compose message is from the counter
-                        to: counterAddress, // And to the counter (self-compose)
+                        from: counterBAddress,
+                        to: counterBAddress,
                         guid,
                         index: 0,
                         message,
@@ -343,46 +390,41 @@ describe('Counter with ULN302 testing', async () => {
             );
 
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainB.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'lz_compose (Composed ABA)');
+            assertTransactionSucceeded(txResult, 'lz_compose on Chain B');
 
-            // Extract ledger number for scanning return packet
             if ('ledger' in txResult) {
                 composeLedger = txResult.ledger;
             }
 
             // Verify composed count increased
-            const { result: composedCount } = await counterClient.composed_count();
+            const { result: composedCount } = await counterClientB.composed_count();
             expect(composedCount).toBe(1n);
-            console.log('✅ Composed count:', composedCount);
+            console.log('✅ Counter B composed count:', composedCount);
 
-            // Verify outbound count increased (return message was sent)
-            const { result: outboundCount } = await counterClient.outbound_count({
-                eid: EID,
+            // Verify outbound count increased (response message sent to Chain A)
+            const { result: outboundCount } = await counterClientB.outbound_count({
+                eid: EID_A,
             });
-            expect(outboundCount).toBe(2n); // 1 original + 1 return message
-            console.log('✅ Outbound count (including return message):', outboundCount);
+            expect(outboundCount).toBe(1n);
+            console.log('✅ Counter B outbound count (response to A):', outboundCount);
         });
 
-        it('Scan Return PacketSent Events', async () => {
-            // Scan for the return packet sent by lz_compose
-            const packetSentEvents = await scanPacketSentEvents(
-                protocolAddresses.endpointV2,
-                composeLedger,
-            );
+        it('Scan Return PacketSent Events (B → A)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(chainB.endpointV2, composeLedger);
             expect(packetSentEvents.length).toBeGreaterThan(0);
             returnPacketSentEvent = packetSentEvents[0];
             console.log(
-                `✅ Return PacketSent events scanned. Found ${packetSentEvents.length} events`,
+                `✅ Return PacketSent events scanned from Chain B. Found ${packetSentEvents.length} events`,
             );
         });
 
-        it('Extract Return Packet Header and Payload Hash', async () => {
+        it('Extract Return Packet Header and Payload Hash (B → A)', async () => {
             const packet = PacketSerializer.deserialize(returnPacketSentEvent.encoded_packet);
             returnGuid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
             returnMessage = Buffer.from(packet.message.replace('0x', ''), 'hex');
@@ -398,16 +440,18 @@ describe('Counter with ULN302 testing', async () => {
             );
         });
 
-        it('DVN Verifies Return Message', async () => {
-            const verifyTx = await uln302Client.verify({
-                dvn: protocolAddresses.dvn,
+        it('DVN A Verifies Return Message on Chain A (from Chain B)', async () => {
+            // Chain A's DVN verifies the packet on Chain A's ULN302
+            const verifyTx = await uln302ClientA.verify({
+                dvn: chainA.dvn,
                 packet_header: returnPacketHeader,
                 payload_hash: returnPayloadHash,
                 confirmations: 1n,
             });
 
+            // Sign with DVN_SIGNER (shared between both chains)
             await signDvnAuthEntries(
-                protocolAddresses.dvn,
+                chainA.dvn,
                 DVN_VID,
                 DEFAULT_DEPLOYER,
                 [DVN_SIGNER],
@@ -416,42 +460,42 @@ describe('Counter with ULN302 testing', async () => {
             );
 
             await verifyTx.signAndSend();
-            console.log('✅ DVN verified return message');
+            console.log('✅ DVN A verified return message on Chain A');
 
-            const { result: isVerifiable } = await uln302Client.verifiable({
+            const { result: isVerifiable } = await uln302ClientA.verifiable({
                 packet_header: returnPacketHeader,
                 payload_hash: returnPayloadHash,
             });
             expect(isVerifiable).toBe(true);
         });
 
-        it('Commit Verification (Return Message)', async () => {
-            const commitTx = await uln302Client.commit_verification({
+        it('Commit Verification on Chain A (Return Message)', async () => {
+            const commitTx = await uln302ClientA.commit_verification({
                 packet_header: returnPacketHeader,
                 payload_hash: returnPayloadHash,
             });
             await commitTx.signAndSend();
-            console.log('✅ Verification committed for return message');
+            console.log('✅ Verification committed for return message on Chain A');
         });
 
-        it('Receive Return Message (lz_receive)', async () => {
-            // Execute lz_receive for the return message (Vanilla type)
+        it('Receive Return Message on Chain A (lz_receive)', async () => {
             const origin = {
-                nonce: 2n, // Second message (return from ComposedABA)
-                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: returnGuid,
                         message: returnMessage,
                         origin,
-                        receiver: counterAddress,
+                        receiver: counterAAddress,
                         value: 0n,
                     },
                     value_payer: EXECUTOR_ADMIN.publicKey(),
@@ -462,32 +506,32 @@ describe('Counter with ULN302 testing', async () => {
             );
 
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainA.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'lz_receive (Return Message)');
+            assertTransactionSucceeded(txResult, 'lz_receive on Chain A (Return Message)');
 
             // Verify final counter state
-            const { result: count } = await counterClient.count();
-            expect(count).toBe(2n);
-            console.log('✅ Final counter count:', count);
+            const { result: count } = await counterClientA.count();
+            expect(count).toBe(1n);
+            console.log('✅ Final counter A count:', count);
 
-            const { result: inboundCount } = await counterClient.inbound_count({
-                eid: EID,
+            const { result: inboundCount } = await counterClientA.inbound_count({
+                eid: EID_B,
             });
-            expect(inboundCount).toBe(2n); // 1 composed ABA + 1 return
-            console.log('✅ Final inbound count from EID', EID, ':', inboundCount);
+            expect(inboundCount).toBe(1n);
+            console.log('✅ Counter A inbound count from EID_B:', inboundCount);
 
-            console.log('\n🎉 Counter Composed ABA with Native Drop - Full Round Trip completed!');
-            console.log(
-                '   Workflow: Send ComposedABA → DVN Verify → Commit → native_drop_and_execute',
-            );
             console.log(
-                '             → lz_compose (sends return) → DVN Verify → Commit → lz_receive',
+                '\n🎉 Counter Cross-Chain Composed ABA with Native Drop - Full Round Trip!',
             );
+            console.log('   Chain A → Chain B: ComposedABA with native_drop');
+            console.log('   DVN B verifies → Commit → native_drop_and_execute → lz_compose');
+            console.log('   Chain B → Chain A: Response (Vanilla)');
+            console.log('   DVN A verifies → Commit → lz_receive');
         });
     });
 });