@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/sdk/test/suites/localnet.ts

@@ -1,25 +1,42 @@
 import axios from 'axios';
 import { $, sleep } from 'zx';
 
-import { DEFAULT_DEPLOYER, FRIENDBOT_URL, ZRO_DISTRIBUTOR } from './constants';
+import { DEFAULT_DEPLOYER, EXECUTOR_ADMIN, FRIENDBOT_URL, ZRO_DISTRIBUTOR } from './constants';
 import { deployNativeSac, deployZroToken } from './deploy';
 
+const CONTAINER_NAME = 'stellar-localnet';
+const QUICKSTART_IMAGE = 'stellar/quickstart';
+
 export async function startStellarLocalnet(): Promise<void> {
     console.log('🚀 Starting Stellar localnet...');
 
-    //TODO: pnpm localnet up --only stellar
-    await $`stellar container start local`;
+    // Remove any existing container first (ignore errors if not running)
+    await $`docker rm -f ${CONTAINER_NAME}`.nothrow();
+
+    // Pull image only if not available locally
+    const imageExists = await $`docker image inspect ${QUICKSTART_IMAGE}`.nothrow().quiet();
+    if (imageExists.exitCode !== 0) {
+        console.log(`📥 Pulling ${QUICKSTART_IMAGE}...`);
+        await $`docker pull ${QUICKSTART_IMAGE}`;
+    }
+
+    // Start the stellar/quickstart container directly (no Stellar CLI needed)
+    await $`docker run -d --name ${CONTAINER_NAME} -p 8086:8000 ${QUICKSTART_IMAGE} --local`;
 
     // Wait for Stellar to start
-    for (let i = 0; i < 60; i++) {
+    for (let i = 0; i < 180; 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`);
+            await fundAccount(ZRO_DISTRIBUTOR.publicKey());
+            console.log(`✅ Account ${ZRO_DISTRIBUTOR.publicKey()} funded`);
+            await fundAccount(EXECUTOR_ADMIN.publicKey());
+            console.log(`✅ Account ${EXECUTOR_ADMIN.publicKey()} funded`);
             console.log('✅ Stellar localnet started');
             break;
         } catch (_e) {
+            console.error(`❌ Failed to fund account ${_e}`);
             await sleep(1000);
             console.log('⏳ Waiting for Stellar localnet to start...');
         }
@@ -37,6 +54,6 @@ export async function fundAccount(publicKey: string): Promise<void> {
 }
 
 export async function stopStellarLocalnet(): Promise<void> {
-    await $`stellar container stop`;
+    await $`docker rm -f ${CONTAINER_NAME}`;
     console.log('✅ Stellar localnet stopped');
 }

package/sdk/test/upgrader.test.ts

@@ -0,0 +1,300 @@
+import { Address, authorizeEntry, Keypair, xdr } from '@stellar/stellar-sdk';
+import { assembleTransaction } from '@stellar/stellar-sdk/rpc';
+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 UpgraderClient } from '../src/generated/upgrader';
+import { DEFAULT_DEPLOYER, NETWORK_PASSPHRASE, RPC_URL } from './suites/constants';
+import { deployContract, uploadWasm } from './suites/deploy';
+import { Client as DummyContractClient } from './suites/dummyContractClient';
+
+let upgraderClient: UpgraderClient;
+let dummyContractClient: DummyContractClient;
+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',
+        'contracts',
+        'upgrader',
+        'src',
+        'tests',
+        'test_data',
+    );
+
+    const UPGRADER_WASM_PATH = path.join(upgraderWasmDir, 'upgrader.wasm');
+    TEST_CONTRACT_V1_WASM_PATH = path.join(testDataDir, 'test_upgradeable_contract1.wasm');
+    TEST_CONTRACT_V2_WASM_PATH = path.join(testDataDir, 'test_upgradeable_contract2.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 Test Upgradeable Contract V1', async () => {
+            console.log('📖 Reading Test Contract V1 WASM file from:', TEST_CONTRACT_V1_WASM_PATH);
+
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // Read and upload WASM
+            const wasmBuffer = readFileSync(TEST_CONTRACT_V1_WASM_PATH);
+            const wasmHash = await uploadWasm(wasmBuffer, DEFAULT_DEPLOYER, server);
+            console.log('✅ Test Contract V1 WASM uploaded, hash:', wasmHash);
+
+            // Deploy test contract V1 with owner as constructor arg
+            console.log('🚀 Deploying Test Contract V1...');
+            const { TransactionBuilder, Operation, StrKey, Address } = await import(
+                '@stellar/stellar-sdk'
+            );
+
+            const account = await server.getAccount(DEFAULT_DEPLOYER.publicKey());
+            const salt = Buffer.from(Keypair.random().rawPublicKey());
+
+            // Create contract from WASM with constructor args
+            const wasmHashBuffer = Buffer.from(wasmHash, 'hex');
+
+            // Encode constructor args: owner (Address)
+            const ownerScVal = Address.fromString(DEFAULT_DEPLOYER.publicKey()).toScVal();
+
+            const createContractTx = new TransactionBuilder(account, {
+                fee: '100000',
+                networkPassphrase: NETWORK_PASSPHRASE,
+            })
+                .addOperation(
+                    Operation.createCustomContract({
+                        address: Address.fromString(DEFAULT_DEPLOYER.publicKey()),
+                        wasmHash: wasmHashBuffer,
+                        salt: salt,
+                        constructorArgs: [ownerScVal],
+                    }),
+                )
+                .setTimeout(30)
+                .build();
+
+            // Simulate to get the contract ID
+            const simulated = await server.simulateTransaction(createContractTx);
+            const preparedTx = rpc.assembleTransaction(createContractTx, simulated).build();
+            preparedTx.sign(DEFAULT_DEPLOYER);
+
+            const sendResult = await server.sendTransaction(preparedTx);
+            if (sendResult.status !== 'PENDING') {
+                throw new Error(`Transaction failed: ${JSON.stringify(sendResult)}`);
+            }
+
+            const txResult = await server.pollTransaction(sendResult.hash);
+            if (txResult.status !== 'SUCCESS') {
+                throw new Error(`Transaction not successful: ${JSON.stringify(txResult)}`);
+            }
+
+            // Extract contract address from the transaction result
+            const returnValue = txResult.returnValue;
+            if (!returnValue) {
+                throw new Error('No return value from contract creation');
+            }
+
+            // The return value is an Address ScVal, decode it
+            const contractIdHash = returnValue.address().contractId();
+            testContractAddress = StrKey.encodeContract(
+                Buffer.from(contractIdHash as unknown as Uint8Array),
+            );
+
+            // Create client for the deployed contract
+            dummyContractClient = new DummyContractClient({
+                contractId: testContractAddress,
+                publicKey: DEFAULT_DEPLOYER.publicKey(),
+                signTransaction: async (tx: string) => {
+                    const transaction = TransactionBuilder.fromXDR(tx, NETWORK_PASSPHRASE);
+                    transaction.sign(DEFAULT_DEPLOYER);
+                    return {
+                        signedTxXdr: transaction.toXDR(),
+                        signerAddress: DEFAULT_DEPLOYER.publicKey(),
+                    };
+                },
+                rpcUrl: RPC_URL,
+                networkPassphrase: NETWORK_PASSPHRASE,
+                allowHttp: true,
+            });
+
+            console.log('✅ Test Contract V1 deployed at:', testContractAddress);
+            expect(testContractAddress).toBeDefined();
+        });
+
+        it('Verify Test Contract V1 Counter', async () => {
+            // Call counter() on V1 contract, should return 1
+            const { result } = await dummyContractClient.counter();
+            console.log('✅ Test Contract V1 counter value:', result);
+            expect(result).toBe(1);
+        });
+    });
+
+    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('Test Upgrader Contract Can Be Called', async () => {
+            console.log('🔄 Testing upgrader contract call...');
+            console.log('   Contract address:', testContractAddress);
+            console.log('   New WASM hash:', newWasmHash);
+
+            // NOTE: Using Option 2 - Hybrid approach with generated client
+            // Build with generated client, then manually simulate with authMode, then inject back
+
+            const voidScVal = xdr.ScVal.scvVoid();
+            const server = new rpc.Server(RPC_URL, { allowHttp: true });
+
+            // 1. Build transaction using generated client (don't auto-simulate)
+            const assembledTx = await upgraderClient.upgrade_and_migrate(
+                {
+                    contract_address: testContractAddress,
+                    wasm_hash: Buffer.from(newWasmHash, 'hex'),
+                    migration_data: [voidScVal],
+                },
+                {
+                    simulate: false, // Don't simulate yet
+                },
+            );
+
+            console.log('✅ Transaction built with generated client');
+
+            // Build the transaction from the raw builder
+            const rawTx = assembledTx.raw!.build();
+
+            console.log('✅ Raw transaction built');
+
+            // 2. Manually simulate with record_allow_nonroot authMode
+            const sim = await server.simulateTransaction(
+                rawTx,
+                undefined, // addlResources
+                'record_allow_nonroot', // ← This enables non-root auth recording!
+            );
+
+            if (rpc.Api.isSimulationError(sim)) {
+                throw new Error(`Simulation failed: ${JSON.stringify(sim)}`);
+            }
+
+            console.log('✅ Transaction simulated with record_allow_nonroot');
+            console.log('   Auth entries returned:', sim.result?.auth?.length ?? 0);
+
+            // 3. Sign auth entries manually (high-level API doesn't see them after injection)
+            const latestLedger = sim.latestLedger;
+            const validUntilLedger = latestLedger + 100;
+
+            if (sim.result && sim.result.auth) {
+                sim.result.auth = await Promise.all(
+                    sim.result.auth.map(async (entry) => {
+                        // Source account credentials are already signed by tx envelope
+                        if (
+                            entry.credentials().switch() ===
+                            xdr.SorobanCredentialsType.sorobanCredentialsSourceAccount()
+                        ) {
+                            console.log('   Skipping source account auth entry');
+                            return entry;
+                        }
+
+                        // Address credentials need explicit signature
+                        const addr = Address.fromScAddress(
+                            entry.credentials().address().address(),
+                        ).toString();
+
+                        console.log('   Signing auth entry for address:', addr);
+
+                        if (addr === DEFAULT_DEPLOYER.publicKey()) {
+                            // Sign with owner's keypair
+                            return authorizeEntry(
+                                entry,
+                                DEFAULT_DEPLOYER,
+                                validUntilLedger,
+                                NETWORK_PASSPHRASE,
+                            );
+                        }
+
+                        throw new Error(`Unexpected auth signer needed: ${addr}`);
+                    }),
+                );
+                console.log('✅ Auth entries signed');
+            }
+
+            // 4. Assemble final transaction with signed auth entries
+            const finalTxBuilder = assembleTransaction(rawTx, sim);
+            const finalTx = finalTxBuilder.build();
+
+            console.log('✅ Final transaction assembled');
+
+            // 5. Sign the transaction envelope
+            finalTx.sign(DEFAULT_DEPLOYER);
+
+            console.log('✅ Transaction envelope signed');
+
+            // 6. Send and poll
+            const sentResult = await server.sendTransaction(finalTx);
+
+            if (sentResult.status !== 'PENDING') {
+                throw new Error(`Transaction failed to send: ${JSON.stringify(sentResult)}`);
+            }
+
+            console.log('✅ Transaction sent, hash:', sentResult.hash);
+
+            const txResult = await server.pollTransaction(sentResult.hash);
+
+            console.log('✅ Upgrade transaction completed');
+            console.log('   Transaction status:', txResult.status);
+
+            expect(txResult.status).toBe('SUCCESS');
+        });
+
+        it('Verify Test Contract V2 Counter2 After Upgrade', async () => {
+            // After upgrade, the contract should have counter2() function that returns 2
+            const { result } = await dummyContractClient.counter2();
+            console.log('✅ Test Contract V2 counter2 value:', result);
+            expect(result).toBe(2);
+        });
+
+        it('Verify Test Contract V1 Counter Still Works After Upgrade', async () => {
+            // The original counter() should still be accessible and return 1
+            const { result } = await dummyContractClient.counter();
+            console.log('✅ Test Contract V2 counter value (from V1):', result);
+            expect(result).toBe(1);
+        });
+    });
+});