gnoman 0.1.0

package/backend/services/onchainAutomationService.ts

@@ -0,0 +1,424 @@
+import { randomBytes } from 'crypto';
+import { ethers } from 'ethers';
+
+export interface SafeOwner {
+  address: string;
+  role: string;
+  threshold: number;
+}
+
+export interface DelegatePermissions {
+  delegate: string;
+  permissions: string[];
+}
+
+export class SafeManager {
+  private owners: SafeOwner[] = [];
+
+  private delegates: Map<string, DelegatePermissions[]> = new Map();
+
+  private threshold = 1;
+
+  constructor(private readonly safeAddress: string, private readonly provider: ethers.JsonRpcProvider) {}
+
+  getSafeAddress(): string {
+    return this.safeAddress;
+  }
+
+  getOwners(): SafeOwner[] {
+    return this.owners.map((owner) => ({ ...owner }));
+  }
+
+  getThreshold(): number {
+    return this.threshold;
+  }
+
+  getDelegates(ownerAddress: string): DelegatePermissions[] {
+    const owner = ethers.getAddress(ownerAddress);
+    return [...(this.delegates.get(owner) ?? [])].map((entry) => ({ ...entry, permissions: [...entry.permissions] }));
+  }
+
+  async addOwner(address: string, role: string, threshold: number): Promise<string> {
+    if (!Number.isInteger(threshold) || threshold < 1) {
+      throw new Error('Threshold must be a positive integer');
+    }
+    const normalizedAddress = ethers.getAddress(address);
+    const existing = this.owners.find((owner) => owner.address === normalizedAddress);
+    if (existing) {
+      existing.role = role;
+      existing.threshold = threshold;
+    } else {
+      this.owners.push({ address: normalizedAddress, role, threshold });
+    }
+    this.threshold = threshold;
+    this.owners.forEach((owner) => {
+      owner.threshold = this.threshold;
+    });
+    return this.executeAddOwner(normalizedAddress, threshold);
+  }
+
+  async removeOwner(address: string): Promise<string> {
+    const normalizedAddress = ethers.getAddress(address);
+    if (!this.validateRemoval(normalizedAddress)) {
+      throw new Error('Removal would violate threshold requirements');
+    }
+    this.owners = this.owners.filter((owner) => owner.address !== normalizedAddress);
+    this.delegates.delete(normalizedAddress);
+    if (this.owners.length < this.threshold) {
+      this.threshold = Math.max(this.owners.length, 1);
+      this.owners.forEach((owner) => {
+        owner.threshold = this.threshold;
+      });
+    }
+    return this.executeRemoveOwner(normalizedAddress);
+  }
+
+  async addDelegate(ownerAddress: string, delegateAddress: string, permissions: string[]): Promise<string> {
+    const owner = ethers.getAddress(ownerAddress);
+    const delegate = ethers.getAddress(delegateAddress);
+
+    if (!this.owners.find((existing) => existing.address === owner)) {
+      throw new Error('Unknown owner');
+    }
+
+    if (!permissions.length) {
+      throw new Error('At least one permission is required');
+    }
+
+    const normalizedPermissions = Array.from(new Set(permissions));
+    const ownerDelegates = this.delegates.get(owner) ?? [];
+    const existing = ownerDelegates.find((entry) => entry.delegate === delegate);
+    if (existing) {
+      existing.permissions = Array.from(new Set([...existing.permissions, ...normalizedPermissions]));
+    } else {
+      ownerDelegates.push({ delegate, permissions: normalizedPermissions });
+    }
+    this.delegates.set(owner, ownerDelegates);
+
+    return this.executeAddDelegate(owner, delegate, normalizedPermissions);
+  }
+
+  private validateRemoval(address: string): boolean {
+    const ownerExists = this.owners.some((owner) => owner.address === address);
+    if (!ownerExists) {
+      return false;
+    }
+    const remainingOwners = this.owners.filter((owner) => owner.address !== address);
+    return remainingOwners.length >= this.threshold;
+  }
+
+  private async executeAddOwner(address: string, threshold: number): Promise<string> {
+    await this.provider.getNetwork();
+    return this.generateTransactionHash('addOwner', address, threshold.toString());
+  }
+
+  private async executeRemoveOwner(address: string): Promise<string> {
+    await this.provider.getNetwork();
+    return this.generateTransactionHash('removeOwner', address);
+  }
+
+  private async executeAddDelegate(owner: string, delegate: string, permissions: string[]): Promise<string> {
+    await this.provider.getNetwork();
+    return this.generateTransactionHash('addDelegate', owner, delegate, permissions.join(','));
+  }
+
+  private generateTransactionHash(...parts: string[]): string {
+    const entropy = randomBytes(32).toString('hex');
+    const payload = ethers.toUtf8Bytes(parts.join(':'));
+    return ethers.keccak256(ethers.concat([payload, `0x${entropy}`]));
+  }
+}
+
+export interface TokenTemplate {
+  name: string;
+  symbol: string;
+  totalSupply: ethers.BigNumberish;
+  decimals: number;
+  mintable: boolean;
+}
+
+interface TokenDeploymentRecord {
+  templateId: string;
+  contractAddress: string;
+}
+
+interface TokenMintRecord {
+  amount: bigint;
+  recipient: string;
+  timestamp: string;
+}
+
+export class TokenMintWizard {
+  private templates: Map<string, TokenTemplate> = new Map();
+
+  private deployments: Map<string, TokenDeploymentRecord> = new Map();
+
+  private mints: Map<string, TokenMintRecord[]> = new Map();
+
+  constructor(private readonly provider: ethers.JsonRpcProvider) {}
+
+  listTemplates(): TokenTemplate[] {
+    return Array.from(this.templates.values()).map((template) => ({ ...template }));
+  }
+
+  getTemplate(templateId: string): TokenTemplate | undefined {
+    const template = this.templates.get(templateId);
+    return template ? { ...template } : undefined;
+  }
+
+  async createToken(templateId: string, template: TokenTemplate): Promise<string> {
+    if (template.decimals < 0 || template.decimals > 18) {
+      throw new Error('Token decimals must be between 0 and 18');
+    }
+    if (ethers.toBigInt(template.totalSupply) < 0n) {
+      throw new Error('Total supply must be non-negative');
+    }
+    this.templates.set(templateId, { ...template });
+    const contractAddress = await this.deployTokenContract(template);
+    this.deployments.set(contractAddress, { templateId, contractAddress });
+    return contractAddress;
+  }
+
+  async mintTokens(contractAddress: string, amount: ethers.BigNumberish, recipient: string): Promise<string> {
+    const normalizedAddress = ethers.getAddress(contractAddress);
+    const normalizedRecipient = ethers.getAddress(recipient);
+    if (!this.deployments.has(normalizedAddress)) {
+      throw new Error('Unknown contract deployment');
+    }
+    const mintedAmount = ethers.toBigInt(amount);
+    if (mintedAmount <= 0n) {
+      throw new Error('Mint amount must be greater than zero');
+    }
+    const history = this.mints.get(normalizedAddress) ?? [];
+    history.push({ amount: mintedAmount, recipient: normalizedRecipient, timestamp: new Date().toISOString() });
+    this.mints.set(normalizedAddress, history);
+    return this.executeMint(normalizedAddress, mintedAmount, normalizedRecipient);
+  }
+
+  getMintHistory(contractAddress: string): TokenMintRecord[] {
+    const normalizedAddress = ethers.getAddress(contractAddress);
+    return [...(this.mints.get(normalizedAddress) ?? [])].map((record) => ({ ...record }));
+  }
+
+  private async deployTokenContract(_template: TokenTemplate): Promise<string> {
+    await this.provider.getNetwork();
+    let contractAddress: string;
+    do {
+      const entropy = randomBytes(20).toString('hex');
+      contractAddress = ethers.getAddress(`0x${entropy}`);
+    } while (this.deployments.has(contractAddress));
+    return contractAddress;
+  }
+
+  private async executeMint(contractAddress: string, amount: bigint, recipient: string): Promise<string> {
+    await this.provider.getNetwork();
+    return this.generateTransactionHash('mint', contractAddress, amount.toString(), recipient);
+  }
+
+  private generateTransactionHash(...parts: string[]): string {
+    const payload = ethers.toUtf8Bytes(parts.join(':'));
+    return ethers.keccak256(payload);
+  }
+}
+
+export interface NftTemplate {
+  name: string;
+  symbol: string;
+  baseUri: string;
+  royaltyPercentage: number;
+  maxSupply: number;
+}
+
+interface NftContractRecord {
+  templateId: string;
+  contractAddress: string;
+  minted: number;
+}
+
+export class NftWizard {
+  private templates: Map<string, NftTemplate> = new Map();
+
+  private contracts: Map<string, NftContractRecord> = new Map();
+
+  constructor(private readonly provider: ethers.JsonRpcProvider) {}
+
+  createTemplate(templateId: string, template: NftTemplate): void {
+    if (template.maxSupply <= 0) {
+      throw new Error('Max supply must be greater than zero');
+    }
+    if (template.royaltyPercentage < 0 || template.royaltyPercentage > 100) {
+      throw new Error('Royalty percentage must be between 0 and 100');
+    }
+    this.templates.set(templateId, { ...template });
+  }
+
+  getTemplate(templateId: string): NftTemplate | undefined {
+    const template = this.templates.get(templateId);
+    return template ? { ...template } : undefined;
+  }
+
+  async mintNft(templateId: string, metadata: Record<string, unknown>): Promise<string> {
+    const template = this.templates.get(templateId);
+    if (!template) {
+      throw new Error(`Unknown template: ${templateId}`);
+    }
+
+    const contract = await this.getOrDeployContract(templateId, template);
+    if (contract.minted >= template.maxSupply) {
+      throw new Error('Max supply reached for template');
+    }
+
+    contract.minted += 1;
+    this.contracts.set(contract.contractAddress, contract);
+    return this.mintToken(contract.contractAddress, metadata, contract.minted);
+  }
+
+  private async getOrDeployContract(templateId: string, _template: NftTemplate): Promise<NftContractRecord> {
+    const existing = Array.from(this.contracts.values()).find((contract) => contract.templateId === templateId);
+    if (existing) {
+      return existing;
+    }
+    await this.provider.getNetwork();
+    let contractAddress: string;
+    do {
+      const entropy = randomBytes(20).toString('hex');
+      contractAddress = ethers.getAddress(`0x${entropy}`);
+    } while (this.contracts.has(contractAddress));
+    const record: NftContractRecord = { templateId, contractAddress, minted: 0 };
+    this.contracts.set(contractAddress, record);
+    return record;
+  }
+
+  private async mintToken(contractAddress: string, metadata: Record<string, unknown>, tokenId: number): Promise<string> {
+    await this.provider.getNetwork();
+    const serialized = JSON.stringify(metadata ?? {});
+    const payload = ethers.toUtf8Bytes(`${contractAddress}:${tokenId}:${serialized}`);
+    return ethers.keccak256(payload);
+  }
+}
+
+export interface BridgeConfig {
+  name: string;
+  supportedSources: string[];
+  supportedDestinations: string[];
+  baseFeeBps: number;
+  capacity?: number;
+  securityAudits?: number;
+  slippage?: number;
+  historicalFailureRate?: number;
+}
+
+interface BridgeState {
+  config: BridgeConfig;
+  riskScore: number;
+  usageStats: BridgeUsageStats;
+}
+
+export interface BridgeUsageStats {
+  usageCount: number;
+  totalVolume: number;
+  averageTransferTime: number;
+}
+
+export interface BridgePath {
+  bridgeType: string;
+  estimatedFee: number;
+  estimatedTime: number;
+  riskScore: number;
+}
+
+export class BridgeManager {
+  private bridges: Map<string, BridgeState> = new Map();
+
+  addBridge(bridgeType: string, config: BridgeConfig): void {
+    const normalizedType = bridgeType.toLowerCase();
+    if (config.baseFeeBps < 0) {
+      throw new Error('Base fee cannot be negative');
+    }
+    if (!config.supportedSources.length || !config.supportedDestinations.length) {
+      throw new Error('Bridge must support at least one source and destination');
+    }
+    const riskScore = this.assessBridgeRisk(config);
+    const usageStats = this.initializeStats();
+    this.bridges.set(normalizedType, { config, riskScore, usageStats });
+  }
+
+  optimizeTransfer(amount: number, source: string, destination: string): BridgePath | undefined {
+    if (amount <= 0) {
+      throw new Error('Transfer amount must be greater than zero');
+    }
+    const availablePaths = this.findAvailablePaths(source, destination);
+    if (!availablePaths.length) {
+      return undefined;
+    }
+    return this.selectOptimalPath(availablePaths, amount);
+  }
+
+  recordTransfer(bridgeType: string, amount: number, duration: number): void {
+    const normalizedType = bridgeType.toLowerCase();
+    const bridge = this.bridges.get(normalizedType);
+    if (!bridge) {
+      throw new Error('Unknown bridge type');
+    }
+    if (amount < 0) {
+      throw new Error('Transfer amount cannot be negative');
+    }
+    if (duration < 0) {
+      throw new Error('Transfer duration cannot be negative');
+    }
+    bridge.usageStats.usageCount += 1;
+    bridge.usageStats.totalVolume += amount;
+    bridge.usageStats.averageTransferTime =
+      (bridge.usageStats.averageTransferTime * (bridge.usageStats.usageCount - 1) + duration) / bridge.usageStats.usageCount;
+  }
+
+  private assessBridgeRisk(config: BridgeConfig): number {
+    const auditScore = config.securityAudits ? Math.min(config.securityAudits, 5) / 5 : 0.2;
+    const failurePenalty = config.historicalFailureRate ?? 0.05;
+    const slippagePenalty = config.slippage ?? 0.01;
+    const capacityBonus = config.capacity ? Math.min(config.capacity / 1_000_000, 1) * 0.1 : 0;
+    const rawScore = 1 - (failurePenalty + slippagePenalty) + auditScore + capacityBonus;
+    return Math.min(Math.max(rawScore, 0), 1);
+  }
+
+  private initializeStats(): BridgeUsageStats {
+    return {
+      usageCount: 0,
+      totalVolume: 0,
+      averageTransferTime: 0
+    };
+  }
+
+  private findAvailablePaths(source: string, destination: string): BridgePath[] {
+    const normalizedSource = source.toLowerCase();
+    const normalizedDestination = destination.toLowerCase();
+    return Array.from(this.bridges.entries())
+      .filter(([, state]) =>
+        state.config.supportedSources.map((value) => value.toLowerCase()).includes(normalizedSource) &&
+        state.config.supportedDestinations.map((value) => value.toLowerCase()).includes(normalizedDestination)
+      )
+      .map(([type, state]) => {
+        const estimatedFee = state.config.baseFeeBps / 10_000;
+        const estimatedTime = Math.max(state.usageStats.averageTransferTime || 15, 5);
+        return {
+          bridgeType: type,
+          estimatedFee,
+          estimatedTime,
+          riskScore: state.riskScore
+        };
+      });
+  }
+
+  private selectOptimalPath(paths: BridgePath[], amount: number): BridgePath {
+    const scoredPaths = paths
+      .map((path) => {
+        const feePenalty = path.estimatedFee * amount;
+        const riskPenalty = (1 - path.riskScore) * amount * 0.01;
+        const timePenalty = path.estimatedTime;
+        return { path, score: feePenalty + riskPenalty + timePenalty };
+      })
+      .sort((a, b) => a.score - b.score);
+
+    return scoredPaths[0].path;
+  }
+}

