solana-mint-recovery-engine 1.0.0

package/dist/src/io/rpc.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcAdapter = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+/**
+ * Adapter class to query Solana RPC node.
+ */
+class RpcAdapter {
+    connection;
+    constructor(rpcUrl, commitment = 'confirmed') {
+        this.connection = new web3_js_1.Connection(rpcUrl, commitment);
+    }
+    /**
+     * Fetches the latest blockhash from the RPC.
+     */
+    async getLatestBlockhash() {
+        const { blockhash } = await this.connection.getLatestBlockhash();
+        return blockhash;
+    }
+    /**
+     * Submits a serialized transaction to the network.
+     */
+    async submitTransaction(rawTransactionBuf) {
+        return await this.connection.sendRawTransaction(rawTransactionBuf, {
+            skipPreflight: false,
+            preflightCommitment: 'confirmed',
+        });
+    }
+    /**
+     * Simulates a transaction.
+     */
+    async simulateTransaction(rawTransactionBuf) {
+        // For web3.js v1, we simulate using standard connection
+        const base64Tx = rawTransactionBuf.toString('base64');
+        const res = await this.connection.simulateTransaction(
+        // We can pass the raw transaction using simulateTransaction helper
+        // or directly invoke the RPC method.
+        // In web3.js v1, Connection.simulateTransaction expects a Transaction object,
+        // but we can decode a versioned transaction or legacy transaction.
+        // A safe way is to send the raw transaction directly via JSON-RPC.
+        // @ts-ignore
+        {
+        // Connection.simulateTransaction signature takes a Transaction
+        // But we can also simulate raw transactions by calling the low level RPC.
+        });
+        // Let's implement simulation using direct JSON-RPC to support VersionedTransactions perfectly:
+        // @ts-ignore
+        const rpcResponse = await this.connection._rpcRequest('simulateTransaction', [
+            base64Tx,
+            { encoding: 'base64', commitment: 'confirmed', replaceRecentBlockhash: true }
+        ]);
+        if (rpcResponse.error) {
+            throw new Error(`Simulation request failed: ${rpcResponse.error.message}`);
+        }
+        return rpcResponse.result;
+    }
+    /**
+     * Inspects a Solana token or mint account.
+     */
+    async inspectAccount(address) {
+        const accountInfo = await this.connection.getAccountInfo(address);
+        if (!accountInfo) {
+            throw new Error(`Account ${address.toBase58()} does not exist on-chain.`);
+        }
+        const ownerProgram = accountInfo.owner;
+        const isToken2022 = ownerProgram.equals(spl_token_1.TOKEN_2022_PROGRAM_ID);
+        const isLegacyToken = ownerProgram.equals(spl_token_1.TOKEN_PROGRAM_ID);
+        if (!isToken2022 && !isLegacyToken) {
+            throw new Error(`Account ${address.toBase58()} is owned by ${ownerProgram.toBase58()}, not a recognized Token Program.`);
+        }
+        const dataSize = accountInfo.data.length;
+        const balance = BigInt(accountInfo.lamports);
+        // Identify account type by data size
+        if (dataSize === spl_token_1.AccountLayout.span || (dataSize > spl_token_1.AccountLayout.span && isToken2022)) {
+            // Decode Token Account
+            try {
+                const decoded = spl_token_1.AccountLayout.decode(accountInfo.data.slice(0, spl_token_1.AccountLayout.span));
+                return {
+                    address,
+                    type: 'token-account',
+                    ownerProgram,
+                    balance,
+                    dataSize,
+                    authority: new web3_js_1.PublicKey(decoded.owner),
+                    isToken2022,
+                };
+            }
+            catch (err) {
+                throw new Error(`Failed to decode Token Account layout: ${err.message}`);
+            }
+        }
+        else if (dataSize === spl_token_1.MintLayout.span || (dataSize > spl_token_1.MintLayout.span && isToken2022)) {
+            // Decode Mint Account
+            try {
+                const decoded = spl_token_1.MintLayout.decode(accountInfo.data.slice(0, spl_token_1.MintLayout.span));
+                const mintAuthority = decoded.mintAuthorityOption !== 0
+                    ? new web3_js_1.PublicKey(decoded.mintAuthority)
+                    : null;
+                return {
+                    address,
+                    type: 'mint',
+                    ownerProgram,
+                    balance,
+                    dataSize,
+                    authority: mintAuthority,
+                    isToken2022,
+                };
+            }
+            catch (err) {
+                throw new Error(`Failed to decode Mint Account layout: ${err.message}`);
+            }
+        }
+        else if (dataSize === spl_token_1.MultisigLayout.span) {
+            // Decode Multisig Account
+            try {
+                const decoded = spl_token_1.MultisigLayout.decode(accountInfo.data);
+                // Extract threshold and signers list
+                const threshold = decoded.m;
+                const numSigners = decoded.n;
+                // MultisigLayout decodes signer1..signer11. Gather them into an array.
+                const allSigners = [
+                    decoded.signer1,
+                    decoded.signer2,
+                    decoded.signer3,
+                    decoded.signer4,
+                    decoded.signer5,
+                    decoded.signer6,
+                    decoded.signer7,
+                    decoded.signer8,
+                    decoded.signer9,
+                    decoded.signer10,
+                    decoded.signer11,
+                ];
+                const signers = allSigners.slice(0, numSigners).map(s => new web3_js_1.PublicKey(s));
+                return {
+                    address,
+                    type: 'multisig',
+                    ownerProgram,
+                    balance,
+                    dataSize,
+                    authority: address, // The multisig account authority is itself
+                    multisigSigners: signers,
+                    multisigThreshold: threshold,
+                    isToken2022,
+                };
+            }
+            catch (err) {
+                throw new Error(`Failed to decode Multisig Account layout: ${err.message}`);
+            }
+        }
+        throw new Error(`Unknown account data size: ${dataSize} bytes. Cannot determine token account type.`);
+    }
+}
+exports.RpcAdapter = RpcAdapter;

