anchorage_layer_simple/api-relay/src/routes/signatures.ts

import { Router, type Request, type Response } from 'express';
import type { StorageServiceInterface } from '../services/storageInterface.js';
import type { RelayService } from '../services/relay.js';
import type { MsgSignature, StoredSignature } from '../types/message.js';
import { validateMsgSignature } from '../lib/validate.js';
import { logger } from '../lib/logger.js';

function handleGetSignatures(
  storage: StorageServiceInterface,
  req: Request,
  res: Response,
): void {
  try {
    const hash = req.params.hash as string;
    if (hash.length === 0) {
      res.status(400).json({ error: 'Hash parameter required' });
      return;
    }
    const stored = storage.getSignatures(hash);
    const signatures: MsgSignature[] = stored.map((s) => s.msg);
    res.json(signatures);
  } catch (error) {
    logger.error({ err: error }, 'Error getting signatures');
    res.status(500).json({ error: 'Internal server error' });
  }
}

function handlePostSignature(
  storage: StorageServiceInterface,
  relay: RelayService,
  req: Request,
  res: Response,
): void {
  void (async (): Promise<void> => {
    try {
      if (!validateMsgSignature(req.body)) {
        res.status(400).json({ error: 'Invalid signature format' });
        return;
      }
      const sig = req.body as MsgSignature;

      const stored: StoredSignature = {
        msg: sig,
        received_at: Date.now(),
        relayed: false,
      };

      storage.storeSignature(stored);
      await relay.relaySignature(sig);
      stored.relayed = true;

      res.status(201).json({ stored: true });
    } catch (error) {
      logger.error({ err: error }, 'Error storing signature');
      res.status(500).json({ error: 'Internal server error' });
    }
  })();
}

export function createSignaturesRouter(
  storage: StorageServiceInterface,
  relay: RelayService,
): Router {
  const router = Router();

  router.get('/:hash', (req, res) => handleGetSignatures(storage, req, res));
  router.post('/', (req, res) => handlePostSignature(storage, relay, req, res));

  return router;
}