solforge 0.2.11 → 0.2.13

package/scripts/install.sh

@@ -1,112 +0,0 @@
-#!/usr/bin/env sh
-set -e
-
-# SolForge installer (downloads GitHub release binary)
-# Usage: curl -fsSL https://sh.solforge.sh | sh
-# Optional: SOLFORGE_VERSION=v0.2.5 curl -fsSL https://sh.solforge.sh | sh
-
-REPO="nitishxyz/solforge"
-BIN_NAME="solforge"
-VERSION="${SOLFORGE_VERSION:-latest}"
-
-info() { printf "\033[1;34m[i]\033[0m %s\n" "$*"; }
-warn() { printf "\033[1;33m[!]\033[0m %s\n" "$*"; }
-err()  { printf "\033[1;31m[x]\033[0m %s\n" "$*" 1>&2; }
-
-# Detect downloader
-http_get() {
-  if command -v curl >/dev/null 2>&1; then
-    curl -fsSL "$1"
-  elif command -v wget >/dev/null 2>&1; then
-    wget -qO- "$1"
-  else
-    err "Need 'curl' or 'wget' to download binaries"
-    exit 1
-  fi
-}
-
-http_down() {
-  dest="$2"
-  if command -v curl >/dev/null 2>&1; then
-    curl -fL --progress-bar -o "$dest" "$1"
-  else
-    wget -qO "$dest" "$1"
-  fi
-}
-
-# OS/arch detection
-uname_s=$(uname -s 2>/dev/null || echo unknown)
-uname_m=$(uname -m 2>/dev/null || echo unknown)
-
-case "$uname_s" in
-  Linux)  os="linux" ;;
-  Darwin) os="darwin" ;;
-  *) err "Unsupported OS: $uname_s"; exit 1 ;;
-esac
-
-case "$uname_m" in
-  x86_64|amd64) arch="x64" ;;
-  arm64|aarch64) arch="arm64" ;;
-  *) err "Unsupported architecture: $uname_m"; exit 1 ;;
-esac
-
-asset="${BIN_NAME}-${os}-${arch}"
-ext=""
-filename="$asset$ext"
-
-# Build URL
-if [ "$VERSION" = "latest" ]; then
-  base="https://github.com/$REPO/releases/latest/download"
-else
-  base="https://github.com/$REPO/releases/download/$VERSION"
-fi
-
-url="$base/$filename"
-
-info "Installing $BIN_NAME ($os/$arch) from: $url"
-
-# Download
-tmpdir=${TMPDIR:-/tmp}
-tmpfile="$tmpdir/$filename"
-http_down "$url" "$tmpfile"
-
-# Make executable
-chmod +x "$tmpfile"
-
-# Choose install dir
-install_dir="/usr/local/bin"
-if [ ! -w "$install_dir" ]; then
-  if command -v sudo >/dev/null 2>&1; then
-    sudo_cmd="sudo"
-  else
-    sudo_cmd=""
-  fi
-fi
-
-if [ -n "$sudo_cmd" ] && [ -d "$install_dir" ] && [ ! -w "$install_dir" ]; then
-  info "Moving binary to $install_dir (requires sudo)"
-  $sudo_cmd mv "$tmpfile" "$install_dir/$BIN_NAME"
-else
-  # Fallback to user bin
-  user_bin="$HOME/.local/bin"
-  mkdir -p "$user_bin"
-  info "Moving binary to $user_bin"
-  mv "$tmpfile" "$user_bin/$BIN_NAME"
-  install_dir="$user_bin"
-fi
-
-# Verify
-if "$install_dir/$BIN_NAME" --version >/dev/null 2>&1; then
-  ver=$("$install_dir/$BIN_NAME" --version 2>/dev/null || true)
-  info "$BIN_NAME installed: $ver"
-else
-  warn "Installed, but failed to run --version"
-fi
-
-# PATH hint
-case ":$PATH:" in
-  *":$install_dir:"*) :;;
-  *) warn "Add $install_dir to your PATH to use '$BIN_NAME'" ;;
-esac
-
-info "Done. Run: $BIN_NAME --help"

package/server/index.ts

@@ -1,5 +0,0 @@
-export * from "./methods";
-export { rpcMethods } from "./methods";
-export { createLiteSVMRpcServer, LiteSVMRpcServer } from "./rpc-server";
-export * from "./types";
-export { createLiteSVMWebSocketServer } from "./ws-server";

package/server/lib/base58.ts

