Security & Guardrails

┌─────────────────────────────────────────┐
│  Agent Decision                         │
│  "Swap 0.5 SOL for USDC"                │
└────────────┬────────────────────────────┘
             ↓
┌─────────────────────────────────────────┐
│  Guardrails Validation                  │
│  ✓ Per-tx limit (0.5 < 2.0 SOL)        │
│  ✓ Rate limit (1/min < 5/min)          │
│  ✓ Daily limit (0.5 < 10.0 SOL/day)    │
│  ✓ Program allowlist (Jupiter OK)      │
│  ✓ Blocked addresses (none)            │
└────────────┬────────────────────────────┘
             ↓
┌─────────────────────────────────────────┐
│  Transaction Execution                  │
│  Build → Sign → Send                    │
└────────────┬────────────────────────────┘
             ↓
┌─────────────────────────────────────────┐
│  Audit Logging                          │
│  Record to data/logs/transactions.jsonl │
└─────────────────────────────────────────┘

export interface GuardrailConfig {
  maxSolPerTransaction: number        // Max SOL per single transaction
  maxTransactionsPerMinute: number    // Rate limit
  dailySpendingLimitSol: number       // Max SOL spent per 24 hours
  allowedPrograms: string[]           // Whitelist of Solana programs
  blockedAddresses: string[]          // Blacklist of recipient addresses
}

export const DEFAULT_GUARDRAIL_CONFIG: GuardrailConfig = {
  maxSolPerTransaction: 2.0,
  maxTransactionsPerMinute: 5,
  dailySpendingLimitSol: 10.0,
  allowedPrograms: [
    '11111111111111111111111111111111',           // System Program
    'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', // SPL Token Program
    'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL', // Associated Token Program
    'JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4',  // Jupiter v6
    'Stake11111111111111111111111111111111111111',  // Stake Program
    'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s',  // Token Metadata Program
  ],
  blockedAddresses: [],
}

export class Guardrails {
  private config: GuardrailConfig
  private windows: Map<string, TransactionWindow> = new Map()

  validate(
    walletId: string,
    amountSol: number,
    programIds: string[] = [],
    destinationAddress?: string,
  ): { allowed: boolean; reason?: string; guardrails: string[] } {
    const applied: string[] = []

    // 1. Spending limit per transaction
    applied.push('max_per_tx')
    if (amountSol > this.config.maxSolPerTransaction) {
      return {
        allowed: false,
        reason: `Amount ${amountSol} SOL exceeds per-transaction limit of ${this.config.maxSolPerTransaction} SOL`,
        guardrails: applied,
      }
    }

    // 2. Rate limiting
    applied.push('rate_limit')
    const window = this.getWindow(walletId)
    const now = Date.now()
    const recentTxCount = window.timestamps.filter(
      (t) => now - t < 60_000,
    ).length

    if (recentTxCount >= this.config.maxTransactionsPerMinute) {
      return {
        allowed: false,
        reason: `Rate limit exceeded: ${recentTxCount}/${this.config.maxTransactionsPerMinute} transactions per minute`,
        guardrails: applied,
      }
    }

    // 3. Daily spending limit
    applied.push('daily_limit')
    this.resetDailyIfNeeded(window)
    if (window.dailySpend + amountSol > this.config.dailySpendingLimitSol) {
      return {
        allowed: false,
        reason: `Daily spending limit exceeded: ${window.dailySpend.toFixed(4)} + ${amountSol} > ${this.config.dailySpendingLimitSol} SOL`,
        guardrails: applied,
      }
    }

    // 4. Program allowlist
    if (this.config.allowedPrograms.length > 0 && programIds.length > 0) {
      applied.push('program_allowlist')
      const disallowed = programIds.filter(
        (p) => !this.config.allowedPrograms.includes(p),
      )
      if (disallowed.length > 0) {
        return {
          allowed: false,
          reason: `Programs not in allowlist: ${disallowed.join(', ')}`,
          guardrails: applied,
        }
      }
    }

    // 5. Blocked addresses
    if (
      destinationAddress &&
      this.config.blockedAddresses.includes(destinationAddress)
    ) {
      applied.push('blocked_address')
      return {
        allowed: false,
        reason: `Destination address is blocked: ${destinationAddress}`,
        guardrails: applied,
      }
    }

    return { allowed: true, guardrails: applied }
  }

