@layerzerolabs/lz-v2-stellar-sdk 0.2.13 → 0.2.18

package/test/{oft.test.ts → oft-sml.test.ts}

@@ -2,102 +2,56 @@ 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 { beforeAll, describe, expect, inject, it } from 'vitest';
 
 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 OFTStdClient, OFTMode, SendParam } from '../src/generated/oft_std';
 import { Client as SMLClient } from '../src/generated/sml';
 import {
     DEFAULT_DEPLOYER,
     EID,
-    NATIVE_TOKEN_ADDRESS,
+    EXECUTOR_ADMIN,
     NETWORK_PASSPHRASE,
     RPC_URL,
-    ZRO_TOKEN_ADDRESS,
 } from './suites/constants';
 import { deployAssetSac, deployContract } from './suites/deploy';
-import { fundAccount, startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
+import { fundAccount } 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' }),
-    );
+import {
+    assertTransactionSucceeded,
+    createClient,
+    getTokenBalance,
+    signAndSendWithExecutorAuth,
+} from './utils';
+
+// Protocol addresses (will be injected from globalSetup in beforeAll)
+let protocolAddresses: ReturnType<typeof inject<'protocolAddresses'>>;
 
-    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: '',
-};
+// OFT-specific addresses
+let oftTokenAddress = '';
+let lockUnlockOftAddress = '';
+let mintBurnOftAddress = '';
 
 // 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