@@ -1,33 +0,0 @@
-const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-const BASE = BigInt(ALPHABET.length);
-
-export function encodeBase58(bytes: Uint8Array): string {
-	let num = 0n;
-	for (let i = 0; i < bytes.length; i++)
-		num = num * 256n + BigInt(bytes[i] || 0);
-	let encoded = "";
-	while (num > 0n) {
-		const remainder = num % BASE;
-		num = num / BASE;
-		encoded = ALPHABET[Number(remainder)] + encoded;
-	}
-	for (let i = 0; i < bytes.length && bytes[i] === 0; i++)
-		encoded = `1${encoded}`;
-	return encoded || "1";
-}
-
-export function decodeBase58(str: string): Uint8Array {
-	let num = 0n;
-	for (const char of str) {
-		const index = ALPHABET.indexOf(char);
-		if (index === -1) throw new Error("Invalid base58 character");
-		num = num * BASE + BigInt(index);
-	}
-	const bytes: number[] = [];
-	while (num > 0n) {
-		bytes.unshift(Number(num % 256n));
-		num = num / 256n;
-	}
-	for (let i = 0; i < str.length && str[i] === "1"; i++) bytes.unshift(0);
-	return new Uint8Array(bytes.length > 0 ? bytes : [0]);
-}

package/server/lib/faucet.ts

@@ -1,110 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import {
-	Keypair,
-	type PublicKey,
-	SystemProgram,
-	Transaction,
-} from "@solana/web3.js";
-import type { LiteSVM } from "litesvm";
-
-const DEFAULT_PATH =
-	process.env.SOLFORGE_FAUCET_PATH || ".solforge/faucet.json";
-// Default to 1,000,000 SOL so we never run out in local dev.
-// Override with SOLFORGE_FAUCET_LAMPORTS if desired.
-const DEFAULT_INITIAL_LAMPORTS = BigInt(
-	process.env.SOLFORGE_FAUCET_LAMPORTS || "1000000000000000",
-); // 1e15 lamports = 1,000,000 SOL
-
-type FaucetFile = { secretKey: string; publicKey: string; createdAt: string };
-
-function ensureDir(path: string) {
-	try {
-		mkdirSync(dirname(path), { recursive: true });
-	} catch {}
-}
-
-export function loadOrCreateFaucet(path: string = DEFAULT_PATH): Keypair {
-	try {
-		if (existsSync(path)) {
-			const raw = readFileSync(path, "utf8");
-			const data = JSON.parse(raw) as FaucetFile;
-			const secret = Buffer.from(data.secretKey, "base64");
-			return Keypair.fromSecretKey(new Uint8Array(secret));
-		}
-	} catch {}
-
-	const kp = Keypair.generate();
-	try {
-		ensureDir(path);
-		const payload: FaucetFile = {
-			secretKey: Buffer.from(kp.secretKey).toString("base64"),
-			publicKey: kp.publicKey.toBase58(),
-			createdAt: new Date().toISOString(),
-		};
-		writeFileSync(path, JSON.stringify(payload, null, 2), "utf8");
-	} catch {}
-	return kp;
-}
-
-export function fundFaucetIfNeeded(
-	svm: LiteSVM,
-	faucet: Keypair,
-	targetLamports: bigint = DEFAULT_INITIAL_LAMPORTS,
-): bigint {
-	let bal = 0n;
-	try {
-		bal = svm.getBalance(faucet.publicKey as PublicKey) || 0n;
-	} catch {
-		bal = 0n;
-	}
-	if (bal >= targetLamports) return bal;
-
-	// Observed per-account airdrop cap ~10k SOL. Work around by creating feeder accounts,
-	// airdropping to each, then transferring to the faucet until the target is reached.
-	const LAMPORTS_PER_SOL = 1_000_000_000n;
-	const PER_ACCOUNT_CAP = 10_000n * LAMPORTS_PER_SOL; // 10k SOL per feeder
-	const FEE = 5_000n; // rough fee for legacy transfer
-
-	let remaining = targetLamports - bal;
-	let safety = 0;
-	while (remaining > 0n && safety < 1000) {
-		safety++;
-		const feeder = Keypair.generate();
-		const mint = remaining > PER_ACCOUNT_CAP ? PER_ACCOUNT_CAP : remaining;
-		// Airdrop enough to cover transfer + fee
-		try {
-			svm.airdrop(feeder.publicKey as PublicKey, mint + FEE);
-		} catch {
-			// If airdrop fails, try smaller amount; if still fails, stop
-			try {
-				svm.airdrop(feeder.publicKey as PublicKey, 1_000_000_000n);
-			} catch {
-				break;
-			}
-		}
-
-		// Transfer from feeder -> faucet
-		try {
-			const tx = new Transaction();
-			try {
-				tx.recentBlockhash = svm.latestBlockhash();
-			} catch {}
-			tx.add(
-				SystemProgram.transfer({
-					fromPubkey: feeder.publicKey,
-					toPubkey: faucet.publicKey as PublicKey,
-					lamports: Number(mint),
-				}),
-			);
-			tx.sign(feeder);
-			svm.sendTransaction(tx);
-			remaining -= mint;
-		} catch {}
-	}
-
-	try {
-		bal = svm.getBalance(faucet.publicKey as PublicKey) || 0n;
-	} catch {}
-	return bal;
-}

