@layerzerolabs/lz-v2-stellar-sdk 0.2.8

package/src/index.ts

@@ -0,0 +1,5 @@
+export * as bml from './generated/bml.js';
+export * as counter from './generated/counter.js';
+export * as endpoint from './generated/endpoint.js';
+export * as sml from './generated/sml.js';
+export * as uln302 from './generated/uln302.js';

package/test/index.test.ts

@@ -0,0 +1,271 @@
+import { 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 CounterClient } from '../src/generated/counter';
+import { Client as EndpointClient } from '../src/generated/endpoint';
+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 { deployContract } from './suites/deploy';
+import { startStellarLocalnet, stopStellarLocalnet } from './suites/localnet';
+import { PacketSentEvent, scanPacketSentEvents } from './suites/scan';
+
+$.verbose = true;
+$.stdio = ['inherit', 'pipe', process.stderr];
+
+const CONTRACT_ADDRESSES = {
+    endpointV2: '',
+    sml: '',
+    counter: '',
+}
+
+let endpointClient: EndpointClient;
+let smlClient: SMLClient;
+let counterClient: CounterClient;
+
+// 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 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');
+
+    beforeAll(async () => {
+        await startStellarLocalnet();
+    }, 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 Counter', async () => {
+            counterClient = await deployContract<CounterClient>(
+                CounterClient,
+                COUNTER_WASM_PATH,
+                {
+                    owner: DEFAULT_DEPLOYER.publicKey(),
+                    endpoint: CONTRACT_ADDRESSES.endpointV2,
+                    delegate: DEFAULT_DEPLOYER.publicKey(),
+                },
+                DEFAULT_DEPLOYER,
+            );
+
+            CONTRACT_ADDRESSES.counter = counterClient.options.contractId;
+            console.log('✅ Counter deployed:', CONTRACT_ADDRESSES.counter);
+        });
+
+        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('  Counter:', CONTRACT_ADDRESSES.counter);
+        });
+    });
+
+    describe('Wire Contracts', async () => {
+        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: 0n,
+                max_count: 100n,
+            });
+            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 (Required even for 0 fee)', 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 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({
+                eid: EID,
+            });
+            expect(peer?.toString()).toBe(Buffer.from(peerBytes).toString());
+            console.log('✅ Counter peer set for EID', EID);
+        });
+    })
+
+    describe('Counter', async () => {
+        let incrementLedger = 0;
+        let packetSentEvent: PacketSentEvent;
+        let guid: Buffer;
+        let message: Buffer;
+        it('Counter Increment', async () => {
+            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,
+                msg_type: MSG_TYPE_VANILLA,
+                options: Buffer.from([]),
+                fee: fee,
+            });
+            const sentTx = await assembledTx.signAndSend();
+            
+            // Extract ledger number from transaction response
+            const txResponse = sentTx.getTransactionResponse;
+            if (txResponse && 'ledger' in txResponse) {
+                incrementLedger = txResponse.ledger;
+            }
+            
+            const {result: outboundCount} = await counterClient.outbound_count({
+                eid: EID,
+            });
+            expect(outboundCount).toBe(1n);
+            console.log('✅ Counter incremented, outbound count:', outboundCount);
+        });
+
+        it('Scan PacketSent Events', async () => {
+            const packetSentEvents = await scanPacketSentEvents(
+                CONTRACT_ADDRESSES.endpointV2,
+                incrementLedger,
+            );
+            expect(packetSentEvents.length).toBeGreaterThan(0);
+            packetSentEvent = packetSentEvents[0];
+            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 assembledTx = await smlClient.validate_packet({
+                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,
+                },
+                guid,
+                message,
+                extra_data: Buffer.from([]),
+                value: 0n,
+            });
+
+            const sentTx = await assembledTx.signAndSend();
+
+            // Extract and print the transaction fee from the result
+            const txResponse = sentTx.getTransactionResponse;
+            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)`);
+                } catch (_e) {
+                    // Ignore if we can't extract the fee
+                }
+            }
+            const {result: inboundCount} = await counterClient.inbound_count({
+                eid: EID,
+            });
+            expect(inboundCount).toBe(1n);
+            console.log('✅ Counter message received, inbox count:', inboundCount);
+        });
+    })
+});

package/test/suites/constants.ts

@@ -0,0 +1,13 @@
+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 EID = 30111;
+export const NATIVE_TOKEN_ADDRESS = Asset.native().contractId(NETWORK_PASSPHRASE);
+export const ZRO_ASSET = new Asset('ZRO', DEFAULT_DEPLOYER.publicKey());
+export const ZRO_TOKEN_ADDRESS = ZRO_ASSET.contractId(NETWORK_PASSPHRASE);
+export const MSG_TYPE_VANILLA = 1;

package/test/suites/deploy.ts

@@ -0,0 +1,277 @@
+import {
+    Asset,
+    BASE_FEE,
+    hash,
+    Keypair,
+    Operation,
+    rpc,
+    TransactionBuilder,
+    xdr
+} from '@stellar/stellar-sdk';
+import { readFileSync } from 'fs';
+
+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> {
+    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);
+        // Create LedgerKeyContractCode with hash
+        const ledgerKeyContractCode = new xdr.LedgerKeyContractCode({
+            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, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'getLedgerEntries',
+                params: {
+                    keys: [ledgerKeyXdr]
+                }
+            })
+        });
+        
+        const result = await response.json();
+        if (result.error) {
+            console.warn(`⚠️  Could not retrieve WASM TTL: ${result.error.message}`);
+        } else if (result.result?.entries?.[0]?.liveUntilLedgerSeq) {
+            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)`);
+        }
+    } 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)}`);
+    }
+}
+
+export async function uploadWasm(
+    wasmBuffer: Buffer,
+    keypair: Keypair,
+    server: rpc.Server,
+): Promise<string> {
+    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, {
+        fee: BASE_FEE,
+        networkPassphrase: NETWORK_PASSPHRASE,
+    })
+        .addOperation(Operation.uploadContractWasm({ wasm: wasmBuffer }))
+        .setTimeout(30)
+        .build();
+
+    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)`);
+    
+    preparedTx.sign(keypair);
+
+    const sendResult = await server.sendTransaction(preparedTx);
+
+    if (sendResult.status !== 'PENDING') {
+        throw new Error(`Transaction failed: ${JSON.stringify(sendResult)}`);
+    }
+
+    // Wait for transaction to be confirmed
+    const txResult = await server.pollTransaction(sendResult.hash);
+
+    if (txResult.status !== 'SUCCESS') {
+        throw new Error(`Transaction not successful: ${JSON.stringify(txResult)}`);
+    }
+
+    // Compute the WASM hash (SHA-256 of the WASM bytes)
+    const wasmHash = hash(wasmBuffer).toString('hex');
+
+    // Query and display the WASM code TTL
+    await queryWasmTtl(wasmHash, server);
+
+    return wasmHash;
+}
+
+/**
+ * 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
+ * @param deployer - The keypair that will deploy the contract
+ * @param options - Optional deployment options (salt, fee, timeout, etc.)
+ * @returns The deployed contract's Client instance with the contractId
+ */
+export async function deployContract<T extends { options: { contractId: string } }>(
+    ClientClass: {
+        deploy: (
+            args: any,
+            options: any,
+        ) => Promise<{ signAndSend: () => Promise<{ result: T }> }>;
+    },
+    wasmFilePath: string,
+    constructorArgs: any,
+    deployer: Keypair,
+    options: {
+        salt?: Buffer;
+        rpcUrl?: string;
+        networkPassphrase?: string;
+        allowHttp?: boolean;
+    } = {},
+): Promise<T> {
+    const {
+        rpcUrl = RPC_URL,
+        networkPassphrase = NETWORK_PASSPHRASE,
+        allowHttp = true,
+        salt,
+    } = options;
+
+    const server = new rpc.Server(rpcUrl, {
+        allowHttp: allowHttp,
+    });
+
+    // Step 1: Read WASM file
+    console.log('📖 Reading WASM file from:', wasmFilePath);
+    const wasmBuffer = readFileSync(wasmFilePath);
+
+    // Step 2: Upload WASM and get hash
+    console.log('📤 Uploading WASM...');
+    const wasmHash = await uploadWasm(wasmBuffer, deployer, server);
+    console.log('✅ WASM uploaded, hash:', wasmHash);
+
+    // Step 3: Deploy the contract
+    console.log('🚀 Deploying contract...');
+    const deployTx = await ClientClass.deploy(constructorArgs, {
+        wasmHash: wasmHash,
+        publicKey: deployer.publicKey(),
+        signTransaction: async (tx: string) => {
+            const transaction = TransactionBuilder.fromXDR(tx, networkPassphrase);
+            transaction.sign(deployer);
+            return {
+                signedTxXdr: transaction.toXDR(),
+                signerAddress: deployer.publicKey(),
+            };
+        },
+        rpcUrl: rpcUrl,
+        networkPassphrase: networkPassphrase,
+        allowHttp: allowHttp,
+        salt: salt,
+    });
+
+    // Step 4: Sign and send
+    const sentTx = await deployTx.signAndSend();
+
+    // Step 5: Extract contract ID from result
+    const contractClient = sentTx.result;
+    const contractId = contractClient.options.contractId;
+    console.log('✅ Contract deployed at:', contractId);
+
+    return contractClient;
+}
+
+export async function deployNativeSac(): Promise<void> {
+    await deployAssetSac(Asset.native());
+    console.log('✅ Native SAC deployed');
+}
+
+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());
+    const transaction = new TransactionBuilder(account, {
+        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() }))
+        .setTimeout(10)
+        .build();
+    transaction.sign(DEFAULT_DEPLOYER, ZRO_DISTRIBUTOR);
+
+    const sendResult = await server.sendTransaction(transaction);
+    if (sendResult.status !== 'PENDING') {
+        throw new Error(`Failed to issue ZRO token: ${JSON.stringify(sendResult)}`);
+    }
+    const txResult = await server.pollTransaction(sendResult.hash);
+    if (txResult.status !== 'SUCCESS') {
+        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');
+}
+
+/**
+ * Deploy SAC for a custom asset using TypeScript
+ */
+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,
+        networkPassphrase: NETWORK_PASSPHRASE,
+    })
+        .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);
+    if (sendResult.status !== 'PENDING') {
+        throw new Error(`Failed to deploy SAC: ${JSON.stringify(sendResult)}`);
+    }
+    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/test/suites/localnet.ts