@@ -114,7 +68,7 @@ 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 () => {
+describe('OFT E2E Testing with SAC (SML)', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
     const wasmDir = path.join(
         repoRoot,
@@ -126,99 +80,33 @@ describe('OFT E2E Testing with SAC', async () => {
         '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();
+        // 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);
+
         // 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);
-        });
-
+    describe('Deploy OFT Contracts', () => {
         it('Deploy OFT Token SAC', async () => {
             const server = new rpc.Server(RPC_URL, { allowHttp: true });
 
@@ -272,8 +160,8 @@ describe('OFT E2E Testing with SAC', async () => {
             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);
+            oftTokenAddress = await deployAssetSac(OFT_ASSET);
+            console.log('✅ OFT Token SAC deployed:', oftTokenAddress);
         });
 
         it('Deploy Lock/Unlock OFT', async () => {
@@ -281,22 +169,22 @@ describe('OFT E2E Testing with SAC', async () => {
                 OFTStdClient,
                 OFT_STD_WASM_PATH,
                 {
-                    token: CONTRACT_ADDRESSES.oftToken,
+                    token: oftTokenAddress,
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    endpoint: protocolAddresses.endpointV2,
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    is_lock_unlock: true, // Lock/Unlock mode
+                    mode: OFTMode.LockUnlock, // Lock/Unlock mode
                 },
                 DEFAULT_DEPLOYER,
             );
 
-            CONTRACT_ADDRESSES.lockUnlockOft = lockUnlockOftClient.options.contractId;
-            console.log('✅ Lock/Unlock OFT deployed:', CONTRACT_ADDRESSES.lockUnlockOft);
+            lockUnlockOftAddress = lockUnlockOftClient.options.contractId;
+            console.log('✅ Lock/Unlock OFT deployed:', lockUnlockOftAddress);
 
             // Verify it's in lock/unlock mode
-            const { result: isLockUnlock } = await lockUnlockOftClient.is_lock_unlock();
-            expect(isLockUnlock).toBe(true);
+            const { result: mode } = await lockUnlockOftClient.mode();
+            expect(mode).toEqual(OFTMode.LockUnlock);
         });
 
         it('Deploy Mint/Burn OFT', async () => {
@@ -304,91 +192,102 @@ describe('OFT E2E Testing with SAC', async () => {
                 OFTStdClient,
                 OFT_STD_WASM_PATH,
                 {
-                    token: CONTRACT_ADDRESSES.oftToken,
+                    token: oftTokenAddress,
                     owner: DEFAULT_DEPLOYER.publicKey(),
-                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    endpoint: protocolAddresses.endpointV2,
                     delegate: DEFAULT_DEPLOYER.publicKey(),
                     shared_decimals: SHARED_DECIMALS,
-                    is_lock_unlock: false, // Mint/Burn mode
+                    mode: OFTMode.MintBurn, // Mint/Burn mode
                 },
                 DEFAULT_DEPLOYER,
             );
 
-            CONTRACT_ADDRESSES.mintBurnOft = mintBurnOftClient.options.contractId;
-            console.log('✅ Mint/Burn OFT deployed:', CONTRACT_ADDRESSES.mintBurnOft);
+            mintBurnOftAddress = mintBurnOftClient.options.contractId;
+            console.log('✅ Mint/Burn OFT deployed:', mintBurnOftAddress);
 
             // Verify it's in mint/burn mode
-            const { result: isLockUnlock } = await mintBurnOftClient.is_lock_unlock();
-            expect(isLockUnlock).toBe(false);
+            const { result: mode } = await mintBurnOftClient.mode();
+            expect(mode).toEqual(OFTMode.MintBurn);
         });
+    });
 
-        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 OFT Contracts to use SML', () => {
+        it('Set Lock/Unlock OFT Send Library to SML', async () => {
+            const assembledTx = await endpointClient.set_send_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                sender: lockUnlockOftAddress,
+                dst_eid: EID,
+                new_lib: protocolAddresses.sml,
+            });
+            await assembledTx.signAndSend();
+
+            const { result: sendLib } = await endpointClient.get_send_library({
+                sender: lockUnlockOftAddress,
+                dst_eid: EID,
+            });
+            expect(sendLib.lib).toBe(protocolAddresses.sml);
+            expect(sendLib.is_default).toBe(false);
+            console.log('✅ Lock/Unlock OFT send library set to SML');
         });
-    });
 
-    describe('Wire Contracts', () => {
-        it('Register Library', async () => {
-            const assembledTx = await endpointClient.register_library({
-                new_lib: CONTRACT_ADDRESSES.sml,
+        it('Set Lock/Unlock OFT Receive Library to SML', async () => {
+            const assembledTx = await endpointClient.set_receive_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                receiver: lockUnlockOftAddress,
+                src_eid: EID,
+                new_lib: protocolAddresses.sml,
+                grace_period: 0n,
             });
             await assembledTx.signAndSend();
-            const { result: libs } = await endpointClient.get_registered_libraries({
-                start: 0,
-                max_count: 100,
+
+            const { result: receiveLib } = await endpointClient.get_receive_library({
+                receiver: lockUnlockOftAddress,
+                src_eid: EID,
             });
-            expect(libs.length).toBe(1);
-            expect(libs[0]).toBe(CONTRACT_ADDRESSES.sml);
-            console.log('✅ Library registered');
+            expect(receiveLib.lib).toBe(protocolAddresses.sml);
+            expect(receiveLib.is_default).toBe(false);
+            console.log('✅ Lock/Unlock OFT receive library set to SML');
         });
 
-        it('Set Default Send Library', async () => {
-            const assembledTx = await endpointClient.set_default_send_library({
+        it('Set Mint/Burn OFT Send Library to SML', async () => {
+            const assembledTx = await endpointClient.set_send_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                sender: mintBurnOftAddress,
                 dst_eid: EID,
-                new_lib: CONTRACT_ADDRESSES.sml,
+                new_lib: protocolAddresses.sml,
             });
             await assembledTx.signAndSend();
-            const { result: defaultSendLib } = await endpointClient.default_send_library({
+
+            const { result: sendLib } = await endpointClient.get_send_library({
+                sender: mintBurnOftAddress,
                 dst_eid: EID,
             });
-            expect(defaultSendLib).toBe(CONTRACT_ADDRESSES.sml);
-            console.log('✅ Default send library set');
+            expect(sendLib.lib).toBe(protocolAddresses.sml);
+            expect(sendLib.is_default).toBe(false);
+            console.log('✅ Mint/Burn OFT send library set to SML');
         });
 
-        it('Set Default Receive Library', async () => {
-            const assembledTx = await endpointClient.set_default_receive_library({
+        it('Set Mint/Burn OFT Receive Library to SML', async () => {
+            const assembledTx = await endpointClient.set_receive_library({
+                caller: DEFAULT_DEPLOYER.publicKey(),
+                receiver: mintBurnOftAddress,
                 src_eid: EID,
-                new_lib: CONTRACT_ADDRESSES.sml,
+                new_lib: protocolAddresses.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,
+            const { result: receiveLib } = await endpointClient.get_receive_library({
+                receiver: mintBurnOftAddress,
+                src_eid: EID,
             });
-            await setZroTx.signAndSend();
-
-            const { result: newZroToken } = await endpointClient.zro();
-            expect(newZroToken).toBe(ZRO_TOKEN_ADDRESS);
-            console.log('✅ ZRO token set:', ZRO_TOKEN_ADDRESS);
+            expect(receiveLib.lib).toBe(protocolAddresses.sml);
+            expect(receiveLib.is_default).toBe(false);
+            console.log('✅ Mint/Burn OFT receive library set to SML');
         });
 
         it('Set Lock/Unlock OFT Peer (to Mint/Burn OFT)', async () => {
-            const mintBurnPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.mintBurnOft);
+            const mintBurnPeerBytes = StrKey.decodeContract(mintBurnOftAddress);
 
             const assembledTx = await lockUnlockOftClient.set_peer({
                 eid: EID,
@@ -404,7 +303,7 @@ describe('OFT E2E Testing with SAC', async () => {
         });
 
         it('Set Mint/Burn OFT Peer (to Lock/Unlock OFT)', async () => {
-            const lockUnlockPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.lockUnlockOft);
+            const lockUnlockPeerBytes = StrKey.decodeContract(lockUnlockOftAddress);
 
             const assembledTx = await mintBurnOftClient.set_peer({
                 eid: EID,
@@ -421,26 +320,19 @@ describe('OFT E2E Testing with SAC', async () => {
 
         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,
+                        contract: oftTokenAddress,
                         function: 'set_admin',
-                        args: [
-                            // new_admin: Address
-                            Address.fromString(CONTRACT_ADDRESSES.mintBurnOft).toScVal(),
-                        ],
+                        args: [Address.fromString(mintBurnOftAddress).toScVal()],
                     }),
                 )
                 .setTimeout(30)
@@ -473,39 +365,35 @@ describe('OFT E2E Testing with SAC', async () => {
         let message: Buffer;
 
         it('Verify initial balances', async () => {
-            // Check sender balance (DEFAULT_DEPLOYER has 1000 OFT tokens)
-            const senderBalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
+            const senderBalance = await getTokenBalance(
                 DEFAULT_DEPLOYER.publicKey(),
+                oftTokenAddress,
             );
             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,
+            const recipientABalance = await getTokenBalance(
                 RECIPIENT_A.publicKey(),
+                oftTokenAddress,
             );
             console.log(`  - RECIPIENT_A: ${recipientABalance} (expected: 0)`);
 
-            expect(senderBalance).toBe(10000000000n); // 1000 tokens with 7 decimals
+            expect(senderBalance).toBe(10000000000n);
             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
+                min_amount_ld: SEND_AMOUNT,
                 extra_options: Buffer.from([]),
                 compose_msg: Buffer.from([]),
                 oft_cmd: Buffer.from([]),
             };
 
-            // Quote OFT
             const { result: quoteResult } = await lockUnlockOftClient.quote_oft({
                 send_param: sendParam,
             });
@@ -519,7 +407,6 @@ describe('OFT E2E Testing with SAC', async () => {
         });
 
         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,
@@ -531,7 +418,6 @@ describe('OFT E2E Testing with SAC', async () => {
                 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,
@@ -539,7 +425,6 @@ describe('OFT E2E Testing with SAC', async () => {
             });
             console.log('📊 Messaging Fee:', fee);
 
-            // Send tokens
             const assembledTx = await lockUnlockOftClient.send({
                 sender: DEFAULT_DEPLOYER.publicKey(),
                 send_param: sendParam,
@@ -547,22 +432,22 @@ describe('OFT E2E Testing with SAC', async () => {
                 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');
+            if (txResponse) {
+                assertTransactionSucceeded(txResponse, 'OFT Send');
+            }
             console.log('✅ Tokens sent, ledger:', sendLedger);
         });
 
         it('Scan PacketSent events', async () => {
             const packetSentEvents = await scanPacketSentEvents(
-                CONTRACT_ADDRESSES.endpointV2,
+                protocolAddresses.endpointV2,
                 sendLedger,
             );
             expect(packetSentEvents.length).toBeGreaterThan(0);
@@ -587,64 +472,56 @@ describe('OFT E2E Testing with SAC', async () => {
         });
 
         it('Receive tokens (mint on Mint/Burn OFT)', async () => {
-            const lockUnlockPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.lockUnlockOft);
+            const lockUnlockPeerBytes = StrKey.decodeContract(lockUnlockOftAddress);
             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,
+            const assembledTx = await executorHelperClient.execute(
+                {
+                    executor: protocolAddresses.executor,
+                    params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid,
+                        message,
+                        origin,
+                        receiver: mintBurnOftAddress,
+                        value: 0n,
+                    },
+                    value_payer: EXECUTOR_ADMIN.publicKey(),
                 },
-            });
+                {
+                    simulate: false,
+                },
+            );
 
-            // Sign the Executor's auth entries
-            await signExecutorAuthEntries(
-                CONTRACT_ADDRESSES.executor,
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            // Sign and send
-            const sentTx = await assembledTx.signAndSend();
-            assertTransactionsSucceeded(sentTx, 'LzReceive (Mint)');
+            assertTransactionSucceeded(txResult, '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,
+            const senderBalance = await getTokenBalance(
                 DEFAULT_DEPLOYER.publicKey(),
+                oftTokenAddress,
             );
-            const lockUnlockOftBalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
-                CONTRACT_ADDRESSES.lockUnlockOft,
+            const lockUnlockOftBalance = await getTokenBalance(
+                lockUnlockOftAddress,
+                oftTokenAddress,
             );
-            const recipientABalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
+            const recipientABalance = await getTokenBalance(
                 RECIPIENT_A.publicKey(),
+                oftTokenAddress,
             );
 
             console.log('📊 Balances after forward send:');
@@ -654,9 +531,9 @@ describe('OFT E2E Testing with SAC', async () => {
             );
             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
+            expect(senderBalance).toBe(9000000000n);
+            expect(lockUnlockOftBalance).toBe(1000000000n);
+            expect(recipientABalance).toBe(1000000000n);
         });
     });
 
@@ -665,10 +542,9 @@ describe('OFT E2E Testing with SAC', async () => {
         let packetSentEvent: PacketSentEvent;
         let guid: Buffer;
         let message: Buffer;
-        const REVERSE_SEND_AMOUNT = 50_0000000n; // 50 tokens
+        const REVERSE_SEND_AMOUNT = 50_0000000n;
 
         it('Quote OFT send (reverse)', async () => {
-            // Send to RECIPIENT_B
             const receiverBytes = StrKey.decodeEd25519PublicKey(RECIPIENT_B.publicKey());
             const sendParam: SendParam = {
                 dst_eid: EID,
@@ -693,7 +569,6 @@ describe('OFT E2E Testing with SAC', async () => {
         });
 
         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,
@@ -705,7 +580,6 @@ describe('OFT E2E Testing with SAC', async () => {
                 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,
@@ -713,7 +587,6 @@ describe('OFT E2E Testing with SAC', async () => {
             });
             console.log('📊 Reverse Messaging Fee:', fee);
 
-            // Send tokens
             const assembledTx = await mintBurnOftClient.send({
                 sender: DEFAULT_DEPLOYER.publicKey(),
                 send_param: sendParam,
@@ -721,22 +594,22 @@ describe('OFT E2E Testing with SAC', async () => {
                 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');
+            if (txResponse) {
+                assertTransactionSucceeded(txResponse, 'OFT Reverse Send');
+            }
             console.log('✅ Tokens sent (reverse), ledger:', sendLedger);
         });
 
         it('Scan PacketSent events (reverse)', async () => {
             const packetSentEvents = await scanPacketSentEvents(
-                CONTRACT_ADDRESSES.endpointV2,
+                protocolAddresses.endpointV2,
                 sendLedger,
             );
             expect(packetSentEvents.length).toBeGreaterThan(0);
@@ -763,69 +636,60 @@ describe('OFT E2E Testing with SAC', async () => {
         });
 
         it('Receive tokens (unlock on Lock/Unlock OFT)', async () => {
-            const mintBurnPeerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.mintBurnOft);
+            const mintBurnPeerBytes = StrKey.decodeContract(mintBurnOftAddress);
             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,
+            const assembledTx = await executorHelperClient.execute(
+                {
+                    executor: protocolAddresses.executor,
+                    params: {
+                        extra_data: Buffer.from([]),
+                        gas_limit: 0n,
+                        guid,
+                        message,
+                        origin,
+                        receiver: lockUnlockOftAddress,
+                        value: 0n,
+                    },
+                    value_payer: EXECUTOR_ADMIN.publicKey(),
                 },
-            });
+                {
+                    simulate: false,
+                },
+            );
 
-            // Sign the Executor's auth entries
-            await signExecutorAuthEntries(
-                CONTRACT_ADDRESSES.executor,
+            const txResult = await signAndSendWithExecutorAuth(
+                protocolAddresses.executor,
                 EXECUTOR_ADMIN,
                 assembledTx,
                 NETWORK_PASSPHRASE,
             );
 
-            // Sign and send
-            const sentTx = await assembledTx.signAndSend();
-            assertTransactionsSucceeded(sentTx, 'LzReceive (Unlock)');
+            assertTransactionSucceeded(txResult, '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,
+            const senderBalance = await getTokenBalance(
                 DEFAULT_DEPLOYER.publicKey(),
+                oftTokenAddress,
             );
-            const lockUnlockOftBalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
-                CONTRACT_ADDRESSES.lockUnlockOft,
+            const lockUnlockOftBalance = await getTokenBalance(
+                lockUnlockOftAddress,
+                oftTokenAddress,
             );
-            const recipientABalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
+            const recipientABalance = await getTokenBalance(
                 RECIPIENT_A.publicKey(),
+                oftTokenAddress,
             );
-            const recipientBBalance = await getSacBalance(
-                CONTRACT_ADDRESSES.oftToken,
+            const recipientBBalance = await getTokenBalance(
                 RECIPIENT_B.publicKey(),
+                oftTokenAddress,
             );
 
             console.log('\n📊 Final Balance Summary:');
@@ -836,10 +700,10 @@ describe('OFT E2E Testing with SAC', async () => {
             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
+            expect(senderBalance).toBe(8500000000n);
+            expect(lockUnlockOftBalance).toBe(500000000n);
+            expect(recipientABalance).toBe(1000000000n);
+            expect(recipientBBalance).toBe(500000000n);
 
             console.log('✅ OFT E2E test completed successfully!');
         });