package/server/lib/instruction-parser.ts

@@ -1,328 +0,0 @@
-import {
-	AddressLookupTableInstruction,
-	ComputeBudgetInstruction,
-	PublicKey,
-	StakeInstruction,
-	SystemInstruction,
-	SystemProgram,
-	TransactionInstruction,
-	VoteInstruction,
-} from "@solana/web3.js";
-import {
-	TOKEN_PROGRAM_ID,
-	ASSOCIATED_TOKEN_PROGRAM_ID,
-	TOKEN_2022_PROGRAM_ID,
-} from "@solana/spl-token";
-import { tryParseSplToken } from "./parsers/spl-token";
-import { tryParseAta } from "./parsers/spl-associated-token-account";
-import { decodeBase58 as _decodeBase58 } from "./base58";
-
-export type ParsedInstruction =
-	| {
-			program: string;
-			programId: string;
-			parsed: { type: string; info: unknown };
-	  }
-	| { programId: string; accounts: string[]; data: string };
-
-function makeIx(
-	programId: string,
-	accountKeys: string[],
-	accounts: number[],
-	dataBase58: string,
-): TransactionInstruction {
-	const keys = accounts.map((i) => ({
-		pubkey: new PublicKey(accountKeys[i] || SystemProgram.programId),
-		isSigner: false,
-		isWritable: false,
-	}));
-	const data = Buffer.from(_decodeBase58(dataBase58));
-	return new TransactionInstruction({
-		programId: new PublicKey(programId),
-		keys,
-		data,
-	});
-}
-
-function ok(
-	program: string,
-	programId: string,
-	type: string,
-	info: unknown,
-): ParsedInstruction {
-	return { program, programId, parsed: { type, info } };
-}
-
-export function parseInstruction(
-    programId: string,
-    accounts: number[],
-    dataBase58: string,
-    accountKeys: string[],
-    tokenBalanceHints?: Array<{ mint: string; decimals: number }>,
-): ParsedInstruction {
-	try {
-		const pid = new PublicKey(programId);
-		const ix = makeIx(programId, accountKeys, accounts, dataBase58);
-
-		// SPL Token (legacy) and Token-2022
-        if (pid.equals(TOKEN_PROGRAM_ID) || pid.equals(TOKEN_2022_PROGRAM_ID)) {
-            const parsed = tryParseSplToken(
-                ix,
-                programId,
-                accountKeys,
-                dataBase58,
-                tokenBalanceHints,
-            );
-            if (parsed) return parsed;
-        }
-
-		// Associated Token Account
-		if (pid.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
-			const parsed = tryParseAta(ix, programId);
-			if (parsed) return parsed;
-		}
-
-		// System Program
-		if (pid.equals(SystemProgram.programId)) {
-			try {
-				const t = SystemInstruction.decodeInstructionType(ix);
-				switch (t) {
-					case "Create": {
-						try {
-							const p = SystemInstruction.decodeCreateAccount(ix);
-							const from = p.fromPubkey.toBase58();
-							const newAcc = p.newAccountPubkey.toBase58();
-							const owner = p.programId.toBase58();
-							return ok("system", programId, "createAccount", {
-								// Explorer-compatible field names
-								source: from,
-								newAccount: newAcc,
-								owner,
-								lamports: Number(p.lamports),
-								space: Number(p.space),
-								// Keep legacy aliases too
-								fromPubkey: from,
-								newAccountPubkey: newAcc,
-								programId: owner,
-							});
-						} catch {
-							return ok("system", programId, "createAccount", {});
-						}
-					}
-					case "Transfer": {
-						try {
-							const p = SystemInstruction.decodeTransfer(ix);
-							return ok("system", programId, "transfer", {
-								source: p.fromPubkey.toBase58(),
-								destination: p.toPubkey.toBase58(),
-								lamports: Number(p.lamports),
-							});
-						} catch {
-							return ok("system", programId, "transfer", {});
-						}
-					}
-					case "TransferWithSeed": {
-						try {
-							const p = SystemInstruction.decodeTransferWithSeed(ix);
-							return ok("system", programId, "transferWithSeed", {
-								fromPubkey: p.fromPubkey.toBase58(),
-								basePubkey: p.basePubkey.toBase58(),
-								toPubkey: p.toPubkey.toBase58(),
-								lamports: Number(p.lamports),
-								seed: p.seed,
-								programId: p.programId.toBase58(),
-							});
-						} catch {
-							return ok("system", programId, "transferWithSeed", {});
-						}
-					}
-					case "Allocate": {
-						try {
-							const p = SystemInstruction.decodeAllocate(ix);
-							return ok("system", programId, "allocate", {
-								accountPubkey: p.accountPubkey.toBase58(),
-								space: Number(p.space),
-							});
-						} catch {
-							return ok("system", programId, "allocate", {});
-						}
-					}
-					case "AllocateWithSeed": {
-						try {
-							const p = SystemInstruction.decodeAllocateWithSeed(ix);
-							return ok("system", programId, "allocateWithSeed", {
-								accountPubkey: p.accountPubkey.toBase58(),
-								basePubkey: p.basePubkey.toBase58(),
-								seed: p.seed,
-								space: Number(p.space),
-								programId: p.programId.toBase58(),
-							});
-						} catch {
-							return ok("system", programId, "allocateWithSeed", {});
-						}
-					}
-					case "Assign": {
-						try {
-							const p = SystemInstruction.decodeAssign(ix);
-							return ok("system", programId, "assign", {
-								accountPubkey: p.accountPubkey.toBase58(),
-								programId: p.programId.toBase58(),
-							});
-						} catch {
-							return ok("system", programId, "assign", {});
-						}
-					}
-					case "AssignWithSeed": {
-						try {
-							const p = SystemInstruction.decodeAssignWithSeed(ix);
-							return ok("system", programId, "assignWithSeed", {
-								accountPubkey: p.accountPubkey.toBase58(),
-								basePubkey: p.basePubkey.toBase58(),
-								seed: p.seed,
-								programId: p.programId.toBase58(),
-							});
-						} catch {
-							return ok("system", programId, "assignWithSeed", {});
-						}
-					}
-					case "InitializeNonceAccount":
-					case "AdvanceNonceAccount":
-					case "WithdrawNonceAccount":
-					case "AuthorizeNonceAccount":
-					case "CreateWithSeed":
-					case "UpgradeNonceAccount": {
-						return ok("system", programId, t, {});
-					}
-					default:
-						return ok("system", programId, t, {});
-				}
-			} catch {
-				// If we cannot even decode the instruction type, fallthrough to raw
-			}
-		}
-
-		// Compute Budget
-		try {
-			const t = ComputeBudgetInstruction.decodeInstructionType(ix);
-			switch (t) {
-				case "SetComputeUnitLimit": {
-					const p = ComputeBudgetInstruction.decodeSetComputeUnitLimit(ix);
-					return ok("computeBudget", programId, "setComputeUnitLimit", {
-						units: Number(p.units),
-					});
-				}
-				case "SetComputeUnitPrice": {
-					const p = ComputeBudgetInstruction.decodeSetComputeUnitPrice(ix);
-					return ok("computeBudget", programId, "setComputeUnitPrice", {
-						microLamports: Number(p.microLamports),
-					});
-				}
-				case "RequestHeapFrame": {
-					const p = ComputeBudgetInstruction.decodeRequestHeapFrame(ix);
-					return ok("computeBudget", programId, "requestHeapFrame", {
-						bytes: Number(p.bytes),
-					});
-				}
-				case "RequestUnits": {
-					const p = ComputeBudgetInstruction.decodeRequestUnits(ix);
-					return ok("computeBudget", programId, "requestUnits", {
-						units: Number(p.units),
-						additionalFee: Number(p.additionalFee),
-					});
-				}
-			}
-		} catch {}
-
-		// Stake
-		try {
-			const t = StakeInstruction.decodeInstructionType(ix);
-			switch (t) {
-				case "Initialize":
-					return ok("stake", programId, "initialize", {});
-				case "Delegate": {
-					const p = StakeInstruction.decodeDelegate(ix);
-					return ok("stake", programId, "delegate", {
-						stakePubkey: p.stakePubkey.toBase58(),
-						votePubkey: p.votePubkey.toBase58(),
-						authorizedPubkey: p.authorizedPubkey.toBase58(),
-					});
-				}
-				case "Authorize": {
-					const p = StakeInstruction.decodeAuthorize(ix);
-					return ok("stake", programId, "authorize", {
-						stakePubkey: p.stakePubkey.toBase58(),
-						authorizedPubkey: p.authorizedPubkey.toBase58(),
-						newAuthorizedPubkey: p.newAuthorizedPubkey.toBase58(),
-						stakeAuthorizationType: p.stakeAuthorizationType.index,
-					});
-				}
-				case "AuthorizeWithSeed":
-					return ok("stake", programId, "authorizeWithSeed", {});
-				case "Split":
-					return ok("stake", programId, "split", {});
-				case "Withdraw":
-					return ok("stake", programId, "withdraw", {});
-				case "Deactivate":
-					return ok("stake", programId, "deactivate", {});
-				case "Merge":
-					return ok("stake", programId, "merge", {});
-			}
-		} catch {}
-
-		// Vote
-		try {
-			const t = VoteInstruction.decodeInstructionType(ix);
-			switch (t) {
-				case "InitializeAccount":
-					return ok("vote", programId, "initialize", {});
-				case "Authorize":
-					return ok("vote", programId, "authorize", {});
-				case "AuthorizeWithSeed":
-					return ok("vote", programId, "authorizeWithSeed", {});
-				case "Withdraw":
-					return ok("vote", programId, "withdraw", {});
-				default:
-					return ok("vote", programId, t, {});
-			}
-		} catch {}
-
-		// Address Lookup Table
-		try {
-			const t = AddressLookupTableInstruction.decodeInstructionType(ix);
-			switch (t) {
-				case "CreateLookupTable":
-				case "ExtendLookupTable":
-				case "CloseLookupTable":
-				case "FreezeLookupTable":
-				case "DeactivateLookupTable":
-					return ok("address-lookup-table", programId, t, {});
-			}
-		} catch {}
-
-		// Memo program: parse utf8 memo if possible
-		if (
-			programId === "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr" ||
-			programId === "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo"
-		) {
-			try {
-				const bytes = _decodeBase58(dataBase58);
-				const memo = new TextDecoder().decode(bytes);
-				return ok("spl-memo", programId, "memo", { memo });
-			} catch {}
-			return ok("spl-memo", programId, "memo", {});
-		}
-
-		// Fallback: unknown program, return raw
-		return {
-			programId,
-			accounts: accounts.map((i) => accountKeys[i] || ""),
-			data: dataBase58,
-		};
-	} catch {
-		return {
-			programId,
-			accounts: accounts.map((i) => accountKeys[i] || ""),
-			data: dataBase58,
-		};
-	}
-}