package/backend/services/robinhood/auth.ts

@@ -0,0 +1,42 @@
+import crypto from 'crypto';
+
+export interface RobinhoodSignedHeaders {
+  'x-api-key': string;
+  'x-signature': string;
+  'x-timestamp': string;
+}
+
+export interface SignRobinhoodRequestParams {
+  apiKey: string;
+  privateKey: string;
+  method: string;
+  path: string;
+  body?: string;
+  timestamp?: number;
+}
+
+/**
+ * Template helper for signing Robinhood requests.
+ * Robinhood's canonical payload format may evolve; keep the canonical string construction in one place.
+ */
+export const signRobinhoodRequest = ({
+  apiKey,
+  privateKey,
+  method,
+  path,
+  body = '',
+  timestamp = Date.now(),
+}: SignRobinhoodRequestParams): RobinhoodSignedHeaders => {
+  const canonical = `${timestamp}|${method.toUpperCase()}|${path}|${body}`;
+  const signature = crypto
+    .createSign('SHA256')
+    .update(canonical)
+    .end()
+    .sign(privateKey, 'base64');
+
+  return {
+    'x-api-key': apiKey,
+    'x-signature': signature,
+    'x-timestamp': String(timestamp),
+  };
+};

package/backend/services/robinhood/client.ts

