@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.123

package/sdk/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/sdk/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/sdk/test/upgrader.test.ts

@@ -1,194 +0,0 @@
-import { BASE_FEE, Contract, scValToNative, TransactionBuilder, xdr } from '@stellar/stellar-sdk';
-import * as rpc from '@stellar/stellar-sdk/rpc';
-import { readFileSync } from 'fs';
-import path from 'path';
-import { describe, expect, it } from 'vitest';
-
-import { getFullyQualifiedRepoRootPath } from '@layerzerolabs/common-node-utils';
-
-import { Client as DvnClient } from '../src/generated/dvn.js';
-import { Client as UpgraderClient } from '../src/generated/upgrader.js';
-import {
-    DEFAULT_DEPLOYER,
-    DVN_SIGNER,
-    DVN_VID,
-    NETWORK_PASSPHRASE,
-    RPC_URL,
-} from './suites/constants.js';
-import { deployContract, uploadWasm } from './suites/deploy.js';
-import { signDvnAuthEntries } from './utils.js';
-
-let upgraderClient: UpgraderClient;
-let dvnClient: DvnClient;
-let testContractAddress: string;
-
-// Test data paths
-let TEST_CONTRACT_V1_WASM_PATH: string;
-let TEST_CONTRACT_V2_WASM_PATH: string;
-
-describe('Upgrader Contract Testing', async () => {
-    const repoRoot = await getFullyQualifiedRepoRootPath();
-    const upgraderWasmDir = path.join(
-        repoRoot,
-        'contracts',
-        'protocol',
-        'stellar',
-        'target',
-        'wasm32v1-none',
-        'release',
-    );
-    const testDataDir = path.join(
-        repoRoot,
-        'contracts',
-        'protocol',
-        'stellar',
-        'sdk',
-        'test',
-        'test_data',
-    );
-
-    const UPGRADER_WASM_PATH = path.join(upgraderWasmDir, 'upgrader.wasm');
-    TEST_CONTRACT_V1_WASM_PATH = path.join(upgraderWasmDir, 'dvn.wasm');
-    TEST_CONTRACT_V2_WASM_PATH = path.join(testDataDir, 'test_upgradeable_dvn.wasm');
-
-    describe('Contract Deployments', () => {
-        it('Deploy Upgrader Contract', async () => {
-            // Deploy upgrader contract using the helper (no constructor args needed)
-            upgraderClient = await deployContract<UpgraderClient>(
-                UpgraderClient,
-                UPGRADER_WASM_PATH,
-                undefined,
-                DEFAULT_DEPLOYER,
-            );
-
-            console.log('✅ Upgrader deployed at:', upgraderClient.options.contractId);
-            expect(upgraderClient.options.contractId).toBeDefined();
-        });
-
-        it('Deploy DVN Contract V1', async () => {
-            console.log('📖 Reading Test Contract V1 WASM file from:', TEST_CONTRACT_V1_WASM_PATH);
-            dvnClient = await deployContract<DvnClient>(
-                DvnClient,
-                TEST_CONTRACT_V1_WASM_PATH,
-                {
-                    vid: DVN_VID,
-                    signers: [DVN_SIGNER.ethAddress],
-                    threshold: 1,
-                    admins: [DEFAULT_DEPLOYER.publicKey()],
-                    supported_msglibs: [],
-                    price_feed: DEFAULT_DEPLOYER.publicKey(),
-                    default_multiplier_bps: 10000,
-                    worker_fee_lib: DEFAULT_DEPLOYER.publicKey(),
-                    deposit_address: DEFAULT_DEPLOYER.publicKey(),
-                },
-                DEFAULT_DEPLOYER,
-            );
-            testContractAddress = dvnClient.options.contractId;
-
-            console.log('✅ Test Contract V1 deployed at:', testContractAddress);
-            expect(testContractAddress).toBeDefined();
-        });
-
-        it('Verify Test Contract V1 VID', async () => {
-            const { result } = await dvnClient.vid();
-            console.log('✅ Test Contract V1 vid value:', result);
-            expect(result).toBe(DVN_VID);
-        });
-    });
-
-    describe('Upgrade Workflow', () => {
-        let newWasmHash: string;
-
-        it('Upload Test Contract V2 WASM', async () => {
-            console.log('📖 Reading Test Contract V2 WASM file from:', TEST_CONTRACT_V2_WASM_PATH);
-
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-
-            // Read and upload WASM for V2
-            const wasmBuffer = readFileSync(TEST_CONTRACT_V2_WASM_PATH);
-            newWasmHash = await uploadWasm(wasmBuffer, DEFAULT_DEPLOYER, server);
-            console.log('✅ Test Contract V2 WASM uploaded, hash:', newWasmHash);
-            expect(newWasmHash).toBeDefined();
-        });
-
-        it('Set Upgrader on DVN', async () => {
-            const setUpgraderTx = await dvnClient.set_upgrader({
-                upgrader: upgraderClient.options.contractId,
-            });
-
-            await signDvnAuthEntries(
-                testContractAddress,
-                DVN_VID,
-                DEFAULT_DEPLOYER,
-                [DVN_SIGNER],
-                setUpgraderTx,
-                NETWORK_PASSPHRASE,
-            );
-
-            await setUpgraderTx.signAndSend();
-            console.log('✅ Upgrader set on DVN to:', upgraderClient.options.contractId);
-
-            const { result: upgrader } = await dvnClient.upgrader();
-            expect(upgrader).toBe(upgraderClient.options.contractId);
-        });
-
-        it('Test Upgrader Contract Can Upgrade DVN with Multisig Auth', async () => {
-            console.log('🔄 Testing upgrader contract call...');
-            console.log('   Contract address:', testContractAddress);
-            console.log('   New WASM hash:', newWasmHash);
-
-            const upgradeTx = await upgraderClient.upgrade_and_migrate({
-                contract_address: testContractAddress,
-                wasm_hash: Buffer.from(newWasmHash, 'hex'),
-                migration_data: xdr.ScVal.scvVoid().toXDR(),
-                operator: undefined,
-            });
-
-            await signDvnAuthEntries(
-                testContractAddress,
-                DVN_VID,
-                DEFAULT_DEPLOYER,
-                [DVN_SIGNER],
-                upgradeTx,
-                NETWORK_PASSPHRASE,
-            );
-
-            await upgradeTx.signAndSend();
-            console.log('✅ Upgrade transaction completed');
-        });
-
-        it('Verify Test Contract V2 test_upgrade_version After Upgrade', async () => {
-            const server = new rpc.Server(RPC_URL, { allowHttp: true });
-            const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
-            const contract = new Contract(testContractAddress);
-            const tx = new TransactionBuilder(account, {
-                fee: BASE_FEE,
-                networkPassphrase: NETWORK_PASSPHRASE,
-            })
-                .addOperation(contract.call('test_upgrade_version'))
-                .setTimeout(30)
-                .build();
-
-            const simulated = await server.simulateTransaction(tx);
-            if (rpc.Api.isSimulationError(simulated)) {
-                throw new Error(
-                    `test_upgrade_version simulation failed: ${JSON.stringify(simulated)}`,
-                );
-            }
-
-            if (!simulated.result?.retval) {
-                throw new Error('No return value from test_upgrade_version');
-            }
-
-            const result = scValToNative(simulated.result.retval) as number;
-            console.log('✅ Test Contract V2 test_upgrade_version value:', result);
-            expect(result).toBe(2);
-        });
-
-        it('Verify Test Contract V1 Methods Still Work After Upgrade', async () => {
-            const { result } = await dvnClient.vid();
-            console.log('✅ Test Contract V2 vid value (from V1):', result);
-            expect(result).toBe(DVN_VID);
-        });
-    });
-});