package/server/lib/parsers/spl-associated-token-account.ts

@@ -1,50 +0,0 @@
-import type { TransactionInstruction } from "@solana/web3.js";
-import { ASSOCIATED_TOKEN_PROGRAM_ID } from "@solana/spl-token";
-
-// Keep shape compatible with instruction-parser
-export type ParsedInstruction =
-	| {
-			program: string;
-			programId: string;
-			parsed: { type: string; info: unknown };
-	  }
-	| { programId: string; accounts: string[]; data: string };
-
-function ok(programId: string, type: string, info: unknown): ParsedInstruction {
-	return {
-		program: "spl-associated-token-account",
-		programId,
-		parsed: { type, info },
-	};
-}
-
-function asBase58(ix: TransactionInstruction, idx: number): string | undefined {
-	try {
-		return ix.keys[idx]?.pubkey?.toBase58();
-	} catch {
-		return undefined;
-	}
-}
-
-export function tryParseAta(
-	ix: TransactionInstruction,
-	programIdStr: string,
-): ParsedInstruction | null {
-	try {
-		if (!ix.programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) return null;
-		// Both create (empty) and createIdempotent ([1]) map to type "create" in explorers
-		const type = "create";
-		// Expected keys: [payer, associatedToken, owner, mint, systemProgram, tokenProgram]
-		const info = {
-			source: asBase58(ix, 0),
-			account: asBase58(ix, 1),
-			wallet: asBase58(ix, 2),
-			mint: asBase58(ix, 3),
-			systemProgram: asBase58(ix, 4),
-			tokenProgram: asBase58(ix, 5),
-		};
-		return ok(programIdStr, type, info);
-	} catch {
-		return null;
-	}
-}