solforge 0.2.6 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solforge",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "module": "index.ts",
   "type": "module",
   "private": false,

package/server/lib/instruction-parser.ts

@@ -0,0 +1,242 @@
+import {
+  AddressLookupTableInstruction,
+  ComputeBudgetInstruction,
+  PublicKey,
+  StakeInstruction,
+  SystemInstruction,
+  SystemProgram,
+  TransactionInstruction,
+  VoteInstruction,
+} from "@solana/web3.js";
+import { decodeBase58 as _decodeBase58 } from "./base58";
+
+export type ParsedInstruction =
+  | { program: string; programId: string; parsed: { type: string; info: any } }
+  | { 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: any): ParsedInstruction {
+  return { program, programId, parsed: { type, info } };
+}
+
+export function parseInstruction(
+  programId: string,
+  accounts: number[],
+  dataBase58: string,
+  accountKeys: string[],
+): ParsedInstruction {
+  try {
+    const pid = new PublicKey(programId);
+    const ix = makeIx(programId, accountKeys, accounts, dataBase58);
+
+    // System Program
+    if (pid.equals(SystemProgram.programId)) {
+      const t = SystemInstruction.decodeInstructionType(ix);
+      switch (t) {
+        case "Create": {
+          const p = SystemInstruction.decodeCreateAccount(ix);
+          return ok("system", programId, "createAccount", {
+            fromPubkey: p.fromPubkey.toBase58(),
+            newAccountPubkey: p.newAccountPubkey.toBase58(),
+            lamports: Number(p.lamports),
+            space: Number(p.space),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "Transfer": {
+          const p = SystemInstruction.decodeTransfer(ix);
+          return ok("system", programId, "transfer", {
+            source: p.fromPubkey.toBase58(),
+            destination: p.toPubkey.toBase58(),
+            lamports: Number(p.lamports),
+          });
+        }
+        case "TransferWithSeed": {
+          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(),
+          });
+        }
+        case "Allocate": {
+          const p = SystemInstruction.decodeAllocate(ix);
+          return ok("system", programId, "allocate", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            space: Number(p.space),
+          });
+        }
+        case "AllocateWithSeed": {
+          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(),
+          });
+        }
+        case "Assign": {
+          const p = SystemInstruction.decodeAssign(ix);
+          return ok("system", programId, "assign", {
+            accountPubkey: p.accountPubkey.toBase58(),
+            programId: p.programId.toBase58(),
+          });
+        }
+        case "AssignWithSeed": {
+          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(),
+          });
+        }
+        case "InitializeNonceAccount":
+        case "AdvanceNonceAccount":
+        case "WithdrawNonceAccount":
+        case "AuthorizeNonceAccount":
+        case "CreateWithSeed":
+        case "UpgradeNonceAccount": {
+          // For brevity: rely on type only; details can be added if needed
+          return ok("system", programId, t, {});
+        }
+        default:
+          break;
+      }
+    }
+
+    // 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/methods/account/request-airdrop.ts

@@ -6,12 +6,13 @@ import {
 	VersionedTransaction,
 } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
 
 /**
  * Implements the requestAirdrop RPC method
  * @see https://docs.solana.com/api/http#requestairdrop
  */
-export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
+export const requestAirdrop: RpcMethodHandler = async (id, params, context) => {
 	const [pubkeyStr, lamports, _config] = params || [];
 
 	try {
@@ -68,20 +69,48 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 			: Array.isArray(msg.accountKeys)
 				? (msg.accountKeys as unknown[])
 				: [];
-		const staticKeys = rawKeys.map((k) => {
-			try {
-				return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
-			} catch {
-				return faucet.publicKey;
-			}
-		});
-		const preBalances = staticKeys.map((pk) => {
-			try {
-				return Number(context.svm.getBalance(pk));
-			} catch {
-				return 0;
-			}
-		});
+        const staticKeys = rawKeys.map((k) => {
+            try {
+                return typeof k === "string" ? new PublicKey(k) : (k as PublicKey);
+            } catch {
+                return faucet.publicKey;
+            }
+        });
+        const preBalances = staticKeys.map((pk) => {
+            try {
+                return Number(context.svm.getBalance(pk));
+            } catch {
+                return 0;
+            }
+        });
+        const preAccountStates = staticKeys.map((pk) => {
+            try {
+                const addr = pk.toBase58();
+                const acc = context.svm.getAccount(pk);
+                if (!acc) return { address: addr, pre: null } as const;
+                return {
+                    address: addr,
+                    pre: {
+                        lamports: Number(acc.lamports || 0n),
+                        ownerProgram: new PublicKey(acc.owner).toBase58(),
+                        executable: !!acc.executable,
+                        rentEpoch: Number(acc.rentEpoch || 0),
+                        dataLen: acc.data?.length ?? 0,
+                        dataBase64: undefined,
+                        lastSlot: Number(context.slot),
+                    },
+                } as const;
+            } catch {
+                return { address: pk.toBase58(), pre: null } as const;
+            }
+        });
+        try {
+            if (process.env.DEBUG_TX_CAPTURE === "1") {
+                console.debug(
+                    `[tx-capture] pre snapshots: keys=${staticKeys.length} captured=${preAccountStates.length}`,
+                );
+            }
+        } catch {}
 		const toIndex = staticKeys.findIndex((pk) => pk.equals(toPubkey));
 		const beforeTo =
 			toIndex >= 0
@@ -94,60 +123,58 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 						}
 					})();
 
