@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/sdk/test/index.test.ts

@@ -1,4 +1,4 @@
-import { StrKey, TransactionBuilder } from '@stellar/stellar-sdk';
+import { Keypair, StrKey, TransactionBuilder } from '@stellar/stellar-sdk';
 import path from 'path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { $ } from 'zx';
@@ -8,11 +8,21 @@ import { PacketSerializer, PacketV1Codec } from '@layerzerolabs/lz-v2-utilities'
 
 import { Client as CounterClient } from '../src/generated/counter';
 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 SMLClient } from '../src/generated/sml';
-import { DEFAULT_DEPLOYER, EID, MSG_TYPE_VANILLA, NATIVE_TOKEN_ADDRESS, NETWORK_PASSPHRASE, ZRO_TOKEN_ADDRESS } from './suites/constants';
+import {
+    DEFAULT_DEPLOYER,
+    EID,
+    MSG_TYPE_VANILLA,
+    NATIVE_TOKEN_ADDRESS,
+    NETWORK_PASSPHRASE,
+    ZRO_TOKEN_ADDRESS,
+} from './suites/constants';
 import { deployContract } from './suites/deploy';
-import { startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
+import { fundAccount, startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
 import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
+import { assertTransactionsSucceeded, signExecutorAuthEntries } from './utils';
 
 $.verbose = true;
 $.stdio = ['inherit', 'pipe', process.stderr];
@@ -21,24 +31,41 @@ const CONTRACT_ADDRESSES = {
     endpointV2: '',
     sml: '',
     counter: '',
-}
+    executor: '',
+    executorHelper: '',
+};
 
 let endpointClient: EndpointClient;
 let smlClient: SMLClient;
 let counterClient: CounterClient;
+let executorClient: ExecutorClient;
+let executorHelperClient: ExecutorHelperClient;
+
+const EXECUTOR_ADMIN = Keypair.random();
 
 // NOTE: run `stellar contract build --features sandbox` before running the test
 
 describe('Protocol testing', async () => {
     const repoRoot = await getFullyQualifiedRepoRootPath();
-    const wasmDir = path.join(repoRoot, 'contracts', 'protocol', 'stellar', 'target', 'wasm32v1-none', 'release');
-    
+    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 COUNTER_WASM_PATH = path.join(wasmDir, 'counter.wasm');
+    const EXECUTOR_WASM_PATH = path.join(wasmDir, 'executor.wasm');
+    const EXECUTOR_HELPER_WASM_PATH = path.join(wasmDir, 'executor_helper.wasm');
 
     beforeAll(async () => {
         await startStellarLocalnet();
+        await fundAccount(EXECUTOR_ADMIN.publicKey());
     }, 120000); // 2 minute timeout for setup
 
     afterAll(async () => {
@@ -78,6 +105,46 @@ describe('Protocol testing', async () => {
             console.log('✅ SimpleMessageLib deployed:', CONTRACT_ADDRESSES.sml);
         });
 
+        it('Deploy Executor Helper', async () => {
+            // Deploy ExecutorHelper first (it's stateless) so we can pass it to Executor
+            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 () => {
+            // Whitelist ExecutorHelper entry points
+            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 Counter', async () => {
             counterClient = await deployContract<CounterClient>(
                 CounterClient,
@@ -99,6 +166,8 @@ describe('Protocol testing', async () => {
             console.log('  Endpoint:', CONTRACT_ADDRESSES.endpointV2);
             console.log('  SimpleMessageLib:', CONTRACT_ADDRESSES.sml);
             console.log('  Counter:', CONTRACT_ADDRESSES.counter);
+            console.log('  Executor:', CONTRACT_ADDRESSES.executor);
+            console.log('  Executor Helper:', CONTRACT_ADDRESSES.executorHelper);
         });
     });
 
@@ -108,9 +177,9 @@ describe('Protocol testing', async () => {
                 new_lib: CONTRACT_ADDRESSES.sml,
             });
             await assembledTx.signAndSend();
-            const {result: libs} = await endpointClient.get_registered_libraries({
-                start: 0n,
-                max_count: 100n,
+            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);
@@ -123,7 +192,7 @@ describe('Protocol testing', async () => {
                 new_lib: CONTRACT_ADDRESSES.sml,
             });
             await assembledTx.signAndSend();
-            const {result: defaultSendLib} = await endpointClient.default_send_library({
+            const { result: defaultSendLib } = await endpointClient.default_send_library({
                 dst_eid: EID,
             });
             expect(defaultSendLib).toBe(CONTRACT_ADDRESSES.sml);
@@ -137,7 +206,7 @@ describe('Protocol testing', async () => {
                 grace_period: 0n,
             });
             await assembledTx.signAndSend();
-            const {result: defaultReceiveLib} = await endpointClient.default_receive_library({
+            const { result: defaultReceiveLib } = await endpointClient.default_receive_library({
                 src_eid: EID,
             });
             expect(defaultReceiveLib).toBe(CONTRACT_ADDRESSES.sml);
@@ -149,28 +218,28 @@ describe('Protocol testing', async () => {
                 zro: ZRO_TOKEN_ADDRESS,
             });
             await setZroTx.signAndSend();
-            
-            const {result: newZroToken} = await endpointClient.zro();
+
+            const { result: newZroToken } = await endpointClient.zro();
             expect(newZroToken).toBe(ZRO_TOKEN_ADDRESS);
             console.log('✅ ZRO token set:', ZRO_TOKEN_ADDRESS);
         });
 
         it('Set Counter Peer', async () => {
             const peerBytes = StrKey.decodeContract(CONTRACT_ADDRESSES.counter);
-            
+
             const assembledTx = await counterClient.set_peer({
                 eid: EID,
                 peer: Buffer.from(peerBytes),
             });
             await assembledTx.signAndSend();
-            
-            const {result: peer} = await counterClient.peers({
+
+            const { result: peer } = await counterClient.peer({
                 eid: EID,
             });
             expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
             console.log('✅ Counter peer set for EID', EID);
         });
-    })
+    });
 
     describe('Counter', async () => {
         let incrementLedger = 0;
@@ -178,14 +247,14 @@ describe('Protocol testing', async () => {
         let guid: Buffer;
         let message: Buffer;
         it('Counter Increment', async () => {
-            const {result: fee} = await counterClient.quote({
+            const { result: fee } = await counterClient.quote({
                 dst_eid: EID,
                 msg_type: MSG_TYPE_VANILLA,
                 options: Buffer.from([]),
                 pay_in_zro: true,
             });
             console.log('✅ Fee:', fee);
-            
+
             const assembledTx = await counterClient.increment({
                 sender: DEFAULT_DEPLOYER.publicKey(),
                 dst_eid: EID,
@@ -194,14 +263,14 @@ describe('Protocol testing', async () => {
                 fee: fee,
             });
             const sentTx = await assembledTx.signAndSend();
-            
+
             // Extract ledger number from transaction response
             const txResponse = sentTx.getTransactionResponse;
             if (txResponse && 'ledger' in txResponse) {
                 incrementLedger = txResponse.ledger;
             }
-            
-            const {result: outboundCount} = await counterClient.outbound_count({
+
+            const { result: outboundCount } = await counterClient.outbound_count({
                 eid: EID,
             });
             expect(outboundCount).toBe(1n);
@@ -215,57 +284,93 @@ describe('Protocol testing', async () => {
             );
             expect(packetSentEvents.length).toBeGreaterThan(0);
             packetSentEvent = packetSentEvents[0];
-            console.log(`✅ PacketSent events scanned successfully. Found ${packetSentEvents.length} events`);
+            console.log(
+                `✅ PacketSent events scanned successfully. Found ${packetSentEvents.length} events`,
+            );
         });
 
         it('Verify Counter Message', 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 codec = PacketV1Codec.from(packet);
+            const packetHeader = codec.header();
+            const payloadHash = codec.payloadHash();
             const assembledTx = await smlClient.validate_packet({
-                caller: DEFAULT_DEPLOYER.publicKey(),
+                // caller: DEFAULT_DEPLOYER.publicKey(),
                 header_bytes: Buffer.from(packetHeader.replace('0x', ''), 'hex'),
                 payload_hash: Buffer.from(payloadHash.replace('0x', ''), 'hex'),
             });
             await assembledTx.signAndSend();
         });
 
-        it('Receive Counter Message', async () => {
-            const assembledTx = await counterClient.lz_receive({
-                executor: DEFAULT_DEPLOYER.publicKey(),
-                origin: {
-                    nonce: 1n,
-                    sender: Buffer.from(StrKey.decodeContract(CONTRACT_ADDRESSES.counter)),
-                    src_eid: EID,
+        it('Receive Counter Message (with native_drop)', async () => {
+            // Use native_drop_and_execute to test both native_drop and lz_receive
+            const origin = {
+                nonce: 1n,
+                sender: Buffer.from(StrKey.decodeContract(CONTRACT_ADDRESSES.counter)),
+                src_eid: EID,
+            };
+
+            const assembledTx = await executorHelperClient.native_drop_and_execute({
+                executor: CONTRACT_ADDRESSES.executor,
+                admin: EXECUTOR_ADMIN.publicKey(),
+                origin,
+                dst_eid: EID,
+                oapp: CONTRACT_ADDRESSES.counter,
+                // Native drop: send 100 stroops to counter contract
+                native_drop_params: [
+                    {
+                        receiver: CONTRACT_ADDRESSES.counter,
+                        amount: 100n,
+                    },
+                ],
+                execute_params: {
+                    extra_data: Buffer.from([]),
+                    gas_limit: 0n,
+                    guid,
+                    message,
+                    origin,
+                    receiver: CONTRACT_ADDRESSES.counter,
+                    value: 11n,
                 },
-                guid,
-                message,
-                extra_data: Buffer.from([]),
-                value: 0n,
             });
 
+            // Step 1: Sign the Executor's auth entries with the admin address as signature
+            await signExecutorAuthEntries(
+                CONTRACT_ADDRESSES.executor,
+                EXECUTOR_ADMIN,
+                assembledTx,
+                NETWORK_PASSPHRASE,
+            );
+
+            // Step 2: Sign and send the transaction by Executor Admin
             const sentTx = await assembledTx.signAndSend();
 
-            // Extract and print the transaction fee from the result
+            // Assert that the transaction success
+            assertTransactionsSucceeded(sentTx, 'LzReceive');
+
             const txResponse = sentTx.getTransactionResponse;
+            // Extract and print the transaction fee from the result
             if (txResponse && 'envelopeXdr' in txResponse && txResponse.envelopeXdr) {
                 try {
                     const txXdr = txResponse.envelopeXdr.toXDR('base64');
                     const parsedTx = TransactionBuilder.fromXDR(txXdr, NETWORK_PASSPHRASE);
                     const fee = parsedTx.fee;
-                    console.log(`💰 lz_receive transaction fee: ${fee} stroops (${(Number(fee) / 10000000).toFixed(7)} XLM)`);
+                    console.log(
+                        `💰 lz_receive transaction fee: ${fee} stroops (${(Number(fee) / 10000000).toFixed(7)} XLM)`,
+                    );
                 } catch (_e) {
                     // Ignore if we can't extract the fee
                 }
             }
-            const {result: inboundCount} = await counterClient.inbound_count({
+
+            // Verify the message was received
+            const { result: inboundCount } = await counterClient.inbound_count({
                 eid: EID,
             });
             expect(inboundCount).toBe(1n);
             console.log('✅ Counter message received, inbox count:', inboundCount);
         });
-    })
+    });
 });

package/sdk/test/suites/constants.ts

@@ -1,11 +1,15 @@
-import { Asset, Keypair, Networks} from '@stellar/stellar-sdk';
+import { Asset, Keypair, Networks } from '@stellar/stellar-sdk';
 
 const CORE_URL = 'http://localhost:8000';
 export const FRIENDBOT_URL = `${CORE_URL}/friendbot`;
 export const RPC_URL = `${CORE_URL}/rpc`;
 export const NETWORK_PASSPHRASE = Networks.STANDALONE;
-export const DEFAULT_DEPLOYER = Keypair.fromSecret('SDLCA3JUES3G6R4FTI6XXDIWW7QCNMZNWPYQQIKQ26TEIZUFOLIVIUDK');
-export const ZRO_DISTRIBUTOR = Keypair.fromSecret('SB6QAFXFRR2MXYHW4RRZ23JDGKHDCYCT5YTQEGG3WNT5VKZADJQFVNWG');
+export const DEFAULT_DEPLOYER = Keypair.fromSecret(
+    'SDLCA3JUES3G6R4FTI6XXDIWW7QCNMZNWPYQQIKQ26TEIZUFOLIVIUDK',
+);
+export const ZRO_DISTRIBUTOR = Keypair.fromSecret(
+    'SB6QAFXFRR2MXYHW4RRZ23JDGKHDCYCT5YTQEGG3WNT5VKZADJQFVNWG',
+);
 export const EID = 30111;
 export const NATIVE_TOKEN_ADDRESS = Asset.native().contractId(NETWORK_PASSPHRASE);
 export const ZRO_ASSET = new Asset('ZRO', DEFAULT_DEPLOYER.publicKey());

package/sdk/test/suites/deploy.ts

@@ -6,39 +6,42 @@ import {
     Operation,
     rpc,
     TransactionBuilder,
-    xdr
+    xdr,
 } from '@stellar/stellar-sdk';
 import { readFileSync } from 'fs';
 
-import { DEFAULT_DEPLOYER, NETWORK_PASSPHRASE, RPC_URL, ZRO_ASSET, ZRO_DISTRIBUTOR } from './constants';
+import {
+    DEFAULT_DEPLOYER,
+    NETWORK_PASSPHRASE,
+    RPC_URL,
+    ZRO_ASSET,
+    ZRO_DISTRIBUTOR,
+} from './constants';
 
 /**
  * Query and display the TTL (Time To Live) of uploaded WASM code
- * 
+ *
  * @param wasmHash - The hex-encoded SHA-256 hash of the WASM code
  * @param server - The Stellar RPC server instance
  * @param rpcUrl - Optional RPC URL (defaults to RPC_URL constant)
  */
-async function queryWasmTtl(
-    wasmHash: string,
-    server: rpc.Server,
-    rpcUrl?: string
-): Promise<void> {
+async function queryWasmTtl(wasmHash: string, server: rpc.Server, rpcUrl?: string): Promise<void> {
     try {
         const latestLedger = await server.getLatestLedger();
         const currentLedger = latestLedger.sequence;
-        
+
         // Create the LedgerKey for contract code using XDR encoding
         const wasmHashBuffer = Buffer.from(wasmHash, 'hex');
         // Ensure hash is exactly 32 bytes
-        const hashBytes = wasmHashBuffer.length === 32 ? wasmHashBuffer : wasmHashBuffer.slice(0, 32);
+        const hashBytes =
+            wasmHashBuffer.length === 32 ? wasmHashBuffer : wasmHashBuffer.slice(0, 32);
         // Create LedgerKeyContractCode with hash
         const ledgerKeyContractCode = new xdr.LedgerKeyContractCode({
-            hash: hashBytes
+            hash: hashBytes,
         });
         const ledgerKey = xdr.LedgerKey.contractCode(ledgerKeyContractCode);
         const ledgerKeyXdr = ledgerKey.toXDR('base64');
-        
+
         // Query contract code entry using direct RPC call
         const rpcEndpoint = rpcUrl || (server as any).serverURL || RPC_URL;
         const response = await fetch(rpcEndpoint, {
@@ -49,11 +52,11 @@ async function queryWasmTtl(
                 id: 1,
                 method: 'getLedgerEntries',
                 params: {
-                    keys: [ledgerKeyXdr]
-                }
-            })
+                    keys: [ledgerKeyXdr],
+                },
+            }),
         });
-        
+
         const result = await response.json();
         if (result.error) {
             console.warn(`⚠️  Could not retrieve WASM TTL: ${result.error.message}`);
@@ -61,12 +64,16 @@ async function queryWasmTtl(
             const liveUntilLedgerSeq = result.result.entries[0].liveUntilLedgerSeq;
             const ttlLedgers = liveUntilLedgerSeq - currentLedger;
             const ttlDays = (ttlLedgers * 5) / (24 * 3600); // ~5 seconds per ledger
-            console.log(`⏰ WASM TTL: live until ledger ${liveUntilLedgerSeq} (${ttlLedgers} ledgers remaining, ~${ttlDays.toFixed(2)} days)`);
+            console.log(
+                `⏰ WASM TTL: live until ledger ${liveUntilLedgerSeq} (${ttlLedgers} ledgers remaining, ~${ttlDays.toFixed(2)} days)`,
+            );
         }
     } catch (error) {
         // If querying TTL fails, it might be because the code isn't indexed yet
         // This is non-fatal, so we just log a warning
-        console.warn(`⚠️  Could not retrieve WASM TTL: ${error instanceof Error ? error.message : String(error)}`);
+        console.warn(
+            `⚠️  Could not retrieve WASM TTL: ${error instanceof Error ? error.message : String(error)}`,
+        );
     }
 }
 
@@ -75,8 +82,10 @@ export async function uploadWasm(
     keypair: Keypair,
     server: rpc.Server,
 ): Promise<string> {
-    console.log(`📦 WASM buffer size: ${wasmBuffer.length} bytes (${(wasmBuffer.length / 1024).toFixed(2)} KB)`);
-    
+    console.log(
+        `📦 WASM buffer size: ${wasmBuffer.length} bytes (${(wasmBuffer.length / 1024).toFixed(2)} KB)`,
+    );
+
     const account = await server.getAccount(keypair.publicKey());
 
     const uploadTx = new TransactionBuilder(account, {
@@ -89,9 +98,11 @@ export async function uploadWasm(
 
     const simulated = await server.simulateTransaction(uploadTx);
     const preparedTx = rpc.assembleTransaction(uploadTx, simulated).build();
-    
-    console.log(`💰 Upload transaction fee: ${preparedTx.fee} stroops (${(Number(preparedTx.fee) / 10000000).toFixed(7)} XLM)`);
-    
+
+    console.log(
+        `💰 Upload transaction fee: ${preparedTx.fee} stroops (${(Number(preparedTx.fee) / 10000000).toFixed(7)} XLM)`,
+    );
+
     preparedTx.sign(keypair);
 
     const sendResult = await server.sendTransaction(preparedTx);
@@ -118,7 +129,7 @@ export async function uploadWasm(
 
 /**
  * Generic contract deployment helper that works with any contract Client
- * 
+ *
  * @param ClientClass - The contract Client class (e.g., EndpointClient, SMLClient)
  * @param wasmFilePath - Path to the compiled WASM file
  * @param constructorArgs - Arguments for the contract's constructor
@@ -129,12 +140,12 @@ export async function uploadWasm(
 export async function deployContract<T extends { options: { contractId: string } }>(
     ClientClass: {
         deploy: (
-            args: any,
-            options: any,
+            argsOrOptions: any,
+            options?: any,
         ) => Promise<{ signAndSend: () => Promise<{ result: T }> }>;
     },
     wasmFilePath: string,
-    constructorArgs: any,
+    constructorArgs: any | undefined,
     deployer: Keypair,
     options: {
         salt?: Buffer;
@@ -165,7 +176,7 @@ export async function deployContract<T extends { options: { contractId: string }
 
     // Step 3: Deploy the contract
     console.log('🚀 Deploying contract...');
-    const deployTx = await ClientClass.deploy(constructorArgs, {
+    const deployOptions = {
         wasmHash: wasmHash,
         publicKey: deployer.publicKey(),
         signTransaction: async (tx: string) => {
@@ -180,7 +191,11 @@ export async function deployContract<T extends { options: { contractId: string }
         networkPassphrase: networkPassphrase,
         allowHttp: allowHttp,
         salt: salt,
-    });
+    };
+    const deployTx =
+        constructorArgs == null
+            ? await ClientClass.deploy(deployOptions)
+            : await ClientClass.deploy(constructorArgs, deployOptions);
 
     // Step 4: Sign and send
     const sentTx = await deployTx.signAndSend();
@@ -202,7 +217,7 @@ export async function deployZroToken(): Promise<void> {
     const server = new rpc.Server(RPC_URL, {
         allowHttp: true,
     });
-    
+
     // First, issue the ZRO token.
     // We can't changeTrust of Issuer account, because the Issuer can't hold the asset.
     const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
@@ -210,8 +225,16 @@ export async function deployZroToken(): Promise<void> {
         fee: BASE_FEE,
         networkPassphrase: NETWORK_PASSPHRASE,
     })
-        .addOperation(Operation.changeTrust({ asset: ZRO_ASSET, source: ZRO_DISTRIBUTOR.publicKey() }))
-        .addOperation(Operation.payment({ asset: ZRO_ASSET, amount: '10000', destination: ZRO_DISTRIBUTOR.publicKey() }))
+        .addOperation(
+            Operation.changeTrust({ asset: ZRO_ASSET, source: ZRO_DISTRIBUTOR.publicKey() }),
+        )
+        .addOperation(
+            Operation.payment({
+                asset: ZRO_ASSET,
+                amount: '10000',
+                destination: ZRO_DISTRIBUTOR.publicKey(),
+            }),
+        )
         .setTimeout(10)
         .build();
     transaction.sign(DEFAULT_DEPLOYER, ZRO_DISTRIBUTOR);
@@ -225,7 +248,7 @@ export async function deployZroToken(): Promise<void> {
         throw new Error(`Failed to issue ZRO token: ${JSON.stringify(txResult)}`);
     }
     console.log('✅ ZRO asset issued');
-    
+
     // Deploy the Stellar Asset Contract (SAC)
     await deployAssetSac(ZRO_ASSET);
     console.log('✅ ZRO SAC deployed');
@@ -236,10 +259,10 @@ export async function deployZroToken(): Promise<void> {
  */
 export async function deployAssetSac(asset: Asset): Promise<string> {
     console.log('Deploying SAC for asset:', asset.toString());
-    
+
     const server = new rpc.Server(RPC_URL, { allowHttp: true });
     const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
-    
+
     // Build transaction with createStellarAssetContract operation
     const deployTx = new TransactionBuilder(account, {
         fee: BASE_FEE,
@@ -248,21 +271,21 @@ export async function deployAssetSac(asset: Asset): Promise<string> {
         .addOperation(
             Operation.createStellarAssetContract({
                 asset: asset,
-            })
+            }),
         )
         .setTimeout(30)
         .build();
-    
+
     // Simulate transaction first (required for contract operations)
     const simulated = await server.simulateTransaction(deployTx);
-    
+
     // Check if simulation was successful
     if (rpc.Api.isSimulationError(simulated)) {
         throw new Error(`Transaction simulation failed: ${JSON.stringify(simulated)}`);
     }
-    
+
     const preparedTx = rpc.assembleTransaction(deployTx, simulated).build();
-    
+
     // Sign and send
     preparedTx.sign(DEFAULT_DEPLOYER);
     const sendResult = await server.sendTransaction(preparedTx);
@@ -272,6 +295,6 @@ export async function deployAssetSac(asset: Asset): Promise<string> {
     const txResult = await server.pollTransaction(sendResult.hash);
     if (txResult.status !== 'SUCCESS') {
         throw new Error(`SAC deployment not successful: ${JSON.stringify(txResult)}`);
-    }    
+    }
     return asset.contractId(NETWORK_PASSPHRASE);
-}
+}

package/sdk/test/suites/localnet.ts

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { $,sleep } from 'zx';
+import { $, sleep } from 'zx';
 
 import { DEFAULT_DEPLOYER, FRIENDBOT_URL, ZRO_DISTRIBUTOR } from './constants';
 import { deployNativeSac, deployZroToken } from './deploy';
@@ -39,4 +39,4 @@ export async function fundAccount(publicKey: string): Promise<void> {
 export async function stopStellarLocalnet(): Promise<void> {
     await $`stellar container stop`;
     console.log('✅ Stellar localnet stopped');
-}
+}