Integration testing

clarinet new defi
cd defi

npm install

clarinet contract new defi

;; Error constants for various failure scenarios.
(define-constant err-overborrow (err u300))

;; The interest rate for loans, represented as 10% (out of a base of 100).
(define-data-var loan-interest-rate uint u10) ;; Representing 10% interest rate


;; Holds the total amount of deposits in the contract, initialized to 0.
(define-data-var total-deposits uint u0)

;; Maps a user's principal address to their deposited amount.
(define-map deposits { owner: principal } { amount: uint })

;; Maps a borrower's principal address to their loan details: amount and the last interaction block.
(define-map loans principal { amount: uint, last-interaction-block: uint })

;; Public function for users to deposit STX into the contract.
;; Updates their balance and the total deposits in the contract.
(define-public (deposit (amount uint))
  (let
    (
      ;; Fetch the current balance or default to 0 if none exists.
      (current-balance (default-to u0 (get amount (map-get? deposits { owner: tx-sender }))))
    )
    ;; Transfer the STX from sender = "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM" to recipient = "ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.defi (ie: contract identifier on the chain!)".
    (try! (stx-transfer? amount tx-sender (as-contract tx-sender)))
    ;; Update the user's deposit amount in the map.
    (map-set deposits { owner: tx-sender } { amount: (+ current-balance amount) })
    ;; Update the total deposits variable.
    (var-set total-deposits (+ (var-get total-deposits) amount))
    ;; Return success.
    (ok true)
  )
)

;; Public function for users to borrow STX based on their deposits.
(define-public (borrow (amount uint))
  (let
    (
      ;; Fetch user's deposit or default to 0.
      (user-deposit (default-to u0 (get amount (map-get? deposits { owner: tx-sender }))))
      ;; Calculate the maximum amount the user is allowed to borrow. (which will be upto HALF of what they deposited)
      (allowed-borrow (/ user-deposit u2))
      ;; Fetch current loan details or default to initial values.
      (current-loan-details (default-to { amount: u0, last-interaction-block: u0 } (map-get? loans tx-sender )))
      ;; Calculate accrued interest on the current loan.
      (accrued-interest (calculate-accrued-interest (get amount current-loan-details) (get last-interaction-block current-loan-details)))
      ;; Calculate the total amount due including interest.
      (total-due (+ (get amount current-loan-details) (unwrap-panic accrued-interest)))
      ;; Calculate the new loan total after borrowing additional amount.
      (new-loan (+ amount))
    )
    ;; Ensure the requested borrow amount does not exceed the allowed amount.
    (asserts! (<= new-loan allowed-borrow) err-overborrow)
    ;; Transfer the borrowed STX to the user.
    (let
      (
        (recipient tx-sender)
      )
      (try! (as-contract (stx-transfer? amount tx-sender recipient)))
    )
    ;; Update the user's loan details in the map.
    (map-set loans tx-sender { amount: new-loan, last-interaction-block: block-height })
    ;; Return success.
    (ok true)
  )
)

;; Read-only function to get the total balance by tx-sender
(define-read-only (get-balance-by-sender)
  (ok (map-get? deposits { owner: tx-sender }))
)

;; Private function to calculate the accrued interest on a loan.
(define-private (calculate-accrued-interest (principal uint) (start-block uint))
  (let
    (
      ;; Calculate the number of blocks elapsed since the last interaction.
      (elapsed-blocks (- block-height start-block))
      ;; Calculate the interest based on the principal, rate, and elapsed time.
      (interest (/ (* principal (var-get loan-interest-rate) elapsed-blocks) u10000))
    )
    ;; Ensure the loan started in the past (not at block 0).
    (asserts! (not (is-eq start-block u0)) (ok u0))
    ;; Return the calculated interest.
    (ok interest)
  )
)

import { describe, it, expect } from "vitest";
import { Cl, cvToValue } from "@stacks/transactions";

const accounts = simnet.getAccounts();
const deployer = accounts.get("deployer")!;
const wallet1 = accounts.get("wallet_1")!;

describe("stx-defi", () => {
  it('borrows 10 and verifies the amount owed to be 10', () => {
    // wallet1 deposits 1000 to "their principal", which will be "locked" in the contract (on the chain)
    simnet.callPublicFn('stx-defi', 'deposit', [Cl.uint(1000)], wallet1);
    const totalDeposits = simnet.getDataVar('stx-defi', 'total-deposits');
    expect(totalDeposits).toBeUint(1000);

    // wallet1 attempts to borrow 10 from their initial deposit for 1000 (which is "locked" in the contract, on the chain)
    const borrowResponse = simnet.callPublicFn('stx-defi', 'borrow', [Cl.uint(10)], wallet1);
    console.log("borrow response: " + Cl.prettyPrint(borrowResponse.result));
    
    // verify the amount owed is exactly what the wallet1 borrowed, which is 10 (because borrow and owed check are happening on the 
    // "same block", so no interest will be applied)
    const { result } = simnet.callReadOnlyFn('stx-defi', 'get-amount-owed', [], wallet1);
    console.log("owed amount: " + Cl.prettyPrint(result));
    expect(result).toBeOk(Cl.uint(10));
  });
});

npm run test

npm run coverage