package/dist/src/signers/signer.d.ts

@@ -0,0 +1,22 @@
+import { Keypair, PublicKey, Transaction } from '@solana/web3.js';
+export interface Signer {
+    getPublicKey(): PublicKey;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+}
+export declare class KeypairSigner implements Signer {
+    private keypair;
+    constructor(keypair: Keypair);
+    getPublicKey(): PublicKey;
+    signTransaction(transaction: Transaction): Promise<Transaction>;
+}
+/**
+ * Resolves home directory shorthand (~) in file paths.
+ */
+export declare function resolveHome(filePath: string): string;
+/**
+ * Loads a Keypair from various potential sources:
+ * 1. Raw Base58 private key string
+ * 2. JSON secret key array file path
+ * 3. Environment variable override
+ */
+export declare function loadKeypair(secretOrPath: string): Keypair;

package/dist/src/signers/signer.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeypairSigner = void 0;
+exports.resolveHome = resolveHome;
+exports.loadKeypair = loadKeypair;
+const web3_js_1 = require("@solana/web3.js");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const bs58_1 = __importDefault(require("bs58"));
+class KeypairSigner {
+    keypair;
+    constructor(keypair) {
+        this.keypair = keypair;
+    }
+    getPublicKey() {
+        return this.keypair.publicKey;
+    }
+    async signTransaction(transaction) {
+        transaction.partialSign(this.keypair);
+        return transaction;
+    }
+}
+exports.KeypairSigner = KeypairSigner;
+/**
+ * Resolves home directory shorthand (~) in file paths.
+ */
+function resolveHome(filePath) {
+    if (filePath.startsWith('~')) {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+/**
+ * Loads a Keypair from various potential sources:
+ * 1. Raw Base58 private key string
+ * 2. JSON secret key array file path
+ * 3. Environment variable override
+ */
+function loadKeypair(secretOrPath) {
+    // Check if it's a file path
+    const resolvedPath = resolveHome(secretOrPath);
+    if (fs.existsSync(resolvedPath)) {
+        try {
+            const fileContent = fs.readFileSync(resolvedPath, 'utf8').trim();
+            if (fileContent.startsWith('[') && fileContent.endsWith(']')) {
+                const secretKey = Uint8Array.from(JSON.parse(fileContent));
+                return web3_js_1.Keypair.fromSecretKey(secretKey);
+            }
+            else {
+                // Try decoding as base58 from file
+                const secretKey = bs58_1.default.decode(fileContent);
+                return web3_js_1.Keypair.fromSecretKey(secretKey);
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to parse keypair file at ${secretOrPath}: ${err.message}`);
+        }
+    }
+    // If not a file, check if it looks like a JSON array string directly
+    if (secretOrPath.startsWith('[') && secretOrPath.endsWith(']')) {
+        try {
+            const secretKey = Uint8Array.from(JSON.parse(secretOrPath));
+            return web3_js_1.Keypair.fromSecretKey(secretKey);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse raw keypair array: ${err.message}`);
+        }
+    }
+    // Otherwise, try parsing as a direct base58 private key string
+    try {
+        const secretKey = bs58_1.default.decode(secretOrPath);
+        return web3_js_1.Keypair.fromSecretKey(secretKey);
+    }
+    catch (err) {
+        throw new Error(`Invalid keypair format. Must be a valid file path, JSON array, or base58 string.`);
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "solana-mint-recovery-engine",
+  "version": "1.0.0",
+  "description": "Solana Mint & Token Account Recovery Engine (SMRE) CLI tool",
+  "main": "dist/src/index.js",
+  "bin": {
+    "smre": "./dist/bin/smre.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node bin/smre.ts",
+    "test": "ts-node tests/run.ts",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@solana/spl-token": "^0.4.8",
+    "@solana/web3.js": "^1.95.3",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^11.1.0",
+    "dotenv": "^16.4.5",
+    "ora": "^5.4.1",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  }
+}