CurrenciCombo/orchestrator/tests/unit/eventSigner.test.ts

/**
 * PR O — EIP-712 / JWS event signatures (gap-analysis v2 §7.5 / §10.5).
 *
 * Covers:
 *   - HMAC default mode (back-compat) — round-trip sign/verify
 *   - JWS compact mode — valid signature, payload-tamper detection,
 *     signature-tamper detection
 *   - EIP-712 mode — round-trip via ethers wallet, tamper detection
 *   - Mode switching via EVENT_SIGNING_MODE + getEventSigner()
 *   - legacyHmac helper preserves the pre-PR-O signature shape
 */

import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
import { ethers } from "ethers";
import {
  getEventSigner,
  resolveSigningMode,
  legacyHmac,
  __resetSignerForTests,
  type EventSignInput,
} from "../../src/services/eventSigner";

const TEST_KEY = "0x" + "ab".repeat(32); // deterministic test wallet

function makeInput(overrides: Partial<EventSignInput> = {}): EventSignInput {
  return {
    planId: "plan-x",
    type: "transaction.created",
    payloadHash: "a".repeat(64),
    prevHash: null,
    ...overrides,
  };
}

describe("eventSigner — mode resolution", () => {
  beforeEach(() => {
    __resetSignerForTests();
    delete process.env.EVENT_SIGNING_MODE;
    delete process.env.ORCHESTRATOR_PRIVATE_KEY;
  });

  it("defaults to hmac when env var absent", () => {
    expect(resolveSigningMode()).toBe("hmac");
    expect(getEventSigner().mode).toBe("hmac");
  });

  it("honours eip712 / jws / hmac values", () => {
    for (const mode of ["eip712", "jws", "hmac"] as const) {
      __resetSignerForTests();
      process.env.EVENT_SIGNING_MODE = mode;
      expect(resolveSigningMode()).toBe(mode);
      expect(getEventSigner().mode).toBe(mode);
    }
  });

  it("falls through to hmac on unknown mode", () => {
    process.env.EVENT_SIGNING_MODE = "bogus";
    expect(resolveSigningMode()).toBe("hmac");
  });
});

describe("eventSigner — HMAC round-trip", () => {
  beforeEach(() => {
    __resetSignerForTests();
    process.env.EVENT_SIGNING_MODE = "hmac";
    process.env.EVENT_BUS_HMAC_SECRET = "test-secret";
  });

  it("signs + verifies", async () => {
    const signer = getEventSigner();
    const input = makeInput();
    const sig = await signer.sign(input);
    expect(sig).toMatch(/^[0-9a-f]{64}$/);
    expect(await signer.verify(input, sig)).toBe(true);
  });

  it("rejects a tampered payload hash", async () => {
    const signer = getEventSigner();
    const input = makeInput();
    const sig = await signer.sign(input);
    expect(
      await signer.verify({ ...input, payloadHash: "b".repeat(64) }, sig),
    ).toBe(false);
  });

  it("legacyHmac produces the same hex as the HMAC signer", async () => {
    const input = makeInput();
    const sig = await getEventSigner().sign(input);
    expect(legacyHmac(input)).toBe(sig);
  });
});

describe("eventSigner — JWS compact", () => {
  beforeEach(() => {
    __resetSignerForTests();
    process.env.EVENT_SIGNING_MODE = "jws";
    process.env.EVENT_BUS_HMAC_SECRET = "jws-secret";
  });

  it("produces header.body.sig shape", async () => {
    const sig = await getEventSigner().sign(makeInput());
    expect(sig.split(".")).toHaveLength(3);
  });

  it("round-trips sign/verify", async () => {
    const signer = getEventSigner();
    const input = makeInput();
    expect(await signer.verify(input, await signer.sign(input))).toBe(true);
  });

  it("rejects a different event being presented with a valid sig", async () => {
    const signer = getEventSigner();
    const signed = await signer.sign(makeInput());
    expect(
      await signer.verify(makeInput({ type: "transaction.aborted" }), signed),
    ).toBe(false);
  });

  it("rejects a truncated signature", async () => {
    const signer = getEventSigner();
    const sig = await signer.sign(makeInput());
    expect(await signer.verify(makeInput(), sig.slice(0, -3))).toBe(false);
  });
});

describe("eventSigner — EIP-712 (ethers wallet)", () => {
  beforeEach(() => {
    __resetSignerForTests();
    process.env.EVENT_SIGNING_MODE = "eip712";
    process.env.ORCHESTRATOR_PRIVATE_KEY = TEST_KEY;
    process.env.CHAIN_138_CHAIN_ID = "138";
  });

  afterEach(() => {
    delete process.env.ORCHESTRATOR_PRIVATE_KEY;
  });

  it("produces a 65-byte 0x-prefixed ECDSA signature", async () => {
    const sig = await getEventSigner().sign(makeInput());
    expect(sig).toMatch(/^0x[0-9a-fA-F]{130}$/);
  });

  it("verifies as the signing wallet", async () => {
    const signer = getEventSigner();
    const input = makeInput();
    const sig = await signer.sign(input);
    expect(await signer.verify(input, sig)).toBe(true);
    // Recovered address should match the wallet derived from TEST_KEY.
    const expectedAddress = new ethers.Wallet(TEST_KEY).address;
    const recovered = ethers.verifyTypedData(
      {
        name: "CurrenciCombo",
        version: "1",
        chainId: 138,
        verifyingContract:
          process.env.NOTARY_REGISTRY_ADDRESS ??
          "0x0000000000000000000000000000000000000000",
      },
      {
        Event: [
          { name: "planId", type: "string" },
          { name: "eventType", type: "string" },
          { name: "payloadHash", type: "bytes32" },
          { name: "prevHash", type: "bytes32" },
        ],
      },
      {
        planId: input.planId,
        eventType: input.type,
        payloadHash: `0x${input.payloadHash}`,
        prevHash: "0x" + "0".repeat(64),
      },
      sig,
    );
    expect(recovered.toLowerCase()).toBe(expectedAddress.toLowerCase());
  });

  it("rejects a signature for a different event", async () => {
    const signer = getEventSigner();
    const sig = await signer.sign(makeInput());
    // Valid signature but rebound to a different event → fails because
    // the recovered address won't be our wallet.
    expect(
      await signer.verify(makeInput({ type: "transaction.committed" }), sig),
    ).toBe(false);
  });
});