Token Unwrapping

const minimumFollowupUnwrapAmountWei = "100000000000000000000" // 100 SFLUV

{
  "wallet_address": "0xuser...",
  "amount_wei": "50000000000000000000"  // 50 SFLUV
}

userDid := utils.GetDid(r)
if userDid == nil {
    w.WriteHeader(http.StatusUnauthorized)
    return
}

if req.WalletAddress == "" || req.AmountWei == "" {
    w.WriteHeader(http.StatusBadRequest)
    return
}

amountWei := new(big.Int)
if _, ok := amountWei.SetString(req.AmountWei, 10); !ok || amountWei.Sign() <= 0 {
    w.WriteHeader(http.StatusBadRequest)
    return
}

wallet, err := a.db.GetWalletByUserAndAddress(r.Context(), *userDid, req.WalletAddress)
if err != nil {
    if err == pgx.ErrNoRows {
        w.WriteHeader(http.StatusForbidden)
        return
    }
    // ...
}

if !wallet.IsRedeemer {
    resp := structs.UnwrapEligibilityResponse{
        Allowed:                  false,
        Reason:                   "Wallet is not unwrap-enabled",
        LastUnwrapAt:             wallet.LastUnwrapAt,
        MinimumFollowupAmountWei: minimumFollowupUnwrapAmountWei.String(),
    }
    // ...
    w.WriteHeader(http.StatusForbidden)
    w.Write(bytes)
    return
}

func isSameUTCMonth(t1 time.Time, t2 time.Time) bool {
    a := t1.UTC()
    b := t2.UTC()
    return a.Year() == b.Year() && a.Month() == b.Month()
}

now := time.Now().UTC()
allowed := true
reason := ""

if wallet.LastUnwrapAt != nil && 
   isSameUTCMonth(*wallet.LastUnwrapAt, now) && 
   amountWei.Cmp(minimumFollowupUnwrapAmountWei) < 0 {
    allowed = false
    reason = "You already unwrapped this month. Additional unwraps this month must be at least $100."
}

{
  "allowed": true,
  "reason": "",
  "last_unwrap_at": "2026-02-15T10:30:00Z",
  "minimum_followup_amount_wei": "100000000000000000000"
}

{
  "allowed": false,
  "reason": "Wallet is not unwrap-enabled",
  "last_unwrap_at": null,
  "minimum_followup_amount_wei": "100000000000000000000"
}

{
  "allowed": false,
  "reason": "You already unwrapped this month. Additional unwraps this month must be at least $100.",
  "last_unwrap_at": "2026-03-01T10:30:00Z",
  "minimum_followup_amount_wei": "100000000000000000000"
}

{
  "wallet_address": "0xuser..."
}

userDid := utils.GetDid(r)
if userDid == nil {
    w.WriteHeader(http.StatusUnauthorized)
    return
}

if req.WalletAddress == "" {
    w.WriteHeader(http.StatusBadRequest)
    return
}

wallet, err := a.db.GetWalletByUserAndAddress(r.Context(), *userDid, req.WalletAddress)
if err != nil {
    if err == pgx.ErrNoRows {
        w.WriteHeader(http.StatusForbidden)
        return
    }
    // ...
}
if !wallet.IsRedeemer {
    w.WriteHeader(http.StatusForbidden)
    return
}

recordedAt := time.Now().UTC()
if err := a.db.SetWalletLastUnwrapAt(r.Context(), *wallet.Id, recordedAt); err != nil {
    a.logger.Logf("error setting wallet last_unwrap_at wallet_id=%d user=%s: %s", *wallet.Id, *userDid, err)
    w.WriteHeader(http.StatusInternalServerError)
    return
}

{
  "recorded": true,
  "recorded_at": "2026-03-04T15:30:00Z"
}

// Check eligibility
const checkEligibility = async (walletAddress: string, amountWei: string) => {
  const res = await authFetch("/unwrap/check-eligibility", {
    method: "POST",
    body: JSON.stringify({ wallet_address: walletAddress, amount_wei: amountWei })
  })
  
  if (!res.ok) {
    const data = await res.json()
    throw new Error(data.reason || "Unwrap not allowed")
  }
  
  return res.json()
}

// Execute unwrap transaction
const unwrapTokens = async (walletAddress: string, amountWei: bigint) => {
  // 1. Check eligibility
  const eligibility = await checkEligibility(walletAddress, amountWei.toString())
  
  if (!eligibility.allowed) {
    throw new Error(eligibility.reason)
  }
  
  // 2. Execute blockchain transaction
  const tx = await unwrapContract.unwrap(amountWei)
  await tx.wait()
  
  // 3. Record unwrap
  const recordRes = await authFetch("/unwrap/record", {
    method: "POST",
    body: JSON.stringify({ wallet_address: walletAddress })
  })
  
  if (!recordRes.ok) {
    console.error("Failed to record unwrap")
  }
  
  return tx.hash
}

CREATE TABLE wallets (
  id SERIAL PRIMARY KEY,
  user_id TEXT NOT NULL,
  address TEXT NOT NULL,
  is_redeemer BOOLEAN DEFAULT false,
  last_unwrap_at TIMESTAMP,
  created_at TIMESTAMP DEFAULT NOW(),
  updated_at TIMESTAMP DEFAULT NOW(),
  UNIQUE(user_id, address)
);

interface UnwrapEligibilityRequest {
  wallet_address: string
  amount_wei: string  // bigint as string
}

interface UnwrapEligibilityResponse {
  allowed: boolean
  reason: string
  last_unwrap_at: string | null  // ISO timestamp
  minimum_followup_amount_wei: string
}

interface UnwrapRecordRequest {
  wallet_address: string
}

interface UnwrapRecordResponse {
  recorded: boolean
  recorded_at: string  // ISO timestamp
}

-- Check wallet redeemer status
SELECT id, address, is_redeemer, last_unwrap_at 
FROM wallets 
WHERE LOWER(address) = LOWER('0xuser...');

-- Find all redeemer wallets
SELECT user_id, address, last_unwrap_at 
FROM wallets 
WHERE is_redeemer = true;

-- Check recent unwraps
SELECT address, last_unwrap_at 
FROM wallets 
WHERE last_unwrap_at > NOW() - INTERVAL '30 days'
ORDER BY last_unwrap_at DESC;

-- Find users with multiple redeemer wallets
SELECT user_id, COUNT(*) as redeemer_count 
FROM wallets 
WHERE is_redeemer = true 
GROUP BY user_id 
HAVING COUNT(*) > 1;