@layerzerolabs/protocol-stellar-v2 0.2.11 → 0.2.13

package/sdk/test/oft.test.ts

@@ -0,0 +1,847 @@
+import {
+    Address,
+    Asset,
+    BASE_FEE,
+    Contract,
+    Keypair,
+    nativeToScVal,
+    Operation,
+    rpc,
+    scValToNative,
+    StrKey,
+    TransactionBuilder,
+} from '@stellar/stellar-sdk';
+import path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { $ } from 'zx';
+
+import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
+import { PacketSerializer, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities';
+
+import { Client as EndpointClient } from '../src/generated/endpoint';
+import { Client as ExecutorClient } from '../src/generated/executor';
+import { Client as ExecutorHelperClient } from '../src/generated/executor_helper';
+import { Client as OFTStdClient, SendParam } from '../src/generated/oft_std';
+import { Client as SMLClient } from '../src/generated/sml';
+import {
+    DEFAULT_DEPLOYER,
+    EID,
+    NATIVE_TOKEN_ADDRESS,
+    NETWORK_PASSPHRASE,
+    RPC_URL,
+    ZRO_TOKEN_ADDRESS,
+} from './suites/constants';
+import { deployAssetSac, deployContract } from './suites/deploy';
+import { fundAccount, startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
+import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
+import { assertTransactionsSucceeded, signExecutorAuthEntries } from './utils';
+
+/**
+ * Helper to get SAC token balance for an address
+ */
+async function getSacBalance(tokenAddress: string, accountAddress: string): Promise<bigint> {
+    const server = new rpc.Server(RPC_URL, { allowHttp: true });
+    const tokenContract = new Contract(tokenAddress);
+
+    // Build the balance call
+    const balanceOp = tokenContract.call(
+        'balance',
+        nativeToScVal(Address.fromString(accountAddress), { type: 'address' }),
+    );
+
+    const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
+    const tx = new TransactionBuilder(account, {
+        fee: BASE_FEE,
+        networkPassphrase: NETWORK_PASSPHRASE,
+    })
+        .addOperation(balanceOp)
+        .setTimeout(30)
+        .build();
+
+    const simulated = await server.simulateTransaction(tx);
+    if (rpc.Api.isSimulationError(simulated)) {
+        throw new Error(`Balance query failed: ${JSON.stringify(simulated)}`);
+    }
+
+    // Extract result from simulation
+    const result = (simulated as rpc.Api.SimulateTransactionSuccessResponse).result;
+    if (result?.retval) {
+        return scValToNative(result.retval) as bigint;
+    }
+    return 0n;
+}
+
+$.verbose = true;
+$.stdio = ['inherit', 'pipe', process.stderr];
+
+// Contract addresses
+const CONTRACT_ADDRESSES = {
+    endpointV2: '',
+    sml: '',
+    executor: '',
+    executorHelper: '',
+    oftToken: '', // The SAC for OFT token
+    lockUnlockOft: '',
+    mintBurnOft: '',
+};
+
+// Clients
+let endpointClient: EndpointClient;
+let smlClient: SMLClient;
+let executorClient: ExecutorClient;
+let executorHelperClient: ExecutorHelperClient;
+let lockUnlockOftClient: OFTStdClient;
+let mintBurnOftClient: OFTStdClient;
+
+// Test accounts
+const EXECUTOR_ADMIN = Keypair.random();
+const TOKEN_ISSUER = Keypair.random();
+// Use DEFAULT_DEPLOYER as SENDER (same pattern as Counter test)
+// The deployer has proper signing setup with the contract clients
+
+// 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
+
+// OFT Token asset (custom token for testing)
+const OFT_TOKEN_CODE = 'OFT';
+let OFT_ASSET: Asset;
+
+// Constants
+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', async () => {
+    const repoRoot = await getFullyQualifiedRepoRootPath();
+    const wasmDir = path.join(
+        repoRoot,
+        'contracts',
+        'protocol',
+        'stellar',
+        'target',
+        'wasm32v1-none',
+        'release',
+    );
+
+    const ENDPOINT_WASM_PATH = path.join(wasmDir, 'endpoint_v2.wasm');
+    const SML_WASM_PATH = path.join(wasmDir, 'simple_message_lib.wasm');
+    const EXECUTOR_WASM_PATH = path.join(wasmDir, 'executor.wasm');
+    const EXECUTOR_HELPER_WASM_PATH = path.join(wasmDir, 'executor_helper.wasm');
+    const OFT_STD_WASM_PATH = path.join(wasmDir, 'oft_std.wasm');
+
+    beforeAll(async () => {
+        await startStellarLocalnet();
+        // Fund test accounts
+        await fundAccount(EXECUTOR_ADMIN.publicKey());
+        await fundAccount(TOKEN_ISSUER.publicKey());
+        await fundAccount(RECIPIENT_A.publicKey());
+        await fundAccount(RECIPIENT_B.publicKey());
+
+        // Create the OFT asset (TOKEN_ISSUER is the issuer)
+        OFT_ASSET = new Asset(OFT_TOKEN_CODE, TOKEN_ISSUER.publicKey());
+    }, 120000); // 2 minute timeout for setup
+
+    afterAll(async () => {
+        await stopStellarLocalnet();
+    });
+
+    describe('Contract Deployments', () => {
+        it('Deploy Endpoint', async () => {
+            endpointClient = await deployContract<EndpointClient>(
+                EndpointClient,
+                ENDPOINT_WASM_PATH,
+                {
+                    eid: EID,
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    native_token: NATIVE_TOKEN_ADDRESS,
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            CONTRACT_ADDRESSES.endpointV2 = endpointClient.options.contractId;
+            console.log('✅ Endpoint deployed:', CONTRACT_ADDRESSES.endpointV2);
+        });
+
+        it('Deploy SimpleMessageLib', async () => {
+            smlClient = await deployContract<SMLClient>(
+                SMLClient,
+                SML_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    fee_recipient: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            CONTRACT_ADDRESSES.sml = smlClient.options.contractId;
+            console.log('✅ SimpleMessageLib deployed:', CONTRACT_ADDRESSES.sml);
+        });
+
+        it('Deploy Executor Helper', async () => {
+            executorHelperClient = await deployContract<ExecutorHelperClient>(
+                ExecutorHelperClient,
+                EXECUTOR_HELPER_WASM_PATH,
+                undefined,
+                DEFAULT_DEPLOYER,
+            );
+            CONTRACT_ADDRESSES.executorHelper = executorHelperClient.options.contractId;
+            console.log('✅ Executor Helper deployed:', CONTRACT_ADDRESSES.executorHelper);
+        });
+
+        it('Deploy Executor', async () => {
+            const whitelist = [
+                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'native_drop_and_execute' },
+                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'execute' },
+                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'compose' },
+                { contract: CONTRACT_ADDRESSES.executorHelper, fn_name: 'native_drop' },
+            ];
+
+            executorClient = await deployContract<ExecutorClient>(
+                ExecutorClient,
+                EXECUTOR_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    whitelist,
+                    admins: [EXECUTOR_ADMIN.publicKey()],
+                    message_libs: [CONTRACT_ADDRESSES.sml],
+                    // FIXME: Add price feed
+                    price_feed: CONTRACT_ADDRESSES.endpointV2,
+                    default_multiplier_bps: 10000,
+                },
+                DEFAULT_DEPLOYER,
+            );
+            CONTRACT_ADDRESSES.executor = executorClient.options.contractId;
+            console.log('✅ Executor deployed:', CONTRACT_ADDRESSES.executor);
+        });
+
+        it('Deploy OFT Token SAC', async () => {
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // Step 1: Issue the OFT token to DEFAULT_DEPLOYER and set up trustlines for recipients
+            const issuerAccount = await server.getAccount(TOKEN_ISSUER.publicKey());
+            const issueTx = new TransactionBuilder(issuerAccount, {
+                fee: BASE_FEE,
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                // Trustline for DEFAULT_DEPLOYER (sender)
+                .addOperation(
+                    Operation.changeTrust({
+                        asset: OFT_ASSET,
+                        source: DEFAULT_DEPLOYER.publicKey(),
+                    }),
+                )
+                // Trustline for RECIPIENT_A (receives minted tokens)
+                .addOperation(
+                    Operation.changeTrust({
+                        asset: OFT_ASSET,
+                        source: RECIPIENT_A.publicKey(),
+                    }),
+                )
+                // Trustline for RECIPIENT_B (receives unlocked tokens)
+                .addOperation(
+                    Operation.changeTrust({
+                        asset: OFT_ASSET,
+                        source: RECIPIENT_B.publicKey(),
+                    }),
+                )
+                // Issue tokens to DEFAULT_DEPLOYER
+                .addOperation(
+                    Operation.payment({
+                        asset: OFT_ASSET,
+                        amount: INITIAL_TOKEN_AMOUNT,
+                        destination: DEFAULT_DEPLOYER.publicKey(),
+                    }),
+                )
+                .setTimeout(30)
+                .build();
+
+            issueTx.sign(TOKEN_ISSUER, DEFAULT_DEPLOYER, RECIPIENT_A, RECIPIENT_B);
+            const sendResult = await server.sendTransaction(issueTx);
+            if (sendResult.status !== 'PENDING') {
+                throw new Error(`Failed to issue OFT token: ${JSON.stringify(sendResult)}`);
+            }
+            const txResult = await server.pollTransaction(sendResult.hash);
+            if (txResult.status !== 'SUCCESS') {
+                throw new Error(`Failed to issue OFT token: ${JSON.stringify(txResult)}`);
+            }
+            console.log('✅ OFT token issued to DEFAULT_DEPLOYER');
+
+            // Step 2: Deploy the SAC for the OFT token
+            CONTRACT_ADDRESSES.oftToken = await deployAssetSac(OFT_ASSET);
+            console.log('✅ OFT Token SAC deployed:', CONTRACT_ADDRESSES.oftToken);
+        });
+
+        it('Deploy Lock/Unlock OFT', async () => {
+            lockUnlockOftClient = await deployContract<OFTStdClient>(
+                OFTStdClient,
+                OFT_STD_WASM_PATH,
+                {
+                    token: CONTRACT_ADDRESSES.oftToken,
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                    shared_decimals: SHARED_DECIMALS,
+                    is_lock_unlock: true, // Lock/Unlock mode
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            CONTRACT_ADDRESSES.lockUnlockOft = lockUnlockOftClient.options.contractId;
+            console.log('✅ Lock/Unlock OFT deployed:', CONTRACT_ADDRESSES.lockUnlockOft);
+
+            // Verify it's in lock/unlock mode
+            const { result: isLockUnlock } = await lockUnlockOftClient.is_lock_unlock();
+            expect(isLockUnlock).toBe(true);
+        });
+
+        it('Deploy Mint/Burn OFT', async () => {
+            mintBurnOftClient = await deployContract<OFTStdClient>(
+                OFTStdClient,
+                OFT_STD_WASM_PATH,
+                {
+                    token: CONTRACT_ADDRESSES.oftToken,
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                    shared_decimals: SHARED_DECIMALS,
+                    is_lock_unlock: false, // Mint/Burn mode
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            CONTRACT_ADDRESSES.mintBurnOft = mintBurnOftClient.options.contractId;
+            console.log('✅ Mint/Burn OFT deployed:', CONTRACT_ADDRESSES.mintBurnOft);
+
+            // Verify it's in mint/burn mode
+            const { result: isLockUnlock } = await mintBurnOftClient.is_lock_unlock();
+            expect(isLockUnlock).toBe(false);
+        });
+
+        it('Verify all contracts deployed', () => {
+            console.log('\n📋 All deployed contracts:');
+            console.log('  Endpoint:', CONTRACT_ADDRESSES.endpointV2);
+            console.log('  SimpleMessageLib:', CONTRACT_ADDRESSES.sml);
+            console.log('  Executor:', CONTRACT_ADDRESSES.executor);
+            console.log('  Executor Helper:', CONTRACT_ADDRESSES.executorHelper);
+            console.log('  OFT Token SAC:', CONTRACT_ADDRESSES.oftToken);
+            console.log('  Lock/Unlock OFT:', CONTRACT_ADDRESSES.lockUnlockOft);
+            console.log('  Mint/Burn OFT:', CONTRACT_ADDRESSES.mintBurnOft);
+        });
+    });
+
+    describe('Wire Contracts', () => {
+        it('Register Library', async () => {
+            const assembledTx = await endpointClient.register_library({
+                new_lib: CONTRACT_ADDRESSES.sml,
+            });
+            await assembledTx.signAndSend();
+            const { result: libs } = await endpointClient.get_registered_libraries({
+                start: 0,
+                max_count: 100,
+            });
+            expect(libs.length).toBe(1);
+            expect(libs[0]).toBe(CONTRACT_ADDRESSES.sml);
+            console.log('✅ Library registered');
+        });
+
+        it('Set Default Send Library', async () => {
+            const assembledTx = await endpointClient.set_default_send_library({
+                dst_eid: EID,
+                new_lib: CONTRACT_ADDRESSES.sml,
+            });
+            await assembledTx.signAndSend();
+            const { result: defaultSendLib } = await endpointClient.default_send_library({
+                dst_eid: EID,
+            });
+            expect(defaultSendLib).toBe(CONTRACT_ADDRESSES.sml);
+            console.log('✅ Default send library set');
+        });
+
+        it('Set Default Receive Library', async () => {
+            const assembledTx = await endpointClient.set_default_receive_library({
+                src_eid: EID,
+                new_lib: CONTRACT_ADDRESSES.sml,
+                grace_period: 0n,
+            });
+            await assembledTx.signAndSend();
+            const { result: defaultReceiveLib } = await endpointClient.default_receive_library({
+                src_eid: EID,
+            });
+            expect(defaultReceiveLib).toBe(CONTRACT_ADDRESSES.sml);
+            console.log('✅ Default receive library set');
+        });
+
+        it('Set ZRO Token', async () => {
+            const setZroTx = await endpointClient.set_zro({
+                zro: ZRO_TOKEN_ADDRESS,
+            });
+            await setZroTx.signAndSend();
+
+            const { result: newZroToken } = await endpointClient.zro();
+            expect(newZroToken).toBe(ZRO_TOKEN_ADDRESS);
+            console.log('✅ ZRO token set:', ZRO_TOKEN_ADDRESS);
+        });
+
+        it('Set Lock/Unlock OFT Peer (to Mint/Burn OFT)', async () => {
+            const mintBurnPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.mintBurnOft);
+
+            const assembledTx = await lockUnlockOftClient.set_peer({
+                eid: EID,
+                peer: Buffer.from(mintBurnPeerBytes),
+            });
+            await assembledTx.signAndSend();
+
+            const { result: peer } = await lockUnlockOftClient.peer({
+                eid: EID,
+            });
+            expect(peer?.toString()).toBe(Buffer.from(mintBurnPeerBytes).toString());
+            console.log('✅ Lock/Unlock OFT peer set to Mint/Burn OFT');
+        });
+
+        it('Set Mint/Burn OFT Peer (to Lock/Unlock OFT)', async () => {
+            const lockUnlockPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.lockUnlockOft);
+
+            const assembledTx = await mintBurnOftClient.set_peer({
+                eid: EID,
+                peer: Buffer.from(lockUnlockPeerBytes),
+            });
+            await assembledTx.signAndSend();
+
+            const { result: peer } = await mintBurnOftClient.peer({
+                eid: EID,
+            });
+            expect(peer?.toString()).toBe(Buffer.from(lockUnlockPeerBytes).toString());
+            console.log('✅ Mint/Burn OFT peer set to Lock/Unlock OFT');
+        });
+
+        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
+            // Use the SAC's set_admin function
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // Build set_admin transaction
+            // SAC's set_admin function requires the current admin (TOKEN_ISSUER) to sign
+            const account = await server.getAccount(TOKEN_ISSUER.publicKey());
+
+            // Build the invokeContract operation for SAC's set_admin
+            const setAdminTx = new TransactionBuilder(account, {
+                fee: BASE_FEE,
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                .addOperation(
+                    Operation.invokeContractFunction({
+                        contract: CONTRACT_ADDRESSES.oftToken,
+                        function: 'set_admin',
+                        args: [
+                            // new_admin: Address
+                            Address.fromString(CONTRACT_ADDRESSES.mintBurnOft).toScVal(),
+                        ],
+                    }),
+                )
+                .setTimeout(30)
+                .build();
+
+            const simulated = await server.simulateTransaction(setAdminTx);
+            if (rpc.Api.isSimulationError(simulated)) {
+                throw new Error(`Simulation failed: ${JSON.stringify(simulated)}`);
+            }
+            const preparedTx = rpc.assembleTransaction(setAdminTx, simulated).build();
+            preparedTx.sign(TOKEN_ISSUER);
+
+            const sendResult = await server.sendTransaction(preparedTx);
+            if (sendResult.status !== 'PENDING') {
+                throw new Error(`Failed to set admin: ${JSON.stringify(sendResult)}`);
+            }
+            const txResult = await server.pollTransaction(sendResult.hash);
+            if (txResult.status !== 'SUCCESS') {
+                throw new Error(`Failed to set admin: ${JSON.stringify(txResult)}`);
+            }
+
+            console.log('✅ SAC admin set to Mint/Burn OFT');
+        });
+    });
+
+    describe('Send: Lock/Unlock -> Mint/Burn', () => {
+        let sendLedger = 0;
+        let packetSentEvent: PacketSentEvent;
+        let guid: Buffer;
+        let message: Buffer;
+
+        it('Verify initial balances', async () => {
+            // Check sender balance (DEFAULT_DEPLOYER has 1000 OFT tokens)
+            const senderBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                DEFAULT_DEPLOYER.publicKey(),
+            );
+            console.log('📊 Initial Balances:');
+            console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 10000000000)`);
+
+            // RECIPIENT_A should have 0 tokens
+            const recipientABalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                RECIPIENT_A.publicKey(),
+            );
+            console.log(`  - RECIPIENT_A: ${recipientABalance} (expected: 0)`);
+
+            expect(senderBalance).toBe(10000000000n); // 1000 tokens with 7 decimals
+            expect(recipientABalance).toBe(0n);
+        });
+
+        it('Quote OFT send', async () => {
+            // Build SendParam - send to RECIPIENT_A
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
+            const sendParam: SendParam = {
+                dst_eid: EID,
+                to: Buffer.from(receiverBytes),
+                amount_ld: SEND_AMOUNT,
+                min_amount_ld: SEND_AMOUNT, // No slippage for test
+                extra_options: Buffer.from([]),
+                compose_msg: Buffer.from([]),
+                oft_cmd: Buffer.from([]),
+            };
+
+            // Quote OFT
+            const { result: quoteResult } = await lockUnlockOftClient.quote_oft({
+                send_param: sendParam,
+            });
+            const [limit, feeDetails, receipt] = quoteResult;
+            console.log('📊 OFT Quote:');
+            console.log('  Limit:', limit);
+            console.log('  Fee Details:', feeDetails);
+            console.log('  Receipt:', receipt);
+
+            expect(receipt.amount_sent_ld).toBe(SEND_AMOUNT);
+        });
+
+        it('Send tokens (Lock/Unlock -> Mint/Burn)', async () => {
+            // Build SendParam - send to RECIPIENT_A
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_A.publicKey());
+            const sendParam: SendParam = {
+                dst_eid: EID,
+                to: Buffer.from(receiverBytes),
+                amount_ld: SEND_AMOUNT,
+                min_amount_ld: SEND_AMOUNT,
+                extra_options: Buffer.from([]),
+                compose_msg: Buffer.from([]),
+                oft_cmd: Buffer.from([]),
+            };
+
+            // Quote send fee (pay in ZRO like Counter test does)
+            const { result: fee } = await lockUnlockOftClient.quote_send({
+                sender: DEFAULT_DEPLOYER.publicKey(),
+                send_param: sendParam,
+                pay_in_zro: true,
+            });
+            console.log('📊 Messaging Fee:', fee);
+
+            // Send tokens
+            const assembledTx = await lockUnlockOftClient.send({
+                sender: DEFAULT_DEPLOYER.publicKey(),
+                send_param: sendParam,
+                fee: fee,
+                refund_address: DEFAULT_DEPLOYER.publicKey(),
+            });
+
+            // Sign and send
+            const sentTx = await assembledTx.signAndSend();
+
+            // Extract ledger number
+            const txResponse = sentTx.getTransactionResponse;
+            if (txResponse && 'ledger' in txResponse) {
+                sendLedger = txResponse.ledger;
+            }
+
+            assertTransactionsSucceeded(sentTx, 'OFT Send');
+            console.log('✅ Tokens sent, ledger:', sendLedger);
+        });
+
+        it('Scan PacketSent events', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                CONTRACT_ADDRESSES.endpointV2,
+                sendLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            packetSentEvent = packetSentEvents[0];
+            console.log(`✅ PacketSent events scanned. Found ${packetSentEvents.length} events`);
+        });
+
+        it('Validate packet 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({
+                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');
+        });
+
+        it('Receive tokens (mint on Mint/Burn OFT)', async () => {
+            const lockUnlockPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.lockUnlockOft);
+            const origin = {
+                nonce: 1n,
+                sender: Buffer.from(lockUnlockPeerBytes),
+                src_eid: EID,
+            };
+
+            // Use native_drop_and_execute with empty native_drop_params
+            const assembledTx = await executorHelperClient.native_drop_and_execute({
+                executor: CONTRACT_ADDRESSES.executor,
+                admin: EXECUTOR_ADMIN.publicKey(),
+                origin,
+                dst_eid: EID,
+                oapp: CONTRACT_ADDRESSES.mintBurnOft,
+                native_drop_params: [],
+                execute_params: {
+                    extra_data: Buffer.from([]),
+                    gas_limit: 0n,
+                    guid,
+                    message,
+                    origin,
+                    receiver: CONTRACT_ADDRESSES.mintBurnOft,
+                    value: 0n,
+                },
+            });
+
+            // Sign the Executor's auth entries
+            await signExecutorAuthEntries(
+                CONTRACT_ADDRESSES.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            // Sign and send
+            const sentTx = await assembledTx.signAndSend();
+            assertTransactionsSucceeded(sentTx, 'LzReceive (Mint)');
+
+            console.log('✅ Tokens received and minted on Mint/Burn OFT');
+        });
+
+        it('Verify balances after forward send', async () => {
+            // Balance changes after forward send:
+            // - Sender (DEFAULT_DEPLOYER): 1000 - 100 = 900 tokens
+            // - Lock/Unlock OFT contract: holds 100 locked tokens
+            // - RECIPIENT_A: received 100 minted tokens
+
+            const senderBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                DEFAULT_DEPLOYER.publicKey(),
+            );
+            const lockUnlockOftBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                CONTRACT_ADDRESSES.lockUnlockOft,
+            );
+            const recipientABalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                RECIPIENT_A.publicKey(),
+            );
+
+            console.log('📊 Balances after forward send:');
+            console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 9000000000)`);
+            console.log(
+                `  - Lock/Unlock OFT (locked): ${lockUnlockOftBalance} (expected: 1000000000)`,
+            );
+            console.log(`  - RECIPIENT_A (minted): ${recipientABalance} (expected: 1000000000)`);
+
+            expect(senderBalance).toBe(9000000000n); // 900 tokens
+            expect(lockUnlockOftBalance).toBe(1000000000n); // 100 tokens locked
+            expect(recipientABalance).toBe(1000000000n); // 100 tokens minted
+        });
+    });
+
+    describe('Send: Mint/Burn -> Lock/Unlock (Reverse)', () => {
+        let sendLedger = 0;
+        let packetSentEvent: PacketSentEvent;
+        let guid: Buffer;
+        let message: Buffer;
+        const REVERSE_SEND_AMOUNT = 50_0000000n; // 50 tokens
+
+        it('Quote OFT send (reverse)', async () => {
+            // Send to RECIPIENT_B
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
+            const sendParam: SendParam = {
+                dst_eid: EID,
+                to: Buffer.from(receiverBytes),
+                amount_ld: REVERSE_SEND_AMOUNT,
+                min_amount_ld: REVERSE_SEND_AMOUNT,
+                extra_options: Buffer.from([]),
+                compose_msg: Buffer.from([]),
+                oft_cmd: Buffer.from([]),
+            };
+
+            const { result: quoteResult } = await mintBurnOftClient.quote_oft({
+                send_param: sendParam,
+            });
+            const [limit, feeDetails, receipt] = quoteResult;
+            console.log('📊 Reverse OFT Quote:');
+            console.log('  Limit:', limit);
+            console.log('  Fee Details:', feeDetails);
+            console.log('  Receipt:', receipt);
+
+            expect(receipt.amount_sent_ld).toBe(REVERSE_SEND_AMOUNT);
+        });
+
+        it('Send tokens (Mint/Burn -> Lock/Unlock)', async () => {
+            // DEFAULT_DEPLOYER sends via Mint/Burn OFT to RECIPIENT_B
+            const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
+            const sendParam: SendParam = {
+                dst_eid: EID,
+                to: Buffer.from(receiverBytes),
+                amount_ld: REVERSE_SEND_AMOUNT,
+                min_amount_ld: REVERSE_SEND_AMOUNT,
+                extra_options: Buffer.from([]),
+                compose_msg: Buffer.from([]),
+                oft_cmd: Buffer.from([]),
+            };
+
+            // Quote send fee (pay in ZRO like Counter test does)
+            const { result: fee } = await mintBurnOftClient.quote_send({
+                sender: DEFAULT_DEPLOYER.publicKey(),
+                send_param: sendParam,
+                pay_in_zro: true,
+            });
+            console.log('📊 Reverse Messaging Fee:', fee);
+
+            // Send tokens
+            const assembledTx = await mintBurnOftClient.send({
+                sender: DEFAULT_DEPLOYER.publicKey(),
+                send_param: sendParam,
+                fee: fee,
+                refund_address: DEFAULT_DEPLOYER.publicKey(),
+            });
+
+            // Sign and send
+            const sentTx = await assembledTx.signAndSend();
+
+            // Extract ledger number
+            const txResponse = sentTx.getTransactionResponse;
+            if (txResponse && 'ledger' in txResponse) {
+                sendLedger = txResponse.ledger;
+            }
+
+            assertTransactionsSucceeded(sentTx, 'OFT Reverse Send');
+            console.log('✅ Tokens sent (reverse), ledger:', sendLedger);
+        });
+
+        it('Scan PacketSent events (reverse)', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                CONTRACT_ADDRESSES.endpointV2,
+                sendLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            packetSentEvent = packetSentEvents[0];
+            console.log(
+                `✅ PacketSent events scanned (reverse). Found ${packetSentEvents.length} events`,
+            );
+        });
+
+        it('Validate packet via SML (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');
+            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('✅ Packet validated via SML (reverse)');
+        });
+
+        it('Receive tokens (unlock on Lock/Unlock OFT)', async () => {
+            const mintBurnPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.mintBurnOft);
+            const origin = {
+                nonce: 1n,
+                sender: Buffer.from(mintBurnPeerBytes),
+                src_eid: EID,
+            };
+
+            // Use native_drop_and_execute with empty native_drop_params
+            const assembledTx = await executorHelperClient.native_drop_and_execute({
+                executor: CONTRACT_ADDRESSES.executor,
+                admin: EXECUTOR_ADMIN.publicKey(),
+                origin,
+                dst_eid: EID,
+                oapp: CONTRACT_ADDRESSES.lockUnlockOft,
+                native_drop_params: [],
+                execute_params: {
+                    extra_data: Buffer.from([]),
+                    gas_limit: 0n,
+                    guid,
+                    message,
+                    origin,
+                    receiver: CONTRACT_ADDRESSES.lockUnlockOft,
+                    value: 0n,
+                },
+            });
+
+            // Sign the Executor's auth entries
+            await signExecutorAuthEntries(
+                CONTRACT_ADDRESSES.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            // Sign and send
+            const sentTx = await assembledTx.signAndSend();
+            assertTransactionsSucceeded(sentTx, 'LzReceive (Unlock)');
+
+            console.log('✅ Tokens received and unlocked on Lock/Unlock OFT');
+        });
+
+        it('Verify final balances', async () => {
+            // Final balance summary:
+            // - DEFAULT_DEPLOYER: started with 1000, sent 100 (locked), sent 50 (burned) = 850
+            // - Lock/Unlock OFT: locked 100, unlocked 50 = 50 held
+            // - RECIPIENT_A: received 100 (minted)
+            // - RECIPIENT_B: received 50 (unlocked)
+
+            const senderBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                DEFAULT_DEPLOYER.publicKey(),
+            );
+            const lockUnlockOftBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                CONTRACT_ADDRESSES.lockUnlockOft,
+            );
+            const recipientABalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                RECIPIENT_A.publicKey(),
+            );
+            const recipientBBalance = await getSacBalance(
+                CONTRACT_ADDRESSES.oftToken,
+                RECIPIENT_B.publicKey(),
+            );
+
+            console.log('\n📊 Final Balance Summary:');
+            console.log(`  - Sender (DEFAULT_DEPLOYER): ${senderBalance} (expected: 8500000000)`);
+            console.log(
+                `  - Lock/Unlock OFT (locked): ${lockUnlockOftBalance} (expected: 500000000)`,
+            );
+            console.log(`  - RECIPIENT_A (minted): ${recipientABalance} (expected: 1000000000)`);
+            console.log(`  - RECIPIENT_B (unlocked): ${recipientBBalance} (expected: 500000000)`);
+
+            expect(senderBalance).toBe(8500000000n); // 850 tokens (1000 - 100 - 50)
+            expect(lockUnlockOftBalance).toBe(500000000n); // 50 tokens (100 - 50)
+            expect(recipientABalance).toBe(1000000000n); // 100 tokens minted
+            expect(recipientBBalance).toBe(500000000n); // 50 tokens unlocked
+
+            console.log('✅ OFT E2E test completed successfully!');
+        });
+    });
+});