@@ -0,0 +1,42 @@
+import axios from 'axios';
+import { $,sleep } from 'zx';
+
+import { DEFAULT_DEPLOYER, FRIENDBOT_URL, ZRO_DISTRIBUTOR } from './constants';
+import { deployNativeSac, deployZroToken } from './deploy';
+
+export async function startStellarLocalnet(): Promise<void> {
+    console.log('🚀 Starting Stellar localnet...');
+
+    //TODO: pnpm localnet up --only stellar
+    await $`stellar container start local`;
+
+    // Wait for Stellar to start
+    for (let i = 0; i < 60; i++) {
+        try {
+            // Ensure faucet service is started and fund the default deployer account
+            await fundAccount(DEFAULT_DEPLOYER.publicKey());
+            await fundAccount(ZRO_DISTRIBUTOR.publicKey());
+            console.log(`✅ Account ${DEFAULT_DEPLOYER.publicKey()} funded`);
+            console.log('✅ Stellar localnet started');
+            break;
+        } catch (_e) {
+            await sleep(1000);
+            console.log('⏳ Waiting for Stellar localnet to start...');
+        }
+    }
+    await deployNativeSac();
+    await deployZroToken();
+}
+
+export async function fundAccount(publicKey: string): Promise<void> {
+    await axios.get(FRIENDBOT_URL, {
+        params: {
+            addr: publicKey,
+        },
+    });
+}
+
+export async function stopStellarLocalnet(): Promise<void> {
+    await $`stellar container stop`;
+    console.log('✅ Stellar localnet stopped');
+}