gnoman 0.1.0

package/tests/keyringManager.test.ts

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { KeyringManager } from '../src/core/keyringManager';
+import { MemoryBackend } from '../src/core/backends/memoryBackend';
+import { FileBackend } from '../src/core/backends/fileBackend';
+import { BackendUnavailableError, KeyringBackend } from '../src/core/backends/types';
+
+class StubBackend implements KeyringBackend {
+  constructor(private state: Record<string, string>) {}
+
+  async initialize(): Promise<void> {
+    // no-op
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.state[key] ?? null;
+  }
+
+  async set(key: string, value: string): Promise<void> {
+    this.state[key] = value;
+  }
+
+  async delete(key: string): Promise<void> {
+    delete this.state[key];
+  }
+
+  async list(): Promise<Record<string, string>> {
+    return { ...this.state };
+  }
+}
+
+describe('KeyringManager', () => {
+  const createTempPath = (fileName: string) => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gnoman-keyring-test-'));
+    return path.join(dir, fileName);
+  };
+
+  it('switchBackend reloads secrets from the requested backend', async () => {
+    const manager = new KeyringManager({
+      backendFactories: {
+        system: () => new StubBackend({ RPC_URL: 'https://system' }),
+        file: () => new StubBackend({ FILE_ONLY: 'present' }),
+        memory: () => new MemoryBackend()
+      },
+      auditLogPath: createTempPath('audit.log')
+    });
+
+    await manager.switchBackend('system');
+    expect(await manager.get('RPC_URL')).toBe('https://system');
+
+    await manager.switchBackend('file');
+    const snapshot = await manager.list();
+    expect(snapshot).toEqual({ FILE_ONLY: 'present' });
+    expect(await manager.get('FILE_ONLY')).toBe('present');
+  });
+
+  it('round-trips secrets between persistent backends', async () => {
+    const filePath = createTempPath('secrets.enc');
+    const manager = new KeyringManager({
+      backendFactories: {
+        system: () => new FileBackend(filePath),
+        file: () => new FileBackend(filePath),
+        memory: () => new MemoryBackend()
+      },
+      auditLogPath: createTempPath('audit.log')
+    });
+
+    await manager.switchBackend('system');
+    await manager.set('API_TOKEN', 'system-token');
+    expect(await manager.get('API_TOKEN')).toBe('system-token');
+
+    await manager.switchBackend('file');
+    expect(await manager.get('API_TOKEN')).toBe('system-token');
+
+    await manager.set('API_TOKEN', 'file-token');
+    expect(await manager.get('API_TOKEN')).toBe('file-token');
+
+    await manager.switchBackend('system');
+    expect(await manager.get('API_TOKEN')).toBe('file-token');
+  });
+
+  it('encrypts secrets on disk for the file backend', async () => {
+    const filePath = createTempPath('secrets.enc');
+    const manager = new KeyringManager({
+      backendFactories: {
+        system: () => new FileBackend(filePath),
+        file: () => new FileBackend(filePath),
+        memory: () => new MemoryBackend()
+      },
+      auditLogPath: createTempPath('audit.log')
+    });
+
+    await manager.switchBackend('file');
+    await manager.set('PRIVATE_KEY', 'super-secret-value');
+
+    const raw = await fsPromises.readFile(filePath, 'utf8');
+    expect(raw).not.toContain('super-secret-value');
+    expect(() => JSON.parse(raw)).not.toThrow();
+  });
+
+  it('falls back when the system backend is unavailable', async () => {
+    class FailingBackend implements KeyringBackend {
+      async initialize(): Promise<void> {
+        throw new BackendUnavailableError('Unavailable', 'system');
+      }
+      async get(): Promise<string | null> {
+        throw new Error('unreachable');
+      }
+      async set(): Promise<void> {
+        throw new Error('unreachable');
+      }
+      async delete(): Promise<void> {
+        throw new Error('unreachable');
+      }
+      async list(): Promise<Record<string, string>> {
+        throw new Error('unreachable');
+      }
+    }
+
+    const manager = new KeyringManager({
+      backendFactories: {
+        system: () => new FailingBackend(),
+        file: () => new MemoryBackend(),
+        memory: () => new MemoryBackend()
+      },
+      auditLogPath: createTempPath('audit.log')
+    });
+
+    const secrets = await manager.list();
+    expect(secrets).toEqual({});
+    expect(['file', 'memory']).toContain(manager.currentBackend());
+  });
+});

package/tests/onchainToolkit.test.ts

@@ -0,0 +1,71 @@
+import { AbiRegistry } from '../backend/services/onchain/abiRegistry';
+import { EtherscanClient } from '../backend/services/onchain/etherscanClient';
+import { OnchainClientError } from '../backend/services/onchain/errors';
+import { createOnchainToolkit } from '../backend/services/onchain';
+
+describe('AbiRegistry', () => {
+  it('resolves ABI from etherscan client and caches by chainId + address', async () => {
+    const resolver = {
+      getContractAbi: jest.fn(async () => [{ type: 'function', name: 'balanceOf' }])
+    };
+
+    const registry = new AbiRegistry({ etherscanClients: { 1: resolver } });
+
+    const abi1 = await registry.getAbi('0x1111111111111111111111111111111111111111', 1);
+    const abi2 = await registry.getAbi('0x1111111111111111111111111111111111111111', 1);
+
+    expect(abi1).toEqual(abi2);
+    expect(resolver.getContractAbi).toHaveBeenCalledTimes(1);
+    expect(registry.getCacheSize()).toBe(1);
+  });
+
+  it('throws a typed error when chain is not configured', async () => {
+    const registry = new AbiRegistry({ etherscanClients: {} });
+    await expect(registry.getAbi('0x1111111111111111111111111111111111111111', 10)).rejects.toMatchObject({
+      code: 'ABI_RESOLUTION_FAILED'
+    } satisfies Partial<OnchainClientError>);
+  });
+});
+
+describe('EtherscanClient', () => {
+  it('retries rate limited responses and returns parsed ABI', async () => {
+    const client = new EtherscanClient('key');
+    const responses = [
+      { data: { status: '0', message: 'NOTOK', result: 'Max rate limit reached' } },
+      { data: { status: '1', message: 'OK', result: JSON.stringify([{ type: 'function', name: 'foo' }]) } }
+    ];
+
+    (client as unknown as { client: { get: jest.Mock } }).client = {
+      get: jest.fn(async () => responses.shift())
+    };
+
+    const abi = await client.getContractAbi('0x1111111111111111111111111111111111111111');
+
+    expect(Array.isArray(abi)).toBe(true);
+  });
+});
+
+describe('createOnchainToolkit', () => {
+  it('creates swappable per-network clients', () => {
+    const toolkit = createOnchainToolkit({
+      defaultChainId: 1,
+      networks: {
+        1: {
+          chainId: 1,
+          rpcUrl: 'https://rpc-mainnet.example',
+          etherscan: { apiKey: 'mainnet-key' },
+          tenderly: { rpcUrl: 'https://rpc.tenderly.co/fork/mainnet' }
+        },
+        11155111: {
+          chainId: 11155111,
+          rpcUrl: 'https://rpc-sepolia.example',
+          etherscan: { apiKey: 'sepolia-key', baseUrl: 'https://api-sepolia.etherscan.io/api' }
+        }
+      }
+    });
+
+    expect(toolkit.getEtherscanClient(11155111)).toBeInstanceOf(EtherscanClient);
+    expect(toolkit.getChainlinkClient(1)).toBeDefined();
+    expect(toolkit.getTenderlyRpcClient(1)).toBeDefined();
+  });
+});

package/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/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/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/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');
+  });
+});