// @CanalQb - Card Authorization Service - Produção
import express from 'express';
import Redis from 'ioredis';

const app = express();
app.use(express.json());
const redis = new Redis(process.env.REDIS_URL);

// Verifica saldo disponível no pool USDC do usuário
async function getUserBalance(userId) {
  const cached = await redis.get(`bal:${userId}`);
  if (cached) return JSON.parse(cached);
  // fallback para DB se cache miss
  return { usd: 0 };
}

// Risk Engine: retorna score 0-1000
async function checkRisk(userId, amount, merchant) {
  const score = await redis.get(`risk:${userId}`);
  return {
    approved: parseInt(score || '700') > 400,
    score: parseInt(score || '700')
  };
}

// Reserva fundos no pool (hold de 30s)
async function reserveFunds(userId, amount, txId) {
  await redis.set(`hold:${txId}`, JSON.stringify({ userId, amount }), 'EX', 30);
  return true;
}

// Endpoint principal de autorização
app.post('/v1/card/authorize', async (req, res) => {
  const { user_id, amount, transaction_id, merchant } = req.body;

  // Idempotência: evita dupla autorização
  const existing = await redis.get(`txn:${transaction_id}`);
  if (existing) return res.json(JSON.parse(existing));

  const [balance, risk] = await Promise.all([
    getUserBalance(user_id),
    checkRisk(user_id, amount, merchant)
  ]);

  if (!risk.approved || balance.usd < amount) {
    const response = { approved: false, reason: 'risk_or_balance' };
    await redis.set(`txn:${transaction_id}`, JSON.stringify(response), 'EX', 60);
    return res.json(response);
  }

  await reserveFunds(user_id, amount, transaction_id);
  const response = {
    approved: true,
    auth_code: `AUTH_${Date.now()}`,
    hold_amount_usd: amount
  };

  await redis.set(`txn:${transaction_id}`, JSON.stringify(response), 'EX', 60);
  return res.json(response);
});

app.listen(3000);

// SPDX-License-Identifier: MIT
// @CanalQb - Token com hooks de liquidez para card issuing
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract CanalQbToken is ERC20, Ownable {

    address public treasury;
    uint256 public liquidityThreshold;

    // Emitido quando o backend precisa rebalancear
    event LiquidityAlert(address indexed from, uint256 amount, uint256 poolBalance);
    event TreasuryRebalance(uint256 tokensBurned, uint256 usdcMinted);

    constructor(address _treasury) ERC20("CanalQbToken", "CQB") Ownable(msg.sender) {
        treasury = _treasury;
        liquidityThreshold = 100_000 * 10**18;
        _mint(msg.sender, 1_000_000 * 10**18);
    }

    // Backend ouve este evento e faz swap automaticamente
    function burnForLiquidity(uint256 amount) external {
        _burn(msg.sender, amount);
        uint256 poolBalance = balanceOf(treasury);
        if (poolBalance < liquidityThreshold) {
            emit LiquidityAlert(msg.sender, amount, poolBalance);
        }
        emit TreasuryRebalance(amount, 0);
    }

    // Recompensa usuários do cartão com tokens
    function mintCardRewards(address to, uint256 amount) external {
        require(msg.sender == treasury, "not treasury");
        _mint(to, amount);
    }
}

import Stripe from 'stripe';
const stripe = new Stripe(process.env.STRIPE_SECRET_KEY);

// 1. Criar cardholder (usuário verificado por KYC)
const cardholder = await stripe.issuing.cardholders.create({
  name: 'João Silva',
  email: 'joao@email.com',
  type: 'individual',
  billing: {
    address: {
      line1: 'Rua Exemplo, 123',
      city: 'São Paulo',
      country: 'BR',
      postal_code: '01310-100'
    }
  }
});

// 2. Emitir cartão virtual
const card = await stripe.issuing.cards.create({
  type: 'virtual',
  currency: 'usd',
  status: 'active',
  cardholder: cardholder.id,
  spending_controls: {
    spending_limits: [{ amount: 50000, interval: 'daily' }]
  }
});

// 3. Webhook de autorização em tempo real
app.post('/stripe/webhook', async (req, res) => {
  const event = stripe.webhooks.constructEvent(
    req.rawBody,
    req.headers['stripe-signature'],
    process.env.STRIPE_WEBHOOK_SECRET
  );

  if (event.type === 'issuing_authorization.request') {
    const auth = event.data.object;
    const amount = auth.pending_request.amount / 100;

    // Chama seu sistema interno
    const approval = await fetch('http://card-service/v1/card/authorize', {
      method: 'POST',
      body: JSON.stringify({ user_id: auth.cardholder, amount, transaction_id: auth.id })
    }).then(r => r.json());

    return res.json({ approved: approval.approved });
  }

  res.sendStatus(200);
});

# card-service deployment - @CanalQb produção
apiVersion: apps/v1
kind: Deployment
metadata:
  name: card-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: card-service
  template:
    spec:
      containers:
        - name: card-service
          image: yourrepo/card-service:latest
          ports:
            - containerPort: 3000
          resources:
            requests:
              memory: "256Mi"
              cpu: "200m"
            limits:
              memory: "1Gi"
              cpu: "1"
          env:
            - name: REDIS_URL
              valueFrom:
                secretKeyRef:
                  name: redis-secret
                  key: url
---
# Auto-scaling baseado em CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: card-service-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: card-service
  minReplicas: 3
  maxReplicas: 50
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60

// Risk Score Engine - @CanalQb
// Score final: 0 (alto risco) a 1000 (baixo risco)

function calculateRiskScore(user, transaction, market) {
  let score = 0;

  // KYC completo: +200 pontos
  score += user.kyc_verified ? 200 : user.kyc_partial ? 80 : 0;

  // Histórico de uso sem chargebacks: +150
  score += user.chargeback_count === 0 ? 150 : Math.max(0, 150 - user.chargeback_count * 100);

  // Penalidade por volatilidade do token nas últimas 24h
  if (market.volatility_24h > 0.5) score -= 300;
  else if (market.volatility_24h > 0.2) score -= 150;

  // Pool de liquidez saudável
  const utilization = market.pool_reserved / market.pool_total;
  if (utilization > 0.8) score -= 200;
  else if (utilization < 0.4) score += 100;

  // Geolocalização consistente: +80
  score += transaction.geo_match ? 80 : -100;

  // Decisão final
  if (score >= 700) return { approved: true, limit_factor: 1.0 };
  if (score >= 400) return { approved: true, limit_factor: 0.5 };
  return { approved: false, reason: 'risk_too_high' };
}

// Modelo de crédito colateralizado - @CanalQb
function calculateCreditLimit(collateral) {
  const { token_value_usd, volatility_30d, risk_score, ltv_ratio } = collateral;

  // LTV base: 50% (conservador para alta volatilidade)
  const base_ltv = 0.5;

  // Penalidade de volatilidade: mais volátil = menos crédito
  const vol_factor = Math.max(0.3, 1 - volatility_30d);

  // Ajuste pelo score do usuário (0-1000 → 0.4-1.0)
  const score_factor = 0.4 + (risk_score / 1000) * 0.6;

  const limit = token_value_usd * base_ltv * vol_factor * score_factor;

  return {
    credit_limit_usd: Math.floor(limit),
    liquidation_threshold: token_value_usd * 1.15, // liquidar se cair 15%
    margin_call_threshold: token_value_usd * 1.25
  };
}

// Exemplo: token = $1.000, vol = 20%, score = 800
// → limite ≈ $1000 × 0.5 × 0.8 × 0.88 = ~$352