solana-ts 0.1.0

package/src/test.ts

@@ -0,0 +1,674 @@
+import {
+  Connection,
+  Keypair,
+  LAMPORTS_PER_SOL,
+  SystemProgram,
+  Transaction,
+  sendAndConfirmTransaction,
+} from "@solana/web3.js";
+import { createServer } from "./server.js";
+import type { ServerConfig } from "./types.js";
+import { setLogLevel } from "./types.js";
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+let nextPort = 18899;
+
+function tmpDb(): string {
+  return path.join(
+    os.tmpdir(),
+    `solana-ts-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`
+  );
+}
+
+function makeConfig(overrides: Partial<ServerConfig> = {}): ServerConfig {
+  const port = nextPort;
+  nextPort += 2; // reserve port and port+1 (WS)
+  return {
+    host: "127.0.0.1",
+    port,
+    ledgerPath: tmpDb(),
+    reset: true,
+    transactionHistory: 1000,
+    logLevel: "warn",
+    ...overrides,
+  };
+}
+
+async function startServer(config: ServerConfig) {
+  const server = createServer(config);
+  await server.start();
+  const url = `http://${config.host}:${config.port}`;
+  const connection = new Connection(url, "confirmed");
+  return { server, connection, url };
+}
+
+function cleanDb(dbPath: string) {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      fs.unlinkSync(dbPath + suffix);
+    } catch {}
+  }
+}
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, msg: string): void {
+  if (!condition) throw new Error(`Assertion failed: ${msg}`);
+}
+
+async function runTest(name: string, fn: () => Promise<void>) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  ✓ ${name}`);
+  } catch (err) {
+    failed++;
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`  ✗ ${name}: ${msg}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test suites
+// ---------------------------------------------------------------------------
+
+async function basicRpcTests() {
+  console.log("\n── Basic RPC ──");
+  const config = makeConfig();
+  const { server, connection } = await startServer(config);
+
+  try {
+    await runTest("getVersion returns solana-core", async () => {
+      const v = await connection.getVersion();
+      assert(
+        typeof v["solana-core"] === "string",
+        `unexpected version: ${JSON.stringify(v)}`
+      );
+    });
+
+    await runTest("getSlot returns a number >= 1", async () => {
+      const slot = await connection.getSlot();
+      assert(typeof slot === "number" && slot >= 1, `slot=${slot}`);
+    });
+
+    await runTest("getBlockHeight returns a number >= 1", async () => {
+      const h = await connection.getBlockHeight();
+      assert(typeof h === "number" && h >= 1, `height=${h}`);
+    });
+
+    await runTest("getLatestBlockhash returns blockhash string", async () => {
+      const { blockhash, lastValidBlockHeight } =
+        await connection.getLatestBlockhash();
+      assert(typeof blockhash === "string" && blockhash.length > 0, "empty bh");
+      assert(lastValidBlockHeight > 0, `lvbh=${lastValidBlockHeight}`);
+    });
+
+    await runTest("getBalance of unknown address is 0", async () => {
+      const bal = await connection.getBalance(Keypair.generate().publicKey);
+      assert(bal === 0, `bal=${bal}`);
+    });
+
+    await runTest("getAccountInfo of unknown address is null", async () => {
+      const info = await connection.getAccountInfo(
+        Keypair.generate().publicKey
+      );
+      assert(info === null, "expected null");
+    });
+
+    await runTest("getMinimumBalanceForRentExemption returns > 0", async () => {
+      const min = await connection.getMinimumBalanceForRentExemption(0);
+      assert(min > 0, `min=${min}`);
+    });
+  } finally {
+    await server.stop();
+    cleanDb(config.ledgerPath);
+  }
+}
+
+async function airdropAndTransferTests() {
+  console.log("\n── Airdrop & Transfer ──");
+  const config = makeConfig();
+  const { server, connection } = await startServer(config);
+
+  const payer = Keypair.generate();
+  const receiver = Keypair.generate();
+  let transferSig = "";
+
+  try {
+    await runTest("requestAirdrop + confirmTransaction", async () => {
+      const sig = await connection.requestAirdrop(
+        payer.publicKey,
+        2 * LAMPORTS_PER_SOL
+      );
+      assert(typeof sig === "string" && sig.length > 0, "no sig");
+      const conf = await connection.confirmTransaction(sig);
+      assert(conf.value.err === null, `confirm err: ${conf.value.err}`);
+    });
+
+    await runTest("payer balance equals airdropped amount", async () => {
+      const bal = await connection.getBalance(payer.publicKey);
+      assert(bal === 2 * LAMPORTS_PER_SOL, `bal=${bal}`);
+    });
+
+    await runTest("sendAndConfirmTransaction (SOL transfer)", async () => {
+      const tx = new Transaction().add(
+        SystemProgram.transfer({
+          fromPubkey: payer.publicKey,
+          toPubkey: receiver.publicKey,
+          lamports: LAMPORTS_PER_SOL / 2,
+        })
+      );
+      transferSig = await sendAndConfirmTransaction(connection, tx, [payer]);
+      assert(transferSig.length > 0, "no sig");
+    });
+
+    await runTest("receiver got 0.5 SOL", async () => {
+      const bal = await connection.getBalance(receiver.publicKey);
+      assert(bal === LAMPORTS_PER_SOL / 2, `bal=${bal}`);
+    });
+
+    await runTest("payer balance decreased by 0.5 SOL + fee", async () => {
+      const bal = await connection.getBalance(payer.publicKey);
+      assert(bal < 2 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      assert(bal > LAMPORTS_PER_SOL, `bal too low: ${bal}`);
+    });
+
+    await runTest("getTransaction returns metadata", async () => {
+      const info = await connection.getTransaction(transferSig, {
+        maxSupportedTransactionVersion: 0,
+      });
+      assert(info !== null, "tx not found");
+      assert(typeof info!.slot === "number", "no slot");
+      assert(info!.meta?.err === null, `tx err: ${info!.meta?.err}`);
+      assert((info!.meta?.fee ?? 0) > 0, "fee should be > 0");
+    });
+
+    await runTest("getSignatureStatuses returns confirmed", async () => {
+      const res = await connection.getSignatureStatuses([transferSig]);
+      const s = res.value[0];
+      assert(s !== null, "status null");
+      assert(s!.confirmationStatus === "confirmed", `status=${s!.confirmationStatus}`);
+    });
+
+    await runTest("slot advanced after transactions", async () => {
+      const slot = await connection.getSlot();
+      assert(slot > 1, `slot should have advanced, got ${slot}`);
+    });
+  } finally {
+    await server.stop();
+    cleanDb(config.ledgerPath);
+  }
+}
+
+async function multipleAirdropTransferTests() {
+  console.log("\n── Multiple transfers ──");
+  const config = makeConfig();
+  const { server, connection } = await startServer(config);
+
+  try {
+    const alice = Keypair.generate();
+    const bob = Keypair.generate();
+    const carol = Keypair.generate();
+
+    // fund alice
+    const sig1 = await connection.requestAirdrop(
+      alice.publicKey,
+      5 * LAMPORTS_PER_SOL
+    );
+    await connection.confirmTransaction(sig1);
+
+    // alice -> bob 1 SOL
+    const tx1 = new Transaction().add(
+      SystemProgram.transfer({
+        fromPubkey: alice.publicKey,
+        toPubkey: bob.publicKey,
+        lamports: LAMPORTS_PER_SOL,
+      })
+    );
+    await sendAndConfirmTransaction(connection, tx1, [alice]);
+
+    // alice -> carol 2 SOL
+    const tx2 = new Transaction().add(
+      SystemProgram.transfer({
+        fromPubkey: alice.publicKey,
+        toPubkey: carol.publicKey,
+        lamports: 2 * LAMPORTS_PER_SOL,
+      })
+    );
+    await sendAndConfirmTransaction(connection, tx2, [alice]);
+
+    await runTest("bob has 1 SOL", async () => {
+      const bal = await connection.getBalance(bob.publicKey);
+      assert(bal === LAMPORTS_PER_SOL, `bob bal=${bal}`);
+    });
+
+    await runTest("carol has 2 SOL", async () => {
+      const bal = await connection.getBalance(carol.publicKey);
+      assert(bal === 2 * LAMPORTS_PER_SOL, `carol bal=${bal}`);
+    });
+
+    await runTest("alice balance decreased correctly", async () => {
+      const bal = await connection.getBalance(alice.publicKey);
+      // 5 SOL - 1 SOL - 2 SOL - 2 * 5000 lamports fee
+      assert(bal < 2 * LAMPORTS_PER_SOL, `alice bal=${bal}`);
+      assert(bal > LAMPORTS_PER_SOL, `alice bal too low=${bal}`);
+    });
+  } finally {
+    await server.stop();
+    cleanDb(config.ledgerPath);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Persistence tests
+// ---------------------------------------------------------------------------
+
+async function persistenceBalanceSurvivesRestart() {
+  console.log("\n── Persistence: balance survives restart ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  const payer = Keypair.generate();
+  const payerAddr = payer.publicKey.toBase58();
+
+  try {
+    // --- session 1: airdrop ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+      const sig = await connection.requestAirdrop(
+        payer.publicKey,
+        3 * LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(sig);
+
+      await runTest("session 1: payer has 3 SOL", async () => {
+        const bal = await connection.getBalance(payer.publicKey);
+        assert(bal === 3 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await server.stop();
+    }
+
+    // small delay so OS releases ports
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: restore without reset ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: false,
+        port: baseConfig.port, // reuse same port
+      });
+      // un-bump the port counter since we manually set it
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2: payer still has 3 SOL", async () => {
+        const bal = await connection.getBalance(payer.publicKey);
+        assert(bal === 3 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+async function persistenceTransferSurvivesRestart() {
+  console.log("\n── Persistence: transfer balances survive restart ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  const alice = Keypair.generate();
+  const bob = Keypair.generate();
+
+  try {
+    // --- session 1: airdrop alice, transfer to bob ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+
+      const sig = await connection.requestAirdrop(
+        alice.publicKey,
+        5 * LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(sig);
+
+      const tx = new Transaction().add(
+        SystemProgram.transfer({
+          fromPubkey: alice.publicKey,
+          toPubkey: bob.publicKey,
+          lamports: 2 * LAMPORTS_PER_SOL,
+        })
+      );
+      await sendAndConfirmTransaction(connection, tx, [alice]);
+
+      await runTest("session 1: bob has 2 SOL", async () => {
+        const bal = await connection.getBalance(bob.publicKey);
+        assert(bal === 2 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      const aliceBal = await connection.getBalance(alice.publicKey);
+      await runTest("session 1: alice balance < 3 SOL (fee deducted)", async () => {
+        assert(aliceBal < 3 * LAMPORTS_PER_SOL, `bal=${aliceBal}`);
+      });
+
+      await server.stop();
+    }
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: verify both balances ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: false,
+        port: baseConfig.port,
+      });
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2: bob still has 2 SOL", async () => {
+        const bal = await connection.getBalance(bob.publicKey);
+        assert(bal === 2 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await runTest("session 2: alice balance persisted correctly", async () => {
+        const bal = await connection.getBalance(alice.publicKey);
+        assert(bal < 3 * LAMPORTS_PER_SOL, `bal=${bal}`);
+        assert(bal > 2 * LAMPORTS_PER_SOL, `bal too low=${bal}`);
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+async function persistenceSlotSurvivesRestart() {
+  console.log("\n── Persistence: slot counter survives restart ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  try {
+    let slotAfterTx: number;
+
+    // --- session 1: do some work to advance slot ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+      const kp = Keypair.generate();
+      const sig = await connection.requestAirdrop(
+        kp.publicKey,
+        LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(sig);
+      slotAfterTx = await connection.getSlot();
+
+      await runTest("session 1: slot advanced past 1", async () => {
+        assert(slotAfterTx > 1, `slot=${slotAfterTx}`);
+      });
+
+      await server.stop();
+    }
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: slot should resume ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: false,
+        port: baseConfig.port,
+      });
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2: slot >= session 1 slot", async () => {
+        const slot = await connection.getSlot();
+        assert(slot >= slotAfterTx!, `slot=${slot} < expected=${slotAfterTx}`);
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+async function persistenceTransactionHistorySurvivesRestart() {
+  console.log("\n── Persistence: transaction history survives restart ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  const payer = Keypair.generate();
+  const receiver = Keypair.generate();
+  let txSig = "";
+
+  try {
+    // --- session 1: airdrop + transfer ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+
+      const airdropSig = await connection.requestAirdrop(
+        payer.publicKey,
+        2 * LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(airdropSig);
+
+      const tx = new Transaction().add(
+        SystemProgram.transfer({
+          fromPubkey: payer.publicKey,
+          toPubkey: receiver.publicKey,
+          lamports: LAMPORTS_PER_SOL,
+        })
+      );
+      txSig = await sendAndConfirmTransaction(connection, tx, [payer]);
+
+      await runTest("session 1: getTransaction works", async () => {
+        const info = await connection.getTransaction(txSig, {
+          maxSupportedTransactionVersion: 0,
+        });
+        assert(info !== null, "tx not found");
+      });
+
+      await runTest("session 1: getSignatureStatuses works", async () => {
+        const res = await connection.getSignatureStatuses([txSig]);
+        assert(res.value[0]?.confirmationStatus === "confirmed", "not confirmed");
+      });
+
+      await server.stop();
+    }
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: tx history should still be there ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: false,
+        port: baseConfig.port,
+      });
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2: getTransaction still returns the tx", async () => {
+        const info = await connection.getTransaction(txSig, {
+          maxSupportedTransactionVersion: 0,
+        });
+        assert(info !== null, "tx not found after restart");
+        assert(info!.meta?.err === null, `err: ${info!.meta?.err}`);
+        assert((info!.meta?.fee ?? 0) > 0, "fee should persist");
+      });
+
+      await runTest("session 2: getSignatureStatuses still confirmed", async () => {
+        const res = await connection.getSignatureStatuses([txSig]);
+        assert(res.value[0] !== null, "status null");
+        assert(
+          res.value[0]!.confirmationStatus === "confirmed",
+          `status: ${res.value[0]!.confirmationStatus}`
+        );
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+async function persistenceResetClearsState() {
+  console.log("\n── Persistence: --reset clears everything ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  const kp = Keypair.generate();
+
+  try {
+    // --- session 1: put some state ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+      const sig = await connection.requestAirdrop(
+        kp.publicKey,
+        LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(sig);
+
+      await runTest("session 1: balance is 1 SOL", async () => {
+        const bal = await connection.getBalance(kp.publicKey);
+        assert(bal === LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await server.stop();
+    }
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: start with --reset ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: true,
+        port: baseConfig.port,
+      });
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2 (reset): balance is 0", async () => {
+        const bal = await connection.getBalance(kp.publicKey);
+        assert(bal === 0, `bal=${bal}, expected 0 after reset`);
+      });
+
+      await runTest("session 2 (reset): slot is back to 1", async () => {
+        const slot = await connection.getSlot();
+        assert(slot === 1, `slot=${slot}, expected 1 after reset`);
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+async function persistenceCanTransactAfterRestore() {
+  console.log("\n── Persistence: can transact on restored state ──");
+  const dbPath = tmpDb();
+  const baseConfig = makeConfig({ ledgerPath: dbPath, reset: true });
+
+  const alice = Keypair.generate();
+  const bob = Keypair.generate();
+
+  try {
+    // --- session 1: airdrop alice ---
+    {
+      const { server, connection } = await startServer(baseConfig);
+      const sig = await connection.requestAirdrop(
+        alice.publicKey,
+        5 * LAMPORTS_PER_SOL
+      );
+      await connection.confirmTransaction(sig);
+      await server.stop();
+    }
+
+    await new Promise((r) => setTimeout(r, 300));
+
+    // --- session 2: transfer from restored alice -> bob ---
+    {
+      const config2 = makeConfig({
+        ledgerPath: dbPath,
+        reset: false,
+        port: baseConfig.port,
+      });
+      nextPort -= 2;
+
+      const { server, connection } = await startServer(config2);
+
+      await runTest("session 2: alice can still send SOL", async () => {
+        const tx = new Transaction().add(
+          SystemProgram.transfer({
+            fromPubkey: alice.publicKey,
+            toPubkey: bob.publicKey,
+            lamports: LAMPORTS_PER_SOL,
+          })
+        );
+        const sig = await sendAndConfirmTransaction(connection, tx, [alice]);
+        assert(sig.length > 0, "no sig");
+      });
+
+      await runTest("session 2: bob received 1 SOL", async () => {
+        const bal = await connection.getBalance(bob.publicKey);
+        assert(bal === LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await runTest("session 2: alice balance updated", async () => {
+        const bal = await connection.getBalance(alice.publicKey);
+        assert(bal < 4 * LAMPORTS_PER_SOL, `bal=${bal}`);
+      });
+
+      await server.stop();
+    }
+  } finally {
+    cleanDb(dbPath);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  setLogLevel("error");
+  console.log("Solana-TS Test Suite\n");
+
+  await basicRpcTests();
+  await airdropAndTransferTests();
+  await multipleAirdropTransferTests();
+
+  await persistenceBalanceSurvivesRestart();
+  await persistenceTransferSurvivesRestart();
+  await persistenceSlotSurvivesRestart();
+  await persistenceTransactionHistorySurvivesRestart();
+  await persistenceResetClearsState();
+  await persistenceCanTransactAfterRestore();
+
+  console.log(`\n${"═".repeat(40)}`);
+  console.log(`  ${passed} passed, ${failed} failed`);
+  console.log(`${"═".repeat(40)}\n`);
+
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+main();