gnoman 0.1.0

package/tests/test_contract_sandbox/sandbox.test.js

@@ -0,0 +1,407 @@
+import test from 'node:test';
+import { strict as assert } from 'node:assert';
+import { tmpdir } from 'os';
+import path from 'path';
+import fs from 'fs';
+import { mkdtempSync, rmSync } from 'fs';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createRequire } from 'module';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const distPath = path.resolve(__dirname, '../../dist/backend/modules/sandbox');
+const require = createRequire(import.meta.url);
+
+const loadModule = async (modulePath) => {
+  const moduleUrl = pathToFileURL(path.join(distPath, modulePath)).href;
+  return import(moduleUrl);
+};
+
+const unwrapDefault = (mod) => {
+  if (!mod) return mod;
+  if (mod.default && typeof mod.default === 'object' && 'default' in mod.default) {
+    return mod.default.default;
+  }
+  return mod.default ?? mod;
+};
+
+const setRpcStub = (responses) => {
+  const { JsonRpcProvider } = require('ethers');
+  const originalSend = JsonRpcProvider.prototype.send;
+  const originalEstimateGas = JsonRpcProvider.prototype.estimateGas;
+  const originalCall = JsonRpcProvider.prototype.call;
+  const originalGetNetwork = JsonRpcProvider.prototype.getNetwork;
+
+  JsonRpcProvider.prototype.send = async function (method, params) {
+    const handler = responses[method];
+    if (!handler) {
+      return originalSend.call(this, method, params);
+    }
+    const result = await handler(params ?? []);
+    if (result && result.error) {
+      const error = new Error(result.error.message);
+      error.code = result.error.code;
+      throw error;
+    }
+    return result;
+  };
+
+  JsonRpcProvider.prototype.estimateGas = async function (request) {
+    const value = await JsonRpcProvider.prototype.send.call(this, 'eth_estimateGas', [request]);
+    return BigInt(value);
+  };
+
+  JsonRpcProvider.prototype.call = async function (request) {
+    return JsonRpcProvider.prototype.send.call(this, 'eth_call', [request]);
+  };
+
+  JsonRpcProvider.prototype.getNetwork = async function () {
+    const chainIdHex = await JsonRpcProvider.prototype.send.call(this, 'eth_chainId', []);
+    return {
+      chainId: BigInt(chainIdHex),
+      name: 'mock-network'
+    };
+  };
+
+  return () => {
+    JsonRpcProvider.prototype.send = originalSend;
+    JsonRpcProvider.prototype.estimateGas = originalEstimateGas;
+    JsonRpcProvider.prototype.call = originalCall;
+    JsonRpcProvider.prototype.getNetwork = originalGetNetwork;
+  };
+};
+
+test('ABI parsing exposes function metadata for parameter forms', async () => {
+  const module = await loadModule('abiLoader.js');
+  const parseAbi = module.parseAbi ?? unwrapDefault(module).parseAbi;
+  const abi = JSON.stringify([
+    {
+      inputs: [
+        { name: 'recipient', type: 'address' },
+        { name: 'amount', type: 'uint256' }
+      ],
+      name: 'transfer',
+      outputs: [{ name: '', type: 'bool' }],
+      stateMutability: 'nonpayable',
+      type: 'function'
+    }
+  ]);
+  const metadata = parseAbi({ abi, name: 'Token' });
+  assert.strictEqual(metadata.name, 'Token');
+  assert.strictEqual(metadata.functions[0].name, 'transfer');
+  assert.strictEqual(metadata.functions[0].inputs.length, 2);
+});
+
+test('Parameter schema generation includes ABI parameters', async () => {
+  const module = await loadModule('formBuilder.js');
+  const buildParameterFields = module.buildParameterFields ?? unwrapDefault(module).buildParameterFields;
+  const metadata = {
+    name: 'Token',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { name: 'recipient', type: 'address' },
+      { name: 'amount', type: 'uint256' }
+    ]
+  };
+  const schema = buildParameterFields(metadata);
+  assert.strictEqual(schema.length, 2);
+  assert.strictEqual(schema[0].name, 'recipient');
+  assert.strictEqual(schema[1].placeholder, 'uint256');
+});
+
+test('Static simulation captures gas estimate and decoded return data', async () => {
+  const module = await loadModule('contractSimulator.js');
+  const simulateContractCall = module.simulateContractCall ?? unwrapDefault(module).simulateContractCall;
+  const { Interface } = require('ethers');
+  const abi = [
+    'function getValue(uint256 key) view returns (uint256)'
+  ];
+  const iface = new Interface(abi);
+  const encodedResult = iface.encodeFunctionResult('getValue', [42n]);
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () => encodedResult,
+    debug_traceCall: async () => ({ gas: '0x5208' })
+  });
+
+  const metadata = {
+    name: 'KVStore',
+    abi,
+    functions: [
+      {
+        name: 'getValue',
+        stateMutability: 'view',
+        inputs: [{ name: 'key', type: 'uint256' }],
+        outputs: [{ name: '', type: 'uint256' }],
+        payable: false,
+        constant: true
+      }
+    ]
+  };
+
+  const result = await simulateContractCall(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000001',
+    functionName: 'getValue',
+    parameters: { key: '0x0' },
+    value: '0x0'
+  });
+
+  restore();
+
+  assert.strictEqual(result.success, true);
+  assert.strictEqual(result.gasEstimate, '21000');
+  assert.deepStrictEqual(Array.from(result.decodedReturnData), [42n]);
+  assert.strictEqual(result.callData.startsWith('0x'), true);
+  assert.strictEqual(result.value, '0x0');
+});
+
+test('Simulation failure captures revert reason', async () => {
+  const module = await loadModule('contractSimulator.js');
+  const simulateContractCall = module.simulateContractCall ?? unwrapDefault(module).simulateContractCall;
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () => ({ error: { code: 3, message: 'execution reverted: TEST' } }),
+    debug_traceCall: async () => ({})
+  });
+
+  const abi = [
+    'function fail() view returns (bool)'
+  ];
+
+  const metadata = {
+    name: 'Fail',
+    abi,
+    functions: [
+      {
+        name: 'fail',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'bool' }],
+        payable: false,
+        constant: true
+      }
+    ]
+  };
+
+  const result = await simulateContractCall(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000002',
+    functionName: 'fail',
+    parameters: {}
+  });
+
+  restore();
+
+  assert.strictEqual(result.success, false);
+  assert.ok(result.revertReason?.includes('execution'));
+});
+
+test('Sandbox manager logs simulations and recovers history', async () => {
+  const SandboxManager = unwrapDefault(await loadModule('sandboxManager.js'));
+  const { parseAbi } = await loadModule('abiLoader.js');
+  const tempDir = mkdtempSync(path.join(tmpdir(), 'sandbox-'));
+
+  const abi = JSON.stringify([
+    {
+      inputs: [],
+      name: 'ping',
+      outputs: [{ name: '', type: 'bool' }],
+      stateMutability: 'view',
+      type: 'function'
+    }
+  ]);
+
+  const metadata = parseAbi({ abi, name: 'Ping' });
+
+  const encodedReturn = '0x0000000000000000000000000000000000000000000000000000000000000001';
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x5',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () => encodedReturn,
+    debug_traceCall: async () => ({})
+  });
+
+  const manager = new SandboxManager(tempDir);
+  const result = await manager.simulate(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000003',
+    functionName: 'ping',
+    parameters: {}
+  });
+  restore();
+
+  assert.ok(result.success);
+  assert.strictEqual(manager.getHistory().length, 1);
+
+  const persistedFiles = fs.readdirSync(tempDir).filter((file) => file.endsWith('.json'));
+  assert.strictEqual(persistedFiles.length, 1);
+  const logContent = JSON.parse(fs.readFileSync(path.join(tempDir, persistedFiles[0]), 'utf8'));
+  assert.strictEqual(logContent.rpcUrl, 'http://localhost:8545');
+
+  const revived = new SandboxManager(tempDir);
+  assert.strictEqual(revived.getHistory().length, 1);
+
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+test('Safe simulation encodes parameters and returns SafeTx-like data', async () => {
+  const SandboxManager = unwrapDefault(await loadModule('sandboxManager.js'));
+  const tempDir = mkdtempSync(path.join(tmpdir(), 'safe-'));
+  const manager = new SandboxManager(tempDir);
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () => '0x0000000000000000000000000000000000000000000000000000000000000000',
+    debug_traceCall: async () => ({})
+  });
+
+  const result = await manager.simulateSafe({
+    rpcUrl: 'http://localhost:8545',
+    safeAddress: '0x0000000000000000000000000000000000000004',
+    functionName: 'isOwner',
+    parameters: { owner: '0x0000000000000000000000000000000000000005' }
+  });
+
+  restore();
+  assert.ok(result.callData.startsWith('0x'));
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+test('Fork mode uses alternate RPC endpoint when active', async () => {
+  const SandboxManager = unwrapDefault(await loadModule('sandboxManager.js'));
+  const tempDir = mkdtempSync(path.join(tmpdir(), 'fork-'));
+  const manager = new SandboxManager(tempDir);
+
+  const forkReturn = '0x000000000000000000000000000000000000000000000000000000000000002a';
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () => forkReturn,
+    debug_traceCall: async () => ({})
+  });
+
+  manager['fork'].getStatus = () => ({ active: true, rpcUrl: 'http://localhost:1111' });
+
+  const metadata = {
+    name: 'Counter',
+    abi: ['function value() view returns (uint256)'],
+    functions: [
+      {
+        name: 'value',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+        payable: false,
+        constant: true
+      }
+    ]
+  };
+
+  const result = await manager.simulate(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000006',
+    functionName: 'value',
+    parameters: {},
+    fork: true
+  });
+
+  restore();
+  assert.strictEqual(result.forkMode, true);
+  assert.strictEqual(result.rpcUrl, 'http://localhost:1111');
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+test('Fork simulations fall back to provided RPC URL when no local fork is active', async () => {
+  const SandboxManager = unwrapDefault(await loadModule('sandboxManager.js'));
+  const tempDir = mkdtempSync(path.join(tmpdir(), 'remote-fork-'));
+  const manager = new SandboxManager(tempDir);
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () =>
+      '0x000000000000000000000000000000000000000000000000000000000000002a',
+    debug_traceCall: async () => ({})
+  });
+
+  manager['fork'].getStatus = () => ({ active: false });
+
+  const metadata = {
+    name: 'Counter',
+    abi: ['function value() view returns (uint256)'],
+    functions: [
+      {
+        name: 'value',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+        payable: false,
+        constant: true
+      }
+    ]
+  };
+
+  const result = await manager.simulate(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000006',
+    functionName: 'value',
+    parameters: {},
+    fork: true,
+    forkRpcUrl: 'http://127.0.0.1:9090'
+  });
+
+  restore();
+  assert.strictEqual(result.forkMode, true);
+  assert.strictEqual(result.rpcUrl, 'http://127.0.0.1:9090');
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+test('Fork flag gracefully degrades when no fork configuration is available', async () => {
+  const SandboxManager = unwrapDefault(await loadModule('sandboxManager.js'));
+  const tempDir = mkdtempSync(path.join(tmpdir(), 'no-fork-'));
+  const manager = new SandboxManager(tempDir);
+
+  const restore = setRpcStub({
+    eth_chainId: async () => '0x1',
+    eth_estimateGas: async () => '0x5208',
+    eth_call: async () =>
+      '0x000000000000000000000000000000000000000000000000000000000000002a',
+    debug_traceCall: async () => ({})
+  });
+
+  manager['fork'].getStatus = () => ({ active: false });
+
+  const metadata = {
+    name: 'Counter',
+    abi: ['function value() view returns (uint256)'],
+    functions: [
+      {
+        name: 'value',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+        payable: false,
+        constant: true
+      }
+    ]
+  };
+
+  const result = await manager.simulate(metadata, {
+    rpcUrl: 'http://localhost:8545',
+    contractAddress: '0x0000000000000000000000000000000000000006',
+    functionName: 'value',
+    parameters: {},
+    fork: true
+  });
+
+  restore();
+  assert.strictEqual(result.forkMode, false);
+  assert.strictEqual(result.rpcUrl, 'http://localhost:8545');
+  rmSync(tempDir, { recursive: true, force: true });
+});

package/tests/walletController.test.ts

@@ -0,0 +1,57 @@
+import type { Request, Response } from 'express';
+
+jest.mock('../backend/services/walletService', () => ({
+  importWalletFromMnemonic: jest.fn(async (payload: unknown) => payload)
+}));
+
+import { importWalletFromMnemonic } from '../backend/services/walletService';
+import { importMnemonic } from '../backend/controllers/walletController';
+
+const mockedImportWalletFromMnemonic = importWalletFromMnemonic as jest.MockedFunction<
+  typeof importWalletFromMnemonic
+>;
+
+describe('walletController importMnemonic', () => {
+  afterEach(() => {
+    mockedImportWalletFromMnemonic.mockClear();
+  });
+
+  it('accepts derivationPath field from request body', async () => {
+    const req = {
+      body: {
+        mnemonic: 'test test test test test test test test test test test junk',
+        alias: 'alpha',
+        password: 'pw',
+        derivationPath: "m/44'/60'/0'/0/7",
+        hidden: true
+      }
+    } as Request;
+    const json = jest.fn();
+    const res = { json } as unknown as Response;
+
+    await importMnemonic(req, res, jest.fn());
+
+    expect(mockedImportWalletFromMnemonic).toHaveBeenCalledWith(
+      expect.objectContaining({ derivationPath: "m/44'/60'/0'/0/7" })
+    );
+    expect(json).toHaveBeenCalled();
+  });
+
+  it('falls back to legacy path field when derivationPath is not provided', async () => {
+    const req = {
+      body: {
+        mnemonic: 'test test test test test test test test test test test junk',
+        path: "m/44'/60'/0'/0/3"
+      }
+    } as Request;
+    const json = jest.fn();
+    const res = { json } as unknown as Response;
+
+    await importMnemonic(req, res, jest.fn());
+
+    expect(mockedImportWalletFromMnemonic).toHaveBeenCalledWith(
+      expect.objectContaining({ derivationPath: "m/44'/60'/0'/0/3" })
+    );
+    expect(json).toHaveBeenCalled();
+  });
+});

package/touch

@@ -0,0 +1,14 @@
+[Unit]
+Description=Gnomon Backend
+After=network.target
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/gnoman2.0
+Environment=NODE_ENV=production
+ExecStart=/usr/bin/node /opt/gnoman2.0/dist/backend/backend/index.js
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target

package/tsconfig.backend.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/backend"
+  },
+  "include": ["backend/**/*.ts", "backend/types/**/*.d.ts", "modules/**/*.ts", "src/**/*.ts", "cli/**/*.ts"]
+}

package/tsconfig.cli.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/cli"
+  },
+  "include": ["cli/**/*.ts", "src/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "lib": ["ES2020", "DOM"],
+    "strict": true,
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "types": ["node", "cors", "better-sqlite3", "jest"],
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "sourceMap": true,
+    "outDir": "dist"
+  },
+  "exclude": ["renderer", "node_modules", "dist"]
+}

package/tsconfig.main.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist/main"
+  },
+  "include": ["main/**/*.ts", "src/**/*.ts"]
+}

package/webhook-shim.js

@@ -0,0 +1,50 @@
+cd ~/Apps/Github/gnoman2.0
+cat > webhook-shim.js <<'EOF'
+const express = require("express");
+const crypto = require("crypto");
+
+const app = express();
+
+const VERIFY_TOKEN = process.env.FB_VERIFY_TOKEN || "change-me";
+const APP_SECRET = process.env.FB_APP_SECRET || "";
+
+app.use(express.json({
+  verify: (req, res, buf) => { req.rawBody = buf; }
+}));
+
+app.get("/webhook", (req, res) => {
+  const mode = req.query["hub.mode"];
+  const token = req.query["hub.verify_token"];
+  const challenge = req.query["hub.challenge"];
+
+  if (mode === "subscribe" && token === VERIFY_TOKEN) {
+    console.log("WEBHOOK_VERIFIED");
+    return res.status(200).send(challenge);
+  }
+  return res.sendStatus(403);
+});
+
+function validSig(req) {
+  if (!APP_SECRET) return true; // allow if you haven't set secret yet
+  const sig = req.headers["x-hub-signature-256"];
+  if (!sig) return false;
+
+  const expected = crypto.createHmac("sha256", APP_SECRET).update(req.rawBody).digest("hex");
+  return sig === `sha256=${expected}`;
+}
+
+app.post("/webhook", async (req, res) => {
+  if (!validSig(req)) return res.sendStatus(403);
+
+  // Log payload so you KNOW it is arriving
+  console.log("WEBHOOK_EVENT:", JSON.stringify(req.body));
+
+  // Return fast (Meta requires <= 5s)
+  return res.status(200).send("EVENT_RECEIVED");
+});
+
+app.listen(4455, "127.0.0.1", () => {
+  console.log("Webhook shim listening on http://127.0.0.1:4455/webhook");
+});
+EOF
+node webhook-shim.js