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

package/test/oft-sml.test.ts

@@ -20,12 +20,14 @@ import { Client as OFTClient, OftType, SendParam } from '../src/generated/oft';
 import { Client as SMLClient } from '../src/generated/sml';
 import {
     DEFAULT_DEPLOYER,
-    EID,
+    EID_A,
+    EID_B,
     EXECUTOR_ADMIN,
     NETWORK_PASSPHRASE,
     RPC_URL,
 } from './suites/constants';
 import { deployAssetSac, deployContract } from './suites/deploy';
+import type { ChainAddresses } from './suites/globalSetup';
 import { fundAccount } from './suites/localnet';
 import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
 import {
@@ -35,27 +37,33 @@ import {
     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;
 
 // OFT-specific addresses
 let oftTokenAddress = '';
-let lockUnlockOftAddress = '';
-let mintBurnOftAddress = '';
+let lockUnlockOftAddress = ''; // Chain A
+let mintBurnOftAddress = ''; // Chain B
 
-// Clients
-let endpointClient: EndpointClient;
-let smlClient: SMLClient;
-let executorHelperClient: ExecutorHelperClient;
+// Chain A Clients
+let endpointClientA: EndpointClient;
+let smlClientA: SMLClient;
+let executorHelperClientA: ExecutorHelperClient;
 let lockUnlockOftClient: OFTClient;
+
+// Chain B Clients
+let endpointClientB: EndpointClient;
+let smlClientB: SMLClient;
+let executorHelperClientB: ExecutorHelperClient;
 let mintBurnOftClient: OFTClient;
 
 // Test accounts
 const TOKEN_ISSUER = Keypair.random();
 
 // Recipients for each direction
-const RECIPIENT_A = Keypair.random(); // Receives tokens in Lock/Unlock -> Mint/Burn direction
-const RECIPIENT_B = Keypair.random(); // Receives tokens in Mint/Burn -> Lock/Unlock direction
+const RECIPIENT_A = Keypair.random(); // Receives tokens on Chain A (unlocked)
+const RECIPIENT_B = Keypair.random(); // Receives tokens on Chain B (minted)
 
 // OFT Token asset (custom token for testing)
 const OFT_TOKEN_CODE = 'OFT';
@@ -66,9 +74,7 @@ const SHARED_DECIMALS = 6;
 const INITIAL_TOKEN_AMOUNT = '1000'; // 1000 tokens
 const SEND_AMOUNT = 100_0000000n; // 100 tokens in local decimals (7 decimals)
 
-// NOTE: run `stellar contract build` before running the test
-
-describe('OFT E2E Testing with SAC (SML)', async () => {
+describe('OFT Cross-Chain E2E Testing with SAC (SML)', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
     const wasmDir = path.join(
         repoRoot,
@@ -83,19 +89,29 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
     const OFT_WASM_PATH = path.join(wasmDir, 'oft.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);
 
         // Fund test accounts
         await fundAccount(TOKEN_ISSUER.publicKey());
@@ -106,7 +122,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
         OFT_ASSET = new Asset(OFT_TOKEN_CODE, TOKEN_ISSUER.publicKey());
     });
 
-    describe('Deploy OFT Contracts', () => {
+    describe('Deploy OFT Contracts on Both Chains', () => {
         it('Deploy OFT Token SAC', async () => {
             const server = new rpc.Server(RPC_URL, { allowHttp: true });
 
@@ -123,14 +139,14 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                         source: DEFAULT_DEPLOYER.publicKey(),
                     }),
                 )
-                // Trustline for RECIPIENT_A (receives minted tokens)
+                // Trustline for RECIPIENT_A (receives unlocked tokens)
                 .addOperation(
                     Operation.changeTrust({
                         asset: OFT_ASSET,
                         source: RECIPIENT_A.publicKey(),
                     }),
                 )
-                // Trustline for RECIPIENT_B (receives unlocked tokens)
+                // Trustline for RECIPIENT_B (receives minted tokens)
                 .addOperation(
                     Operation.changeTrust({
                         asset: OFT_ASSET,
@@ -164,14 +180,14 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             console.log('✅ OFT Token SAC deployed:', oftTokenAddress);
         });
 
-        it('Deploy Lock/Unlock OFT', async () => {
+        it('Deploy Lock/Unlock OFT on Chain A', async () => {
             lockUnlockOftClient = await deployContract<OFTClient>(
                 OFTClient,
                 OFT_WASM_PATH,
                 {
                     token: oftTokenAddress,
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: protocolAddresses.endpointV2,
+                    endpoint: chainA.endpointV2, // Chain A endpoint
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
                     oft_type: OftType.LockUnlock,
@@ -180,146 +196,139 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             );
 
             lockUnlockOftAddress = lockUnlockOftClient.options.contractId;
-            console.log('✅ Lock/Unlock OFT deployed:', lockUnlockOftAddress);
+            console.log('✅ Lock/Unlock OFT deployed on Chain A:', lockUnlockOftAddress);
 
-            // Verify it's in lock/unlock mode
             const { result: oftType } = await lockUnlockOftClient.oft_type();
             expect(oftType).toEqual(OftType.LockUnlock);
         });
 
-        it('Deploy Mint/Burn OFT', async () => {
+        it('Deploy Mint/Burn OFT on Chain B', async () => {
             mintBurnOftClient = await deployContract<OFTClient>(
                 OFTClient,
                 OFT_WASM_PATH,
                 {
                     token: oftTokenAddress,
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: protocolAddresses.endpointV2,
+                    endpoint: chainB.endpointV2, // Chain B endpoint
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    oft_type: OftType.MintBurn, // Mint/Burn mode
+                    oft_type: OftType.MintBurn,
                 },
                 DEFAULT_DEPLOYER,
             );
 
             mintBurnOftAddress = mintBurnOftClient.options.contractId;
-            console.log('✅ Mint/Burn OFT deployed:', mintBurnOftAddress);
+            console.log('✅ Mint/Burn OFT deployed on Chain B:', mintBurnOftAddress);
 
-            // Verify it's in mint/burn mode
             const { result: oftType } = await mintBurnOftClient.oft_type();
             expect(oftType).toEqual(OftType.MintBurn);
         });
     });
 
-    describe('Wire OFT Contracts to use SML', () => {
-        it('Set Lock/Unlock OFT Send Library to SML', async () => {
-            const assembledTx = await endpointClient.set_send_library({
+    describe('Wire OFT Contracts to use SML (Cross-Chain)', () => {
+        it('Set Lock/Unlock OFT (Chain A) Send Library to SML for Chain B', async () => {
+            const assembledTx = await endpointClientA.set_send_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
                 sender: lockUnlockOftAddress,
-                dst_eid: EID,
-                new_lib: protocolAddresses.sml,
+                dst_eid: EID_B,
+                new_lib: chainA.sml,
             });
             await assembledTx.signAndSend();
 
-            const { result: sendLib } = await endpointClient.get_send_library({
+            const { result: sendLib } = await endpointClientA.get_send_library({
                 sender: lockUnlockOftAddress,
-                dst_eid: EID,
+                dst_eid: EID_B,
             });
-            expect(sendLib.lib).toBe(protocolAddresses.sml);
-            expect(sendLib.is_default).toBe(false);
-            console.log('✅ Lock/Unlock OFT send library set to SML');
+            expect(sendLib.lib).toBe(chainA.sml);
+            console.log('✅ Lock/Unlock OFT (Chain A) send library set to SML for EID_B');
         });
 
-        it('Set Lock/Unlock OFT Receive Library to SML', async () => {
-            const assembledTx = await endpointClient.set_receive_library({
+        it('Set Lock/Unlock OFT (Chain A) Receive Library to SML for Chain B', async () => {
+            const assembledTx = await endpointClientA.set_receive_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
                 receiver: lockUnlockOftAddress,
-                src_eid: EID,
-                new_lib: protocolAddresses.sml,
+                src_eid: EID_B,
+                new_lib: chainA.sml,
                 grace_period: 0n,
             });
             await assembledTx.signAndSend();
 
-            const { result: receiveLib } = await endpointClient.get_receive_library({
+            const { result: receiveLib } = await endpointClientA.get_receive_library({
                 receiver: lockUnlockOftAddress,
-                src_eid: EID,
+                src_eid: EID_B,
             });
-            expect(receiveLib.lib).toBe(protocolAddresses.sml);
-            expect(receiveLib.is_default).toBe(false);
-            console.log('✅ Lock/Unlock OFT receive library set to SML');
+            expect(receiveLib.lib).toBe(chainA.sml);
+            console.log('✅ Lock/Unlock OFT (Chain A) receive library set to SML for EID_B');
         });
 
-        it('Set Mint/Burn OFT Send Library to SML', async () => {
-            const assembledTx = await endpointClient.set_send_library({
+        it('Set Mint/Burn OFT (Chain B) Send Library to SML for Chain A', async () => {
+            const assembledTx = await endpointClientB.set_send_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
                 sender: mintBurnOftAddress,
-                dst_eid: EID,
-                new_lib: protocolAddresses.sml,
+                dst_eid: EID_A,
+                new_lib: chainB.sml,
             });
             await assembledTx.signAndSend();
 
-            const { result: sendLib } = await endpointClient.get_send_library({
+            const { result: sendLib } = await endpointClientB.get_send_library({
                 sender: mintBurnOftAddress,
-                dst_eid: EID,
+                dst_eid: EID_A,
             });
-            expect(sendLib.lib).toBe(protocolAddresses.sml);
-            expect(sendLib.is_default).toBe(false);
-            console.log('✅ Mint/Burn OFT send library set to SML');
+            expect(sendLib.lib).toBe(chainB.sml);
+            console.log('✅ Mint/Burn OFT (Chain B) send library set to SML for EID_A');
         });
 
-        it('Set Mint/Burn OFT Receive Library to SML', async () => {
-            const assembledTx = await endpointClient.set_receive_library({
+        it('Set Mint/Burn OFT (Chain B) Receive Library to SML for Chain A', async () => {
+            const assembledTx = await endpointClientB.set_receive_library({
                 caller: DEFAULT_DEPLOYER.publicKey(),
                 receiver: mintBurnOftAddress,
-                src_eid: EID,
-                new_lib: protocolAddresses.sml,
+                src_eid: EID_A,
+                new_lib: chainB.sml,
                 grace_period: 0n,
             });
             await assembledTx.signAndSend();
 
-            const { result: receiveLib } = await endpointClient.get_receive_library({
+            const { result: receiveLib } = await endpointClientB.get_receive_library({
                 receiver: mintBurnOftAddress,
-                src_eid: EID,
+                src_eid: EID_A,
             });
-            expect(receiveLib.lib).toBe(protocolAddresses.sml);
-            expect(receiveLib.is_default).toBe(false);
-            console.log('✅ Mint/Burn OFT receive library set to SML');
+            expect(receiveLib.lib).toBe(chainB.sml);
+            console.log('✅ Mint/Burn OFT (Chain B) receive library set to SML for EID_A');
         });
 
-        it('Set Lock/Unlock OFT Peer (to Mint/Burn OFT)', async () => {
+        it('Set Lock/Unlock OFT (Chain A) Peer to Mint/Burn OFT (Chain B)', async () => {
             const mintBurnPeerBytes = StrKey.decodeContract(mintBurnOftAddress);
 
             const assembledTx = await lockUnlockOftClient.set_peer({
-                eid: EID,
+                eid: EID_B,
                 peer: Buffer.from(mintBurnPeerBytes),
             });
             await assembledTx.signAndSend();
 
             const { result: peer } = await lockUnlockOftClient.peer({
-                eid: EID,
+                eid: EID_B,
             });
             expect(peer?.toString()).toBe(Buffer.from(mintBurnPeerBytes).toString());
-            console.log('✅ Lock/Unlock OFT peer set to Mint/Burn OFT');
+            console.log('✅ Lock/Unlock OFT (Chain A) peer set to Mint/Burn OFT for EID_B');
         });
 
-        it('Set Mint/Burn OFT Peer (to Lock/Unlock OFT)', async () => {
+        it('Set Mint/Burn OFT (Chain B) Peer to Lock/Unlock OFT (Chain A)', async () => {
             const lockUnlockPeerBytes = StrKey.decodeContract(lockUnlockOftAddress);
 
             const assembledTx = await mintBurnOftClient.set_peer({
-                eid: EID,
+                eid: EID_A,
                 peer: Buffer.from(lockUnlockPeerBytes),
             });
             await assembledTx.signAndSend();
 
             const { result: peer } = await mintBurnOftClient.peer({
-                eid: EID,
+                eid: EID_A,
             });
             expect(peer?.toString()).toBe(Buffer.from(lockUnlockPeerBytes).toString());
-            console.log('✅ Mint/Burn OFT peer set to Lock/Unlock OFT');
+            console.log('✅ Mint/Burn OFT (Chain B) peer set to Lock/Unlock OFT for EID_A');
         });
 
         it('Set SAC Admin to Mint/Burn OFT (for minting)', async () => {
-            // The Mint/Burn OFT needs to be the admin of the SAC to mint tokens
             const server = new rpc.Server(RPC_URL, { allowHttp: true });
 
             const account = await server.getAccount(TOKEN_ISSUER.publicKey());
@@ -358,7 +367,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
         });
     });
 
-    describe('Send: Lock/Unlock -> Mint/Burn', () => {
+    describe('Send: Chain A (Lock) → Chain B (Mint)', () => {
         let sendLedger = 0;
         let packetSentEvent: PacketSentEvent;
         let guid: Buffer;
@@ -372,20 +381,20 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             console.log('📊 Initial Balances:');
             console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 10000000000)`);
 
-            const recipientABalance = await getTokenBalance(
-                RECIPIENT_A.publicKey(),
+            const recipientBBalance = await getTokenBalance(
+                RECIPIENT_B.publicKey(),
                 oftTokenAddress,
             );
-            console.log(`  - RECIPIENT_A: ${recipientABalance} (expected: 0)`);
+            console.log(`  - RECIPIENT_B (Chain B): ${recipientBBalance} (expected: 0)`);
 
             expect(senderBalance).toBe(10000000000n);
-            expect(recipientABalance).toBe(0n);
+            expect(recipientBBalance).toBe(0n);
         });
 
-        it('Quote OFT send', async () => {
-            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
+        it('Quote OFT send (A → B)', async () => {
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
             const sendParam: SendParam = {
-                dst_eid: EID,
+                dst_eid: EID_B,
                 to: Buffer.from(receiverBytes),
                 amount_ld: SEND_AMOUNT,
                 min_amount_ld: SEND_AMOUNT,
@@ -398,7 +407,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                 send_param: sendParam,
             });
             const [limit, feeDetails, receipt] = quoteResult;
-            console.log('📊 OFT Quote:');
+            console.log('📊 OFT Quote (A → B):');
             console.log('  Limit:', limit);
             console.log('  Fee Details:', feeDetails);
             console.log('  Receipt:', receipt);
@@ -406,10 +415,10 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             expect(receipt.amount_sent_ld).toBe(SEND_AMOUNT);
         });
 
-        it('Send tokens (Lock/Unlock -> Mint/Burn)', async () => {
-            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
+        it('Send tokens from Chain A to Chain B (Lock → Mint)', async () => {
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
             const sendParam: SendParam = {
-                dst_eid: EID,
+                dst_eid: EID_B,
                 to: Buffer.from(receiverBytes),
                 amount_ld: SEND_AMOUNT,
                 min_amount_ld: SEND_AMOUNT,
@@ -423,7 +432,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                 send_param: sendParam,
                 pay_in_zro: true,
             });
-            console.log('📊 Messaging Fee:', fee);
+            console.log('📊 Messaging Fee (A → B):', fee);
 
             const assembledTx = await lockUnlockOftClient.send({
                 from: DEFAULT_DEPLOYER.publicKey(),
@@ -440,22 +449,21 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             }
 
             if (txResponse) {
-                assertTransactionSucceeded(txResponse, 'OFT Send');
+                assertTransactionSucceeded(txResponse, 'OFT Send (A → B)');
             }
-            console.log('✅ Tokens sent, ledger:', sendLedger);
+            console.log('✅ Tokens sent from Chain A, ledger:', sendLedger);
         });
 
-        it('Scan PacketSent events', async () => {
-            const packetSentEvents = await scanPacketSentEvents(
-                protocolAddresses.endpointV2,
-                sendLedger,
-            );
+        it('Scan PacketSent events (A → B)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(chainA.endpointV2, sendLedger);
             expect(packetSentEvents.length).toBeGreaterThan(0);
             packetSentEvent = packetSentEvents[0];
-            console.log(`✅ PacketSent events scanned. Found ${packetSentEvents.length} events`);
+            console.log(
+                `✅ PacketSent events scanned from Chain A. Found ${packetSentEvents.length} events`,
+            );
         });
 
-        it('Validate packet via SML', async () => {
+        it('Validate packet via SML on Chain 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');
@@ -463,25 +471,25 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             const packetHeader = codec.header();
             const payloadHash = codec.payloadHash();
 
-            const assembledTx = await smlClient.validate_packet({
+            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('✅ Packet validated via SML');
+            console.log('✅ Packet validated via SML on Chain B');
         });
 
-        it('Receive tokens (mint on Mint/Burn OFT)', async () => {
+        it('Receive tokens on Chain B (mint)', async () => {
             const lockUnlockPeerBytes = StrKey.decodeContract(lockUnlockOftAddress);
             const origin = {
                 nonce: 1n,
                 sender: Buffer.from(lockUnlockPeerBytes),
-                src_eid: EID,
+                src_eid: EID_A,
             };
 
-            const assembledTx = await executorHelperClient.execute(
+            const assembledTx = await executorHelperClientB.execute(
                 {
-                    executor: protocolAddresses.executor,
+                    executor: chainB.executor,
                     params: {
                         extra_data: Buffer.from([]),
                         gas_limit: 0n,
@@ -499,18 +507,18 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             );
 
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainB.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'LzReceive (Mint)');
+            assertTransactionSucceeded(txResult, 'LzReceive on Chain B (Mint)');
 
-            console.log('✅ Tokens received and minted on Mint/Burn OFT');
+            console.log('✅ Tokens received and minted on Chain B');
         });
 
-        it('Verify balances after forward send', async () => {
+        it('Verify balances after forward send (A → B)', async () => {
             const senderBalance = await getTokenBalance(
                 DEFAULT_DEPLOYER.publicKey(),
                 oftTokenAddress,
@@ -519,35 +527,37 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                 lockUnlockOftAddress,
                 oftTokenAddress,
             );
-            const recipientABalance = await getTokenBalance(
-                RECIPIENT_A.publicKey(),
+            const recipientBBalance = await getTokenBalance(
+                RECIPIENT_B.publicKey(),
                 oftTokenAddress,
             );
 
-            console.log('📊 Balances after forward send:');
+            console.log('📊 Balances after forward send (A → B):');
             console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 9000000000)`);
             console.log(
-                `  - Lock/Unlock OFT (locked): ${lockUnlockOftBalance} (expected: 1000000000)`,
+                `  - Lock/Unlock OFT (Chain A, locked): ${lockUnlockOftBalance} (expected: 1000000000)`,
+            );
+            console.log(
+                `  - RECIPIENT_B (Chain B, minted): ${recipientBBalance} (expected: 1000000000)`,
             );
-            console.log(`  - RECIPIENT_A (minted): ${recipientABalance} (expected: 1000000000)`);
 
             expect(senderBalance).toBe(9000000000n);
             expect(lockUnlockOftBalance).toBe(1000000000n);
-            expect(recipientABalance).toBe(1000000000n);
+            expect(recipientBBalance).toBe(1000000000n);
         });
     });
 
-    describe('Send: Mint/Burn -> Lock/Unlock (Reverse)', () => {
+    describe('Send: Chain B (Burn) → Chain A (Unlock)', () => {
         let sendLedger = 0;
         let packetSentEvent: PacketSentEvent;
         let guid: Buffer;
         let message: Buffer;
         const REVERSE_SEND_AMOUNT = 50_0000000n;
 
-        it('Quote OFT send (reverse)', async () => {
-            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
+        it('Quote OFT send (B → A)', async () => {
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
             const sendParam: SendParam = {
-                dst_eid: EID,
+                dst_eid: EID_A,
                 to: Buffer.from(receiverBytes),
                 amount_ld: REVERSE_SEND_AMOUNT,
                 min_amount_ld: REVERSE_SEND_AMOUNT,
@@ -560,7 +570,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                 send_param: sendParam,
             });
             const [limit, feeDetails, receipt] = quoteResult;
-            console.log('📊 Reverse OFT Quote:');
+            console.log('📊 Reverse OFT Quote (B → A):');
             console.log('  Limit:', limit);
             console.log('  Fee Details:', feeDetails);
             console.log('  Receipt:', receipt);
@@ -568,10 +578,10 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             expect(receipt.amount_sent_ld).toBe(REVERSE_SEND_AMOUNT);
         });
 
-        it('Send tokens (Mint/Burn -> Lock/Unlock)', async () => {
-            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
+        it('Send tokens from Chain B to Chain A (Burn → Unlock)', async () => {
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
             const sendParam: SendParam = {
-                dst_eid: EID,
+                dst_eid: EID_A,
                 to: Buffer.from(receiverBytes),
                 amount_ld: REVERSE_SEND_AMOUNT,
                 min_amount_ld: REVERSE_SEND_AMOUNT,
@@ -585,7 +595,7 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
                 send_param: sendParam,
                 pay_in_zro: true,
             });
-            console.log('📊 Reverse Messaging Fee:', fee);
+            console.log('📊 Reverse Messaging Fee (B → A):', fee);
 
             const assembledTx = await mintBurnOftClient.send({
                 from: DEFAULT_DEPLOYER.publicKey(),
@@ -602,24 +612,21 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             }
 
             if (txResponse) {
-                assertTransactionSucceeded(txResponse, 'OFT Reverse Send');
+                assertTransactionSucceeded(txResponse, 'OFT Reverse Send (B → A)');
             }
-            console.log('✅ Tokens sent (reverse), ledger:', sendLedger);
+            console.log('✅ Tokens sent from Chain B (reverse), ledger:', sendLedger);
         });
 
-        it('Scan PacketSent events (reverse)', async () => {
-            const packetSentEvents = await scanPacketSentEvents(
-                protocolAddresses.endpointV2,
-                sendLedger,
-            );
+        it('Scan PacketSent events (B → A)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(chainB.endpointV2, sendLedger);
             expect(packetSentEvents.length).toBeGreaterThan(0);
             packetSentEvent = packetSentEvents[0];
             console.log(
-                `✅ PacketSent events scanned (reverse). Found ${packetSentEvents.length} events`,
+                `✅ PacketSent events scanned from Chain B (reverse). Found ${packetSentEvents.length} events`,
             );
         });
 
-        it('Validate packet via SML (reverse)', async () => {
+        it('Validate packet via SML on Chain A (reverse)', async () => {
             const packet = PacketSerializer.deserialize(packetSentEvent.encoded_packet);
             guid = Buffer.from(packet.guid.replace('0x', ''), 'hex');
             message = Buffer.from(packet.message.replace('0x', ''), 'hex');
@@ -627,25 +634,25 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             const packetHeader = codec.header();
             const payloadHash = codec.payloadHash();
 
-            const assembledTx = await smlClient.validate_packet({
+            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('✅ Packet validated via SML (reverse)');
+            console.log('✅ Packet validated via SML on Chain A (reverse)');
         });
 
-        it('Receive tokens (unlock on Lock/Unlock OFT)', async () => {
+        it('Receive tokens on Chain A (unlock)', async () => {
             const mintBurnPeerBytes = StrKey.decodeContract(mintBurnOftAddress);
             const origin = {
                 nonce: 1n,
                 sender: Buffer.from(mintBurnPeerBytes),
-                src_eid: EID,
+                src_eid: EID_B,
             };
 
-            const assembledTx = await executorHelperClient.execute(
+            const assembledTx = await executorHelperClientA.execute(
                 {
-                    executor: protocolAddresses.executor,
+                    executor: chainA.executor,
                     params: {
                         extra_data: Buffer.from([]),
                         gas_limit: 0n,
@@ -663,15 +670,15 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             );
 
             const txResult = await signAndSendWithExecutorAuth(
-                protocolAddresses.executor,
+                chainA.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            assertTransactionSucceeded(txResult, 'LzReceive (Unlock)');
+            assertTransactionSucceeded(txResult, 'LzReceive on Chain A (Unlock)');
 
-            console.log('✅ Tokens received and unlocked on Lock/Unlock OFT');
+            console.log('✅ Tokens received and unlocked on Chain A');
         });
 
         it('Verify final balances', async () => {
@@ -695,17 +702,27 @@ describe('OFT E2E Testing with SAC (SML)', async () => {
             console.log('\n📊 Final Balance Summary:');
             console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 8500000000)`);
             console.log(
-                `  - Lock/Unlock OFT (locked): ${lockUnlockOftBalance} (expected: 500000000)`,
+                `  - Lock/Unlock OFT (Chain A, locked): ${lockUnlockOftBalance} (expected: 500000000)`,
+            );
+            console.log(
+                `  - RECIPIENT_A (Chain A, unlocked): ${recipientABalance} (expected: 500000000)`,
+            );
+            console.log(
+                `  - RECIPIENT_B (Chain B, minted): ${recipientBBalance} (expected: 1000000000)`,
             );
-            console.log(`  - RECIPIENT_A (minted): ${recipientABalance} (expected: 1000000000)`);
-            console.log(`  - RECIPIENT_B (unlocked): ${recipientBBalance} (expected: 500000000)`);
 
             expect(senderBalance).toBe(8500000000n);
             expect(lockUnlockOftBalance).toBe(500000000n);
-            expect(recipientABalance).toBe(1000000000n);
-            expect(recipientBBalance).toBe(500000000n);
+            expect(recipientABalance).toBe(500000000n);
+            expect(recipientBBalance).toBe(1000000000n);
 
-            console.log('✅ OFT E2E test completed successfully!');
+            console.log('\n🎉 OFT Cross-Chain E2E test completed successfully!');
+            console.log(
+                '   Chain A (Lock/Unlock) → Chain B (Mint/Burn): 100 tokens locked, 100 minted',
+            );
+            console.log(
+                '   Chain B (Mint/Burn) → Chain A (Lock/Unlock): 50 tokens burned, 50 unlocked',
+            );
         });
     });
 });