-		const sendResult = context.svm.sendTransaction(tx);
-		// Surface errors to aid debugging
-		try {
-			const rawErr = (sendResult as { err?: unknown }).err;
-			const maybeErr =
-				typeof rawErr === "function" ? (rawErr as () => unknown)() : rawErr;
-			if (maybeErr) {
-				let logsForErr: string[] = [];
-				try {
-					const sr = sendResult as {
-						logs?: () => string[];
-						meta?: () => { logs?: () => string[] } | undefined;
-					};
-					if (typeof sr?.logs === "function") logsForErr = sr.logs();
-					else if (typeof sr?.meta === "function") {
-						const m = sr.meta();
-						const lg = m?.logs;
-						if (typeof lg === "function") logsForErr = lg();
-					}
-				} catch {}
-				console.warn(
-					"[requestAirdrop] transfer failed. err=",
-					maybeErr,
-					" logs=\n",
-					logsForErr.join("\n"),
-				);
-			}
-		} catch {}
+        // Send via standard sendTransaction RPC to unify capture + persistence
+        const rawB64 = Buffer.from(tx.serialize()).toString("base64");
+        const resp = await (sendTxRpc as RpcMethodHandler)(id, [rawB64], context);
+        if ((resp as any)?.error) return resp;
+        // Surface errors to aid debugging
+        const sendResult = undefined as unknown as { err?: unknown };
+        // Any send errors would have been returned by send-transaction already
 
-		let signature = tx.signatures[0]
-			? context.encodeBase58(tx.signatures[0])
-			: context.encodeBase58(new Uint8Array(64).fill(0));
-		context.notifySignature(signature);
-		// Compute post balances and capture logs if available for explorer detail view
-		let postBalances = staticKeys.map((pk) => {
-			try {
-				return Number(context.svm.getBalance(pk));
-			} catch {
-				return 0;
-			}
-		});
-		let logs: string[] = [];
-		try {
-			const sr = sendResult as {
-				logs?: () => string[];
-				meta?: () => { logs?: () => string[] } | undefined;
-			};
-			if (typeof sr?.logs === "function") logs = sr.logs();
-			else if (typeof sr?.meta === "function") {
-				const m = sr.meta();
-				const lg = m?.logs;
-				if (typeof lg === "function") logs = lg();
-			}
-		} catch {}
+        let signature = String((resp as any)?.result || "");
+        if (!signature) {
+            signature = tx.signatures[0]
+                ? context.encodeBase58(tx.signatures[0])
+                : context.encodeBase58(new Uint8Array(64).fill(0));
+        }
+        try { context.notifySignature(signature); } catch {}
+        // Compute post balances and capture logs if available for explorer detail view
+        let postBalances = staticKeys.map((pk) => {
+            try {
+                return Number(context.svm.getBalance(pk));
+            } catch {
+                return 0;
+            }
+        });
+        const postAccountStates = staticKeys.map((pk) => {
+            try {
+                const addr = pk.toBase58();
+                const acc = context.svm.getAccount(pk);
+                if (!acc) return { address: addr, post: null } as const;
+                return {
+                    address: addr,
+                    post: {
+                        lamports: Number(acc.lamports || 0n),
+                        ownerProgram: new PublicKey(acc.owner).toBase58(),
+                        executable: !!acc.executable,
+                        rentEpoch: Number(acc.rentEpoch || 0),
+                        dataLen: acc.data?.length ?? 0,
+                        dataBase64: undefined,
+                        lastSlot: Number(context.slot),
+                    },
+                } as const;
+            } catch {
+                return { address: pk.toBase58(), post: null } as const;
+            }
+        });
+        try {
+            if (process.env.DEBUG_TX_CAPTURE === "1") {
+                console.debug(
+                    `[tx-capture] post snapshots: keys=${staticKeys.length} captured=${postAccountStates.length}`,
+                );
+            }
+        } catch {}
+        // Parsing, recording etc. are performed by send-transaction
 		// Verify recipient received lamports; retry once if not
 		const afterTo =
 			toIndex >= 0
