Lending with RainFi

const quoteLoanCalculatorAction: Action = {
  name: "RAINFI_QUOTE_LOAN_CALCULATOR",
  description: "Calculate the loan quote for a given amount and currency",
  schema: z.object({
    amountIn: z.number().describe("Amount to borrow (in smallest units)"),
    currencyIn: z.string().describe("Input currency address"),
    currencyOut: z.string().describe("Output currency address"),
    borrower: z.string().describe("Borrower's wallet address"),
  }),
  handler: async (agent, input) => {
    const loanTransactionRequest = await quoteLoanCalculator({
      amountIn: input.amountIn,
      currencyIn: input.currencyIn,
      currencyOut: input.currencyOut,
      borrower: agent.wallet.publicKey.toString(),
    });

    return {
      status: "success",
      message: "Loan quote calculated successfully",
      loanTransactionRequest,
    };
  },
};

{
  borrower: "2gLAprD3LUJrSGdcXv88Nvi1ZfHRqpaL7c84SV7M4XWs",
  amountIn: 1000000000,  // 1 SOL in lamports
  currencyIn: "So11111111111111111111111111111111111111112",  // SOL
  currencyOut: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
  simulation: {
    amount: 1000000000,      // Loan amount
    duration: 7,             // 7 days
    interest: "0.1",         // Interest amount
    rainFees: 0.01,          // Protocol fees
    apr: 5.2,                // Annual percentage rate
    authorization: "abc123",  // Authorization token
    bank: "rainfi-bank-1",   // Lending pool
    pool: "main",            // Pool identifier
    baseAmount: 1000000000,  // Base loan amount
    currency: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
  },
  options: {
    prioritizationFeeLamports: "fast"
  },
  slippage: 50  // 0.5% slippage
}

"Build loan transaction with my quote"
"Execute rainfi loan"

const rainfiTransactionBuilderAction: Action = {
  name: "RAINFI_TRANSACTION_BUILDER",
  description: "Build and execute a loan transaction on Rainfi",
  schema: loanTransactionRequestSchema,
  handler: async (agent, input) => {
    const loanRequest = loanTransactionRequestSchema.parse(input);
    const tx = await RainfiTransactionBuilder(agent, loanRequest);

    return {
      status: "success",
      message: "Loan transaction executed successfully",
      signature: tx.toString(),
      transaction: {
        borrower: loanRequest.borrower,
        amountIn: loanRequest.amountIn,
        currencyIn: loanRequest.currencyIn,
        currencyOut: loanRequest.currencyOut,
      },
    };
  },
};

interface TransactionOptions {
  prioritizationFeeLamports: string;  // "fast", "medium", "slow"
  maxFeeCapLamports?: number;         // Maximum fee cap
  jitoTipLamports?: number;           // MEV protection tip
}

const rainfiGetUserLoansAction: Action = {
  name: "RAINFI_GET_USER_LOANS",
  description: "Get user loans from Rainfi",
  handler: async (agent) => {
    const address = agent.wallet.publicKey.toString();
    const { loans } = await GetUserLoans({ address });

    return {
      status: "success",
      message: "User loans fetched successfully",
      loans,
    };
  },
};

{
  pubkey: "loan_address",
  borrower: "your_wallet_address",
  status: "Active",
  borrowedAmount: "100000000",      // Amount borrowed
  collateralAmount: "1000000000",   // Collateral locked
  principal: "address",             // Principal token
  collateral: "address",            // Collateral token
  interest: "10",                   // Interest (10 = 0.1%)
  duration: 604800,                 // Duration in seconds
  expiredAt: "2024-03-10T12:00:00Z",
  liquidation: 80,                  // Liquidation threshold (80%)
  metadata: {
    borrowedAmountUsd: "100.00",
    collateralAmountUsd: "125.00",
    lender: "lender_address"
  }
}

const rainfiRepayLoanAction: Action = {
  name: "RAINFI_REPAY_LOAN",
  description: "Repay a loan from Rainfi",
  schema: repayLoanRequestSchema,
  handler: async (agent, input) => {
    const repayLoanRequest = repayLoanRequestSchema.parse(input);
    const tx = await RepayLoan(agent, {
      ...repayLoanRequest,
      isDefi: true,
    });

    return {
      status: "success",
      message: "Loan repaid successfully",
      signature: tx.toString(),
    };
  },
};

Interest amount = Principal × (APR/365) × (Duration in days)

5% APR for 7 days = 0.096% interest
5% APR for 30 days = 0.41% interest
5% APR for 365 days = 5% interest

Collateral Value / Borrowed Value < Liquidation Threshold

Borrow: 100 USDC
Collateral: 1 SOL (worth $125)
Threshold: 80%

Safe if: ($125 / $100) × 100 = 125% > 80% ✅
Liquidation if: SOL drops to < $80 ❌

Loan-to-Value (LTV): 50-60%
Buffer: Large safety margin
Duration: Short-term (7-14 days)

LTV: 60-70%
Buffer: Moderate safety margin
Duration: Medium-term (14-30 days)

LTV: 70-80%
Buffer: Minimal safety margin
Duration: Any duration

interface PoolConditions {
  minAge: string;              // Minimum collateral token age
  minLoan: string;             // Minimum loan amount
  minVolume: string;           // Minimum trading volume
  liquidationThreshold: number; // Liquidation ratio
  isEnabled: boolean;          // Pool active status
  whitelist: string;           // Whitelist address (if any)
}

interface PoolCurrency {
  currency: number;        // Currency ID
  currencyLtv: number;     // Loan-to-value ratio
  exposure: number;        // Pool exposure
  borrowedAmount: string;  // Total borrowed
}

Borrow: 100 USDC
Duration: 30 days
APR: 5%

Interest: 100 × 0.05 × (30/365) = 0.41 USDC
Rain Fee: 0.01 USDC
Network Fee: ~0.00001 SOL

Total Repayment: 100.42 USDC + gas