| import * as crypto from 'crypto' |
| import * as fs from 'fs' |
| import * as path from 'path' |
| import { v4 as uuidv4 } from 'uuid' |
|
|
| export interface WormEntry { |
| id: string |
| receivedAt: string |
| type: string |
| payload: unknown |
| chainHash: string |
| } |
|
|
| export class WormLog { |
| private filePath: string |
| private secret: string |
| private chainTip: string = 'GENESIS' |
|
|
| constructor(dataDir: string = './data') { |
| if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true }) |
| this.filePath = path.join(dataDir, 'sealforge.worm.jsonl') |
| const secret = process.env.WORM_SECRET |
| if (!secret || secret.length < 32) throw new Error('[WORM] WORM_SECRET must be set and at least 32 characters') |
| this.secret = secret |
| this.loadChainTip() |
| } |
|
|
| private loadChainTip(): void { |
| if (!fs.existsSync(this.filePath)) return |
| const lines = fs.readFileSync(this.filePath, 'utf8').trim().split('\n').filter(Boolean) |
| if (lines.length > 0) { |
| const last = JSON.parse(lines[lines.length - 1]) as WormEntry |
| this.chainTip = last.chainHash |
| console.log(`[WORM] Chain loaded — ${lines.length} entries — tip: ${this.chainTip.slice(0, 16)}...`) |
| } |
| } |
|
|
| private computeHash(id: string, receivedAt: string, bodyRaw: string): string { |
| return crypto |
| .createHmac('sha256', this.secret) |
| .update(`${this.chainTip}:${id}:${receivedAt}:${bodyRaw}`) |
| .digest('hex') |
| } |
|
|
| append(type: string, payload: unknown): WormEntry { |
| const id = uuidv4() |
| const receivedAt = new Date().toISOString() |
| const bodyRaw = JSON.stringify(payload) |
| const chainHash = this.computeHash(id, receivedAt, bodyRaw) |
| const entry: WormEntry = { id, receivedAt, type, payload, chainHash } |
| fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n') |
| this.chainTip = chainHash |
| return entry |
| } |
|
|
| getAll(limit = 100, offset = 0): { entries: WormEntry[]; chainValid: boolean } { |
| if (!fs.existsSync(this.filePath)) return { entries: [], chainValid: true } |
| const lines = fs.readFileSync(this.filePath, 'utf8').trim().split('\n').filter(Boolean) |
| const entries = lines.slice(offset, offset + limit).map(l => JSON.parse(l) as WormEntry) |
| return { entries, chainValid: this.verifyChain() } |
| } |
|
|
| getById(id: string): WormEntry | null { |
| if (!fs.existsSync(this.filePath)) return null |
| const lines = fs.readFileSync(this.filePath, 'utf8').trim().split('\n').filter(Boolean) |
| for (const line of lines) { |
| const entry = JSON.parse(line) as WormEntry |
| if (entry.id === id) return entry |
| } |
| return null |
| } |
|
|
| verifyChain(): boolean { |
| if (!fs.existsSync(this.filePath)) return true |
| const lines = fs.readFileSync(this.filePath, 'utf8').trim().split('\n').filter(Boolean) |
| let prev = 'GENESIS' |
| for (const line of lines) { |
| const entry = JSON.parse(line) as WormEntry |
| const expected = crypto |
| .createHmac('sha256', this.secret) |
| .update(`${prev}:${entry.id}:${entry.receivedAt}:${JSON.stringify(entry.payload)}`) |
| .digest('hex') |
| if (expected !== entry.chainHash) return false |
| prev = entry.chainHash |
| } |
| return true |
| } |
|
|
| tip(): string { |
| return this.chainTip |
| } |
| } |
|
|