@@ -207,22 +234,18 @@ export const requestAirdrop: RpcMethodHandler = (id, params, context) => {
 		}
 
 		// Try to capture error again for accurate status reporting
-		let recErr: unknown = null;
-		try {
-			const rawErrFun = (sendResult as { err?: unknown }).err;
-			recErr =
-				typeof rawErrFun === "function"
-					? (rawErrFun as () => unknown)()
-					: rawErrFun;
-		} catch {}
-		context.recordTransaction(signature, tx, {
-			logs,
-			fee: 5000,
-			blockTime: Math.floor(Date.now() / 1000),
-			preBalances,
-			postBalances,
-			err: recErr,
-		});
+        // No additional error capture; send-transaction has already recorded it
+        // Pre/post snapshots are still useful for account cache; we can upsert
+        try {
+            const snapshots = new Map<string, { pre?: any; post?: any }>();
+            for (const s of preAccountStates) snapshots.set(s.address, { pre: s.pre || null });
+            for (const s of postAccountStates) {
+                const e = snapshots.get(s.address) || {};
+                e.post = s.post || null;
+                snapshots.set(s.address, e);
+            }
+            // Not persisted here; DB already has the transaction via send-transaction
+        } catch {}
 
 		return context.createSuccessResponse(id, signature);
 	} catch (error: unknown) {

package/server/methods/admin/mint-to.ts

@@ -16,6 +16,7 @@ import {
 	VersionedTransaction,
 } from "@solana/web3.js";
 import type { RpcMethodHandler } from "../../types";
+import { sendTransaction as sendTxRpc } from "../transaction/send-transaction";
 
 // Mint via a real SPL Token transaction signed by faucet (must be mint authority)
 export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
@@ -148,16 +149,15 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			}
 		} catch {}
 
-		// Send transaction via svm
-		const _res = context.svm.sendTransaction(vtx);
-		// Compute signature (base58) from the signed transaction
-		let signatureStr = "";
-		try {
-			const sigBytes = vtx.signatures?.[0];
-			if (sigBytes)
-				signatureStr = context.encodeBase58(new Uint8Array(sigBytes));
-		} catch {}
-		if (!signatureStr) signatureStr = `mint:${ata.toBase58()}:${Date.now()}`;
+        // Send via the standard RPC sendTransaction path to unify capture/parsing
+        const rawBase64ForRpc = Buffer.from(vtx.serialize()).toString("base64");
+        const rpcResp = await (sendTxRpc as RpcMethodHandler)(
+            id,
+            [rawBase64ForRpc],
+            context,
+        );
+        if ((rpcResp as any)?.error) return rpcResp;
+        const signatureStr = String((rpcResp as any)?.result || "");
 
 		// Token balance deltas (pre/post) for ATA
 		type UiTokenAmount = {
@@ -229,34 +229,7 @@ export const solforgeMintTo: RpcMethodHandler = async (id, params, context) => {
 			];
 		} catch {}
 
-		// Insert into DB for explorer via context.recordTransaction for richer details
-		try {
-			const rawBase64 = Buffer.from(vtx.serialize()).toString("base64");
-			const postBalances = trackedKeys.map((pk) => {
-				try {
-					return Number(context.svm.getBalance(pk) || 0n);
-				} catch {
-					return 0;
-				}
-			});
-			const logs: string[] = ["spl-token mintToChecked"];
-			try {
-				(vtx as unknown as { serialize: () => Uint8Array }).serialize = () =>
-					Buffer.from(rawBase64, "base64");
-			} catch {}
-			context.recordTransaction(signatureStr, vtx, {
-				logs,
-				fee: 0,
-				blockTime: Math.floor(Date.now() / 1000),
-				preBalances,
-				postBalances,
-				preTokenBalances,
-				postTokenBalances,
-			});
-		} catch {}
-		try {
-			context.notifySignature(signatureStr);
-		} catch {}
+        // send-transaction already records/announces signature and persists to DB
 
 		return context.createSuccessResponse(id, {
 			ok: true,