@@ -0,0 +1,123 @@
+import { signRobinhoodRequest } from './auth';
+import { runtimeObservability } from '../../../src/utils/runtimeObservability';
+
+const DEFAULT_BASE_URL = 'https://trading.robinhood.com';
+
+export interface BalanceResponse {
+  [key: string]: unknown;
+}
+
+export interface MarketDataResponse {
+  [key: string]: unknown;
+}
+
+export interface OrderResponse {
+  id?: string;
+  [key: string]: unknown;
+}
+
+export interface OrderStatus {
+  id?: string;
+  state?: string;
+  [key: string]: unknown;
+}
+
+export interface ClientOptions {
+  baseUrl?: string;
+  maxRetries?: number;
+  retryDelayMs?: number;
+  fetchImpl?: typeof fetch;
+  onRequestComplete?: (event: { endpoint: string; method: string; statusCode: number; latencyMs: number }) => void;
+}
+
+export class RobinhoodCryptoClient {
+  private readonly baseUrl: string;
+
+  private readonly maxRetries: number;
+
+  private readonly retryDelayMs: number;
+
+  private readonly fetchImpl: typeof fetch;
+
+  private readonly onRequestComplete?: ClientOptions['onRequestComplete'];
+
+  constructor(
+    private readonly apiKey: string,
+    private readonly privateKey: string,
+    options: ClientOptions = {}
+  ) {
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryDelayMs = options.retryDelayMs ?? 500;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.onRequestComplete = options.onRequestComplete;
+  }
+
+  async getAccounts(): Promise<BalanceResponse> {
+    return this.request<BalanceResponse>('GET', '/api/v1/crypto/trading/accounts/');
+  }
+
+  async getAccountBalance(): Promise<BalanceResponse> {
+    return this.getAccounts();
+  }
+
+  async getMarketData(symbol: string): Promise<MarketDataResponse> {
+    return this.request<MarketDataResponse>('GET', `/api/v1/crypto/marketdata/best_bid_ask/?symbol=${encodeURIComponent(symbol)}`);
+  }
+
+  async placeOrder(symbol: string, amountCash: number): Promise<OrderResponse> {
+    return this.request<OrderResponse>('POST', '/api/v1/crypto/trading/orders/', {
+      symbol,
+      side: 'buy',
+      type: 'market',
+      cash_amount: amountCash,
+    });
+  }
+
+  async getOrderStatus(orderID: string): Promise<OrderStatus> {
+    return this.request<OrderStatus>('GET', `/api/v1/crypto/trading/orders/${encodeURIComponent(orderID)}/`);
+  }
+
+  async cancelOrder(orderID: string): Promise<OrderStatus> {
+    return this.request<OrderStatus>('POST', `/api/v1/crypto/trading/orders/${encodeURIComponent(orderID)}/cancel/`);
+  }
+
+  private async request<T>(method: string, path: string, payload?: Record<string, unknown>): Promise<T> {
+    const body = payload ? JSON.stringify(payload) : '';
+    const headers = signRobinhoodRequest({
+      apiKey: this.apiKey,
+      privateKey: this.privateKey,
+      method,
+      path,
+      body,
+    });
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
+      const startedAt = Date.now();
+      const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+        method,
+        headers: {
+          ...headers,
+          'content-type': 'application/json',
+        },
+        body: body || undefined,
+      });
+
+      this.onRequestComplete?.({ endpoint: path, method, statusCode: response.status, latencyMs: Date.now() - startedAt });
+
+      if (response.status === 429 && attempt < this.maxRetries) {
+        await new Promise((resolve) => setTimeout(resolve, this.retryDelayMs * (attempt + 1)));
+        continue;
+      }
+
+      if (!response.ok) {
+        const responseText = await response.text();
+        throw new Error(`Robinhood API error (${response.status}): ${responseText}`);
+      }
+
+      return (await response.json()) as T;
+    }
+
+    throw new Error('Robinhood API retry budget exhausted.');
+  }
+}