bitspire/apps/machine/electron/__tests__/state-store-fees.test.ts

/**
 * Tests for fee-config persistence in state-store (aiolabs/lamassu-next#57).
 *
 * Validates the v9→v10 migration shape, the 15% cap enforced at the IPC
 * boundary (defense in depth — renderer is the primary check), watermark
 * dedup, and atomic apply semantics.
 *
 * Uses an in-memory SQLite database — fresh per test, no on-disk
 * artifacts, no parallel-test interference.
 */

import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import {
  applyFeeConfig,
  closeDatabase,
  getFeeConfig,
  getLastKnownFeeConfigCreatedAt,
  initDatabase,
} from '../state-store.js'

const VALID_PAYLOAD = {
  cashInFeeFraction: 0.0633,
  cashOutFeeFraction: 0.1077,
  schemaVersion: 1,
}

beforeEach(() => {
  initDatabase(':memory:')
})
afterEach(() => {
  closeDatabase()
})

describe('state-store: fee_config', () => {
  it('returns null before any event has been applied', () => {
    expect(getFeeConfig()).toBeNull()
    expect(getLastKnownFeeConfigCreatedAt()).toBe(0)
  })

  it('applies a valid event and round-trips via getFeeConfig', () => {
    const result = applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
    expect(result).toEqual({ applied: true })

    const row = getFeeConfig()
    expect(row).not.toBeNull()
    expect(row!.cashInFeeFraction).toBe(0.0633)
    expect(row!.cashOutFeeFraction).toBe(0.1077)
    expect(row!.schemaVersion).toBe(1)
    expect(row!.eventCreatedAt).toBe(1_780_256_000)
    expect(row!.appliedAt).toBeGreaterThan(0)

    expect(getLastKnownFeeConfigCreatedAt()).toBe(1_780_256_000)
  })

  it('upserts subsequent newer events (replaces the singleton row)', () => {
    applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
    const result = applyFeeConfig(
      { cashInFeeFraction: 0.05, cashOutFeeFraction: 0.08, schemaVersion: 1 },
      1_780_256_100
    )
    expect(result).toEqual({ applied: true })

    const row = getFeeConfig()!
    expect(row.cashInFeeFraction).toBe(0.05)
    expect(row.cashOutFeeFraction).toBe(0.08)
    expect(row.eventCreatedAt).toBe(1_780_256_100)
  })

  describe('watermark dedup', () => {
    it('rejects an event whose created_at equals the watermark', () => {
      applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
      const result = applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
      expect(result.applied).toBe(false)
      if (result.applied === false) {
        expect(result.reason).toMatch(/event\.created_at .* <= lastKnownFeeConfigCreatedAt/)
      }
    })

    it('rejects an event whose created_at is older than the watermark', () => {
      applyFeeConfig(VALID_PAYLOAD, 1_780_256_500)
      const result = applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
      expect(result.applied).toBe(false)
    })

    it('leaves the persisted row unchanged when a stale event is rejected', () => {
      applyFeeConfig(VALID_PAYLOAD, 1_780_256_500)
      const before = getFeeConfig()!
      applyFeeConfig(
        { cashInFeeFraction: 0.01, cashOutFeeFraction: 0.02, schemaVersion: 1 },
        1_780_256_000
      )
      const after = getFeeConfig()!
      expect(after.cashInFeeFraction).toBe(before.cashInFeeFraction)
      expect(after.cashOutFeeFraction).toBe(before.cashOutFeeFraction)
      expect(after.eventCreatedAt).toBe(before.eventCreatedAt)
    })
  })

  describe('per-direction 15% cap', () => {
    it('rejects when cash_in_fee_fraction exceeds 0.15', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: 0.151, cashOutFeeFraction: 0.05, schemaVersion: 1 },
        1_780_256_000
      )
      expect(result.applied).toBe(false)
      if (result.applied === false) {
        expect(result.reason).toMatch(/cash_in_fee_fraction out of range/)
      }
    })

    it('rejects when cash_out_fee_fraction exceeds 0.15', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: 0.05, cashOutFeeFraction: 0.16, schemaVersion: 1 },
        1_780_256_000
      )
      expect(result.applied).toBe(false)
    })

    it('accepts when both fractions are exactly at the 15% cap', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: 0.15, cashOutFeeFraction: 0.15, schemaVersion: 1 },
        1_780_256_000
      )
      expect(result.applied).toBe(true)
    })

    it('rejects negative fractions', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: -0.01, cashOutFeeFraction: 0.05, schemaVersion: 1 },
        1_780_256_000
      )
      expect(result.applied).toBe(false)
    })

    it('rejects non-finite fractions', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: NaN, cashOutFeeFraction: 0.05, schemaVersion: 1 },
        1_780_256_000
      )
      expect(result.applied).toBe(false)
    })
  })

  describe('schema validation', () => {
    it('rejects schema_version less than 1', () => {
      const result = applyFeeConfig(
        { cashInFeeFraction: 0.05, cashOutFeeFraction: 0.05, schemaVersion: 0 },
        1_780_256_000
      )
      expect(result.applied).toBe(false)
    })

    it('rejects non-integer event_created_at', () => {
      const result = applyFeeConfig(VALID_PAYLOAD, 1_780_256_000.5)
      expect(result.applied).toBe(false)
    })
  })

  describe('atomicity', () => {
    it('does not advance watermark when payload validation fails', () => {
      applyFeeConfig(VALID_PAYLOAD, 1_780_256_000)
      applyFeeConfig(
        { cashInFeeFraction: 0.99, cashOutFeeFraction: 0.05, schemaVersion: 1 },
        1_780_256_500
      )
      // Cap rejection — watermark should still be at the first apply.
      expect(getLastKnownFeeConfigCreatedAt()).toBe(1_780_256_000)
    })
  })
})