  recordTransaction(walletId: string, amountSol: number): void {
    const window = this.getWindow(walletId)
    window.timestamps.push(Date.now())
    window.dailySpend += amountSol
  }
}

const guardrails = new Guardrails()

// Check current config
console.log(guardrails.getConfig())

// Update specific limits
guardrails.updateConfig({
  maxSolPerTransaction: 5.0,
  dailySpendingLimitSol: 20.0,
})

// Add a program to the allowlist
const currentConfig = guardrails.getConfig()
guardrails.updateConfig({
  allowedPrograms: [...currentConfig.allowedPrograms, 'NewProgramID'],
})

const info = guardrails.getSpendingInfo('wallet-id')
console.log(info)
// {
//   recentTxCount: 2,         // Transactions in the last minute
//   dailySpend: 3.5,          // SOL spent today
//   dailyRemaining: 6.5,      // SOL remaining for today
//   perTxLimit: 2.0           // Max per transaction
// }

async transferSol(
  walletId: string,
  toAddress: string,
  amountSol: number,
  agentId?: string,
): Promise<TransactionRecord> {
  const record = this.createRecord(walletId, 'transfer', agentId, {
    to: toAddress,
    amount: amountSol,
    token: 'SOL',
  })

  try {
    // Validate with guardrails
    const validation = this.guardrails.validate(
      walletId,
      amountSol,
      [SystemProgram.programId.toBase58()],
      toAddress,
    )
    record.guardrailsApplied = validation.guardrails

    if (!validation.allowed) {
      record.status = 'blocked'
      record.error = validation.reason
      this.logger.logTransaction(record)
      this.logger.logEvent({ type: 'transaction:blocked', data: record })
      return record  // Transaction blocked
    }

    // Build and send transaction
    const keypair = await this.walletManager.getKeypair(walletId)
    const connection = getConnection()
    const transaction = new Transaction().add(
      SystemProgram.transfer({
        fromPubkey: keypair.publicKey,
        toPubkey: new PublicKey(toAddress),
        lamports: Math.round(amountSol * LAMPORTS_PER_SOL),
      }),
    )

    const signature = await sendAndConfirmTransaction(
      connection,
      transaction,
      [keypair],
    )

    // Record success
    record.status = 'confirmed'
    record.signature = signature
    this.guardrails.recordTransaction(walletId, amountSol)

    this.logger.logTransaction(record)
    this.logger.logEvent({ type: 'transaction:confirmed', data: record })
    return record
  } catch (error: any) {
    record.status = 'failed'
    record.error = error.message
    this.logger.logTransaction(record)
    return record
  }
}

export class AuditLogger {
  private logDir: string  // Default: data/logs/

  logTransaction(record: TransactionRecord): void {
    const file = path.join(this.logDir, 'transactions.jsonl')
    fs.appendFileSync(file, JSON.stringify(record) + '\n')
  }

  logDecision(decision: AgentDecision): void {
    const file = path.join(this.logDir, `agent-${decision.agentId}.jsonl`)
    fs.appendFileSync(file, JSON.stringify(decision) + '\n')
  }

  logEvent(event: KarenEvent): void {
    const file = path.join(this.logDir, 'events.jsonl')
    const entry = { ...event, timestamp: new Date().toISOString() }
    fs.appendFileSync(file, JSON.stringify(entry) + '\n')
  }

  getTransactions(walletId?: string, limit: number = 50): TransactionRecord[] {
    // Read from transactions.jsonl and filter by walletId
  }

  getDecisions(agentId: string, limit: number = 50): AgentDecision[] {
    // Read from agent-{agentId}.jsonl
  }
}

const logger = new AuditLogger()

const unsubscribe = logger.onEvent((event) => {
  if (event.type === 'transaction:blocked') {
    console.warn('Transaction blocked:', event.data)
    // Send alert, update dashboard, etc.
  }
})

// Later: unsubscribe()

export interface TransactionRecord {
  id: string
  walletId: string
  agentId?: string
  type: TransactionType
  status: TransactionStatus  // 'pending' | 'confirmed' | 'failed' | 'blocked'
  signature?: string
  details: TransactionDetails
  guardrailsApplied: string[]
  timestamp: string
  error?: string
}

export interface AgentDecision {
  agentId: string
  cycle: number
  observations: Record<string, unknown>
  reasoning: string
  action: SkillInvocation | null
  outcome?: string
  timestamp: string
}