@layerzerolabs/lz-v2-stellar-sdk 0.2.121 → 0.2.123

package/test/suites/localnet.ts

@@ -1,192 +0,0 @@
-import { BASE_FEE, Operation, rpc, TransactionBuilder } from '@stellar/stellar-sdk';
-import { execSync } from 'node:child_process';
-
-import {
-    CHAIN_B_DEPLOYER,
-    DEFAULT_DEPLOYER,
-    EXECUTOR_ADMIN,
-    JUNK_WALLET,
-    NETWORK_PASSPHRASE,
-    RPC_URL,
-    ZRO_DISTRIBUTOR,
-} from './constants.js';
-import { deployNativeSac, deployZroToken } from './deploy.js';
-
-const CONTAINER_NAME = 'stellar-protocol-sdk';
-const ECR_IMAGE = '438003944538.dkr.ecr.us-east-1.amazonaws.com/layerzerolabs/stellar:2026-03-02';
-const CONTAINER_PORT = 8000;
-const HOST_PORT = 8086;
-
-// Timeout configuration (in milliseconds)
-const STARTUP_TIMEOUT_MS = 120_000; // 2 minutes
-const REQUEST_TIMEOUT_MS = 5_000;
-const RETRY_INTERVAL_MS = 2_000;
-
-export async function startStellarLocalnet(): Promise<void> {
-    console.log('🚀 Starting Stellar localnet...');
-
-    // Remove any existing container and start fresh from the ECR snapshot
-    try {
-        execSync(`docker rm -f ${CONTAINER_NAME}`, { stdio: 'ignore' });
-    } catch {
-        // Container didn't exist — ignore
-    }
-
-    execSync(
-        `docker run -d --name ${CONTAINER_NAME} -p ${HOST_PORT}:${CONTAINER_PORT} ${ECR_IMAGE}`,
-        { stdio: 'inherit' },
-    );
-
-    console.log('⏳ Waiting for Stellar RPC to be healthy...');
-    await waitForRpcHealth();
-    console.log('✅ Stellar RPC is healthy');
-
-    await fundTestAccounts();
-    await deployNativeSac();
-    await deployZroToken();
-}
-
-// Serialization queue for fundAccount — the junk wallet can only have one pending tx at a time.
-// Chaining onto this promise ensures concurrent calls are sequenced correctly.
-let fundAccountQueue: Promise<void> = Promise.resolve();
-
-/**
- * Fund a single account from the junk wallet (for ad-hoc test accounts).
- * Calls are serialized to avoid sequence number conflicts on the junk wallet.
- */
-export function fundAccount(publicKey: string): Promise<void> {
-    const result = fundAccountQueue.then(() => fundAccountInternal(publicKey));
-    fundAccountQueue = result.catch(() => {}); // keep queue alive if this call fails
-    return result;
-}
-
-async function fundAccountInternal(publicKey: string): Promise<void> {
-    const MAX_RETRIES = 5;
-    let lastError: unknown;
-
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-            // Re-fetch account on every attempt to get the latest sequence number
-            const junkAccount = await server.getAccount(JUNK_WALLET.publicKey());
-
-            const tx = new TransactionBuilder(junkAccount, {
-                fee: BASE_FEE,
-                networkPassphrase: NETWORK_PASSPHRASE,
-            })
-                .addOperation(
-                    Operation.createAccount({
-                        destination: publicKey,
-                        startingBalance: '100',
-                    }),
-                )
-                .setTimeout(30)
-                .build();
-
-            tx.sign(JUNK_WALLET);
-
-            const sendResult = await server.sendTransaction(tx);
-            if (sendResult.status !== 'PENDING') {
-                throw new Error(
-                    `Failed to fund account ${publicKey}: ${JSON.stringify(sendResult)}`,
-                );
-            }
-
-            const txResult = await server.pollTransaction(sendResult.hash);
-            if (txResult.status !== 'SUCCESS') {
-                throw new Error(
-                    `Account funding failed for ${publicKey}: ${JSON.stringify(txResult)}`,
-                );
-            }
-
-            return; // success
-        } catch (err) {
-            lastError = err;
-            if (attempt < MAX_RETRIES) {
-                await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
-            }
-        }
-    }
-
-    throw new Error(
-        `Failed to fund account ${publicKey} after ${MAX_RETRIES} attempts: ${lastError instanceof Error ? lastError.message : String(lastError)}`,
-    );
-}
-
-async function waitForRpcHealth(): Promise<void> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < STARTUP_TIMEOUT_MS) {
-        try {
-            const response = await fetch(RPC_URL, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'getHealth' }),
-                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-            });
-            const data = (await response.json()) as { result?: { status?: string } };
-            if (data.result?.status === 'healthy') return;
-        } catch {
-            // Not ready yet
-        }
-        await new Promise((resolve) => setTimeout(resolve, RETRY_INTERVAL_MS));
-    }
-    throw new Error(
-        `Stellar RPC failed to become healthy within ${STARTUP_TIMEOUT_MS / 1000} seconds`,
-    );
-}
-
-async function fundTestAccounts(): Promise<void> {
-    console.log('💰 Funding test accounts from junk wallet...');
-    const server = new rpc.Server(RPC_URL, { allowHttp: true });
-    const junkAccount = await server.getAccount(JUNK_WALLET.publicKey());
-
-    const tx = new TransactionBuilder(junkAccount, {
-        fee: BASE_FEE,
-        networkPassphrase: NETWORK_PASSPHRASE,
-    })
-        .addOperation(
-            Operation.createAccount({
-                destination: DEFAULT_DEPLOYER.publicKey(),
-                startingBalance: '2000',
-            }),
-        )
-        .addOperation(
-            Operation.createAccount({
-                destination: ZRO_DISTRIBUTOR.publicKey(),
-                startingBalance: '2000',
-            }),
-        )
-        .addOperation(
-            Operation.createAccount({
-                destination: EXECUTOR_ADMIN.publicKey(),
-                startingBalance: '2000',
-            }),
-        )
-        .addOperation(
-            Operation.createAccount({
-                destination: CHAIN_B_DEPLOYER.publicKey(),
-                startingBalance: '2000',
-            }),
-        )
-        .setTimeout(30)
-        .build();
-
-    tx.sign(JUNK_WALLET);
-
-    const sendResult = await server.sendTransaction(tx);
-    if (sendResult.status !== 'PENDING') {
-        throw new Error(`Failed to fund test accounts: ${JSON.stringify(sendResult)}`);
-    }
-
-    const txResult = await server.pollTransaction(sendResult.hash);
-    if (txResult.status !== 'SUCCESS') {
-        throw new Error(`Account funding transaction failed: ${JSON.stringify(txResult)}`);
-    }
-
-    console.log('✅ All test accounts funded');
-}
-
-export async function stopStellarLocalnet(): Promise<void> {
-    execSync(`docker rm -f ${CONTAINER_NAME}`, { stdio: 'ignore' });
-    console.log('✅ Stellar localnet stopped');
-}

package/test/suites/scan.ts

@@ -1,202 +0,0 @@
-import { rpc, xdr } from '@stellar/stellar-sdk';
-
-import { RPC_URL } from './constants.js';
-
-/**
- * Event filter for scanning contract events
- */
-export interface EventFilter {
-    contractId: string;
-}
-
-/**
- * Parsed contract event
- */
-export interface ParsedContractEvent {
-    type: string;
-    contractId: string;
-    topics: any[];
-    data: any;
-    ledger: number;
-    txHash: string;
-}
-
-/**
- * PacketSent event structure from endpoint_v2.rs
- */
-export interface PacketSentEvent {
-    encoded_packet: Buffer;
-    options: Buffer;
-    send_library: string;
-}
-
-/**
- * Scan for contract events within a ledger range
- */
-export async function scanEvents(
-    startLedgerSequence: number,
-    filter: EventFilter,
-): Promise<ParsedContractEvent[]> {
-    const server = new rpc.Server(RPC_URL, { allowHttp: true });
-    const latestLedger = await server.getLatestLedger();
-
-    console.log('🔍 Scanning events from ledger', startLedgerSequence);
-
-    try {
-        // Wait for at least one new ledger to ensure events are indexed
-        let endLedger = latestLedger.sequence;
-        if (endLedger <= startLedgerSequence) {
-            console.log('   Waiting for next ledger...');
-            for (let i = 0; i < 10; i++) {
-                await new Promise((resolve) => setTimeout(resolve, 1000));
-                const newLedger = await server.getLatestLedger();
-                if (newLedger.sequence > startLedgerSequence) {
-                    endLedger = newLedger.sequence;
-                    break;
-                }
-            }
-        }
-
-        const events = await server.getEvents({
-            startLedger: startLedgerSequence,
-            filters: [{ type: 'contract', contractIds: [filter.contractId] }],
-            endLedger: endLedger,
-        });
-
-        const parsedEvents: ParsedContractEvent[] = [];
-
-        for (const event of events.events || []) {
-            try {
-                const parsedEvent: ParsedContractEvent = {
-                    type: event.type,
-                    contractId: event.contractId?.contractId() || '',
-                    topics: event.topic,
-                    data: event.value ? xdr.ScVal.fromXDR(event.value.toXDR()) : undefined,
-                    ledger: event.ledger,
-                    txHash: event.txHash,
-                };
-                parsedEvents.push(parsedEvent);
-            } catch (e) {
-                console.warn('Failed to parse event:', e);
-            }
-        }
-
-        console.log(`✅ Found ${parsedEvents.length} events`);
-        return parsedEvents;
-    } catch (error: any) {
-        console.error('Error scanning events:', error.message);
-        throw error;
-    }
-}
-
-/**
- * Scan for PacketSent events from the Endpoint contract
- */
-export async function scanPacketSentEvents(
-    endpointAddress: string,
-    startLedger: number,
-): Promise<PacketSentEvent[]> {
-    console.log('📦 Scanning for PacketSent events...');
-    const events = await scanEvents(startLedger, {
-        contractId: endpointAddress,
-    });
-
-    // Filter for PacketSent events
-    // PacketSent event has topics like ["PacketSent"] or similar
-    const packetSentEvents: PacketSentEvent[] = [];
-
-    for (const event of events) {
-        try {
-            // Check if this is a PacketSent event
-            // The first topic should be the event name
-            const firstTopic = event.topics[0];
-
-            // Convert ScVal to string to check event name
-            let eventName = '';
-            if (firstTopic && firstTopic._switch?.name === 'scvSymbol') {
-                eventName = firstTopic.value()?.toString() || '';
-            }
-
-            if (eventName === 'packet_sent') {
-                // Parse the event data
-                // PacketSent { encoded_packet, options, send_library }
-                const eventData = event.data;
-
-                // Try to extract fields from the struct
-                if (eventData && eventData._switch?.name === 'scvMap') {
-                    const map = eventData.value();
-                    const packetEvent: Partial<PacketSentEvent> = {};
-
-                    for (const entry of map || []) {
-                        const key = entry.key().value()?.toString();
-                        const value = entry.val();
-
-                        if (key === 'encoded_packet' && value._switch?.name === 'scvBytes') {
-                            packetEvent.encoded_packet = Buffer.from(value.value());
-                        } else if (key === 'options' && value._switch?.name === 'scvBytes') {
-                            packetEvent.options = Buffer.from(value.value());
-                        } else if (key === 'send_library' && value._switch?.name === 'scvAddress') {
-                            packetEvent.send_library = value.value()?.toString() || '';
-                        }
-                    }
-
-                    if (
-                        packetEvent.encoded_packet &&
-                        packetEvent.options !== undefined &&
-                        packetEvent.send_library
-                    ) {
-                        packetSentEvents.push(packetEvent as PacketSentEvent);
-                    }
-                }
-            }
-        } catch (e) {
-            console.warn('Failed to parse PacketSent event:', e);
-        }
-    }
-
-    console.log(`✅ Found ${packetSentEvents.length} PacketSent events`);
-    return packetSentEvents;
-}
-
-/**
- * Wait for new ledgers and scan for events
- */
-export async function waitAndScanEvents(
-    startLedger: number,
-    contractAddress: string,
-    eventName: string,
-    maxWaitSeconds: number = 30,
-): Promise<ParsedContractEvent[]> {
-    const server = new rpc.Server(RPC_URL, { allowHttp: true });
-    const endTime = Date.now() + maxWaitSeconds * 1000;
-
-    console.log(`⏳ Waiting for ${eventName} events...`);
-
-    while (Date.now() < endTime) {
-        const currentLedger = await server.getLatestLedger();
-
-        if (currentLedger.sequence > startLedger) {
-            const events = await scanEvents(startLedger, {
-                contractId: contractAddress,
-            });
-
-            const matchingEvents = events.filter((e) => {
-                const firstTopic = e.topics[0];
-                if (firstTopic && firstTopic._switch?.name === 'scvSymbol') {
-                    const name = firstTopic.value()?.toString() || '';
-                    return name === eventName;
-                }
-                return false;
-            });
-
-            if (matchingEvents.length > 0) {
-                return matchingEvents;
-            }
-        }
-
-        // Wait 1 second before checking again
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-
-    throw new Error(`Timeout waiting for ${eventName} events`);
-}

package/turbo.json

@@ -1,15 +0,0 @@
-{
-    "extends": ["//"],
-    "tasks": {
-        "build": {
-            "inputs": [
-                "$TURBO_DEFAULT$",
-                "!**/*.md",
-                "!**/LICENSE",
-                "!test/**",
-                "!tsconfig.test.json",
-                "!vitest.config.ts"
-            ]
-        }
-    }
-}