gnoman 0.1.0

package/gnoman2.0/tests/robinhoodClient.test.ts

@@ -0,0 +1,54 @@
+import crypto from 'crypto';
+import { signRobinhoodRequest } from '../backend/services/robinhood/auth';
+import { RobinhoodCryptoClient } from '../backend/services/robinhood/client';
+import { RobinhoodUnofficialClient } from '../backend/services/robinhood/unofficialClient';
+
+describe('Robinhood templates', () => {
+  it('signRobinhoodRequest returns signed headers', () => {
+    const { privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    const headers = signRobinhoodRequest({
+      apiKey: 'key_123',
+      privateKey: privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(),
+      method: 'POST',
+      path: '/v1/orders',
+      body: '{"foo":"bar"}',
+      timestamp: 1700000000000,
+    });
+
+    expect(headers['x-api-key']).toBe('key_123');
+    expect(headers['x-timestamp']).toBe('1700000000000');
+    expect(headers['x-signature']).toEqual(expect.any(String));
+    expect(headers['x-signature'].length).toBeGreaterThan(10);
+  });
+
+  it('retries on 429 and eventually succeeds', async () => {
+    const { privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
+    let calls = 0;
+    const fetchImpl = jest.fn(async () => {
+      calls += 1;
+      if (calls < 2) {
+        return new Response('rate limited', { status: 429 });
+      }
+      return new Response(JSON.stringify({ id: 'ok' }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+      });
+    });
+
+    const client = new RobinhoodCryptoClient('key', privateKey.export({ type: 'pkcs8', format: 'pem' }).toString(), {
+      fetchImpl: fetchImpl as unknown as typeof fetch,
+      retryDelayMs: 1,
+      maxRetries: 2,
+    });
+
+    const order = await client.placeOrder('BTC-USD', 25);
+    expect(order.id).toBe('ok');
+    expect(fetchImpl).toHaveBeenCalledTimes(2);
+  });
+
+  it('blocks unofficial stock calls unless feature flag is enabled', async () => {
+    delete process.env.GNOMAN_ENABLE_UNOFFICIAL_ROBINHOOD;
+    const client = new RobinhoodUnofficialClient('token', jest.fn() as unknown as typeof fetch);
+    await expect(client.placeStockBuy('AAPL', 1)).rejects.toThrow('disabled');
+  });
+});

package/gnoman2.0/tests/robinhoodController.test.ts

@@ -0,0 +1,81 @@
+import type { Request, Response } from 'express';
+
+jest.mock('../backend/services/robinhood/integrationService', () => ({
+  cancelRobinhoodCryptoOrder: jest.fn(),
+  getRobinhoodCryptoAccounts: jest.fn(),
+  getRobinhoodCryptoConfigStatus: jest.fn(),
+  getRobinhoodCryptoMarketData: jest.fn(),
+  getRobinhoodCryptoOrderStatus: jest.fn(),
+  purchaseRobinhoodCryptoWithCash: jest.fn(async (_symbol: string, _cashAmount: number) => ({ id: 'order_1' })),
+  setRobinhoodCryptoConfig: jest.fn(),
+  validateRobinhoodCryptoAuth: jest.fn(async () => ({ ok: true }))
+}));
+
+import { purchaseRobinhoodCryptoWithCash } from '../backend/services/robinhood/integrationService';
+import { placeCryptoCashOrder } from '../backend/controllers/robinhoodController';
+
+const mockedPurchaseRobinhoodCryptoWithCash = purchaseRobinhoodCryptoWithCash as jest.MockedFunction<
+  typeof purchaseRobinhoodCryptoWithCash
+>;
+
+describe('robinhoodController placeCryptoCashOrder', () => {
+  afterEach(() => {
+    mockedPurchaseRobinhoodCryptoWithCash.mockClear();
+  });
+
+  it('rejects cashAmount below the usd depth gate', async () => {
+    const req = {
+      body: {
+        symbol: 'BTC-USD',
+        cashAmount: 1999.99
+      }
+    } as Request;
+    const status = jest.fn().mockReturnThis();
+    const json = jest.fn();
+    const res = { status, json } as unknown as Response;
+
+    await placeCryptoCashOrder(req, res, jest.fn());
+
+    expect(status).toHaveBeenCalledWith(400);
+    expect(json).toHaveBeenCalledWith({ message: 'cashAmount must be at least 2000.' });
+    expect(mockedPurchaseRobinhoodCryptoWithCash).not.toHaveBeenCalled();
+  });
+
+
+
+  it('accepts cashAmount above the usd depth gate', async () => {
+    const req = {
+      body: {
+        symbol: 'BTC-USD',
+        cashAmount: 2500
+      }
+    } as Request;
+    const status = jest.fn().mockReturnThis();
+    const json = jest.fn();
+    const res = { status, json } as unknown as Response;
+
+    await placeCryptoCashOrder(req, res, jest.fn());
+
+    expect(mockedPurchaseRobinhoodCryptoWithCash).toHaveBeenCalledWith('BTC-USD', 2500);
+    expect(status).toHaveBeenCalledWith(201);
+    expect(json).toHaveBeenCalledWith({ id: 'order_1' });
+  });
+
+  it('accepts cashAmount at the usd depth gate', async () => {
+    const req = {
+      body: {
+        symbol: 'BTC-USD',
+        cashAmount: 2000
+      }
+    } as Request;
+    const status = jest.fn().mockReturnThis();
+    const json = jest.fn();
+    const res = { status, json } as unknown as Response;
+
+    await placeCryptoCashOrder(req, res, jest.fn());
+
+    expect(mockedPurchaseRobinhoodCryptoWithCash).toHaveBeenCalledWith('BTC-USD', 2000);
+    expect(status).toHaveBeenCalledWith(201);
+    expect(json).toHaveBeenCalledWith({ id: 'order_1' });
+  });
+});

package/gnoman2.0/tests/robinhoodIntegrationService.test.ts

@@ -0,0 +1,50 @@
+import {
+  getRobinhoodCryptoConfigStatus,
+  purchaseRobinhoodCryptoWithCash,
+  setRobinhoodCryptoConfig,
+} from '../backend/services/robinhood/integrationService';
+
+jest.mock('../backend/services/secureSettingsService', () => {
+  let store: Record<string, unknown> = {};
+  return {
+    getSecureSetting: jest.fn(async (key: string, fallback: unknown) =>
+      Object.prototype.hasOwnProperty.call(store, key) ? store[key] : fallback
+    ),
+    setSecureSetting: jest.fn(async (key: string, value: unknown) => {
+      store[key] = value;
+    }),
+    __reset: () => {
+      store = {};
+    },
+  };
+});
+
+describe('Robinhood integration service', () => {
+  const secureSettings = jest.requireMock('../backend/services/secureSettingsService') as {
+    __reset: () => void;
+  };
+
+  beforeEach(() => {
+    secureSettings.__reset();
+    process.env.ENABLE_ROBINHOOD_CRYPTO = 'true';
+  });
+
+  afterEach(() => {
+    delete process.env.ENABLE_ROBINHOOD_CRYPTO;
+  });
+
+  it('persists credentials and returns masked status', async () => {
+    const status = await setRobinhoodCryptoConfig('abcd1234wxyz', 'PRIVATE_KEY');
+    expect(status.configured).toBe(true);
+    expect(status.apiKeyPreview).toBe('abcd***wxyz');
+  });
+
+  it('throws if placing order without configured credentials', async () => {
+    await expect(purchaseRobinhoodCryptoWithCash('BTC-USD', 25)).rejects.toThrow('not configured');
+  });
+
+  it('loads unconfigured status by default', async () => {
+    const status = await getRobinhoodCryptoConfigStatus();
+    expect(status).toEqual({ configured: false, enabled: true, mode: 'official-crypto-only' });
+  });
+});

package/gnoman2.0/tests/safeServicePersistence.test.ts

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+
+const storageDir = path.join(process.cwd(), '.gnoman');
+const safesPath = path.join(storageDir, 'safes.json');
+
+describe('safeService persisted state loading', () => {
+  let backup: string | undefined;
+
+  beforeAll(() => {
+    fs.mkdirSync(storageDir, { recursive: true });
+    if (fs.existsSync(safesPath)) {
+      backup = fs.readFileSync(safesPath, 'utf8');
+    }
+  });
+
+  afterEach(() => {
+    jest.resetModules();
+  });
+
+  afterAll(() => {
+    if (typeof backup === 'string') {
+      fs.writeFileSync(safesPath, backup, 'utf8');
+      return;
+    }
+    if (fs.existsSync(safesPath)) {
+      fs.rmSync(safesPath, { force: true });
+    }
+  });
+
+  it('loads valid safes even when persisted payload includes malformed entries', async () => {
+    fs.writeFileSync(
+      safesPath,
+      JSON.stringify(
+        {
+          version: 1,
+          safes: [
+            {
+              address: '0x1111111111111111111111111111111111111111',
+              rpcUrl: 'http://localhost:8545',
+              owners: ['0x2222222222222222222222222222222222222222', 'bad-owner'],
+              threshold: 1,
+              modules: ['0x3333333333333333333333333333333333333333', 'bad-module'],
+              delegates: [
+                {
+                  address: '0x4444444444444444444444444444444444444444',
+                  label: 'Ops',
+                  since: '2024-01-01T00:00:00.000Z'
+                },
+                {
+                  address: 'not-an-address',
+                  label: 'Invalid',
+                  since: '2024-01-01T00:00:00.000Z'
+                }
+              ],
+              transactions: []
+            },
+            {
+              address: 'invalid-safe-address',
+              rpcUrl: 'http://localhost:8545',
+              owners: [],
+              threshold: 1,
+              modules: [],
+              delegates: [],
+              transactions: []
+            }
+          ]
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const safeService = await import('../backend/services/safeService');
+    const owners = await safeService.getOwners('0x1111111111111111111111111111111111111111');
+
+    expect(owners).toEqual(['0x2222222222222222222222222222222222222222']);
+    await expect(safeService.getOwners('0x5555555555555555555555555555555555555555')).rejects.toThrow('Safe not loaded');
+  });
+});

package/gnoman2.0/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 });
+});