Posted By : Suchit
This article explores collateralized loans, a financial frontier where traditional borrowing meets the cutting-edge brilliance of blockchain technology. You'll gain insights into how smart contract development revolutionizes borrowing and lending by creating your own collateralized loan smart contract.
At the heart of collateralized loans lies a fundamental concept: mitigating risk through collateral. Imagine you need funds, and lenders seek assurance. This is where collateral swoops in as the financial guardian. It's not merely a precautionary measure; it's a strategic tool ensuring a trustless secure relationship between borrowers and lenders.
Collateralized loans elevate security that redefines the borrowing and lending landscape. For lenders, these loans inherently offer greater safety than non-collateralized alternatives, leading to lower interest rates.
In the following section, we go through a collateralized loan smart contract named "CryptoCollateralizedLoan" that facilitates the issuance and repayment of loans using ERC-20 tokens as collateral and Ether as borrowed assets. Borrowers can request loans by locking up a specified amount of collateral, and repay the loan along with accrued interest at a later time.
Also, Check | Top 5 Smart Contract Development Companies
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract CryptoCollateralizedLoan {
struct LoanInfo {
address borrower;
uint256 borrowedAmount;
uint256 collateralAmount;
uint256 requestedAt;
bool paid;
}
ERC20 public collateralToken;
uint256 public interestRate;
uint256 public minCollateralizationRatio;
mapping(address => LoanInfo) public loans;
event LoanGranted(
address borrower,
uint256 borrowedAmount,
uint256 collateralAmount
);
event LoanRepaid(address borrower, uint256 repaidAmount);
constructor(
ERC20 _collateralToken,
uint256 _interestRate,
uint256 _minCollateralizationRatio
) {
collateralToken = _collateralToken;
interestRate = _interestRate;
minCollateralizationRatio = _minCollateralizationRatio;
}
function requestLoan(
uint256 _borrowedAmount,
uint256 _collateralAmount
) public {
LoanInfo storage initialLoanInfo = loans[msg.sender];
require(
initialLoanInfo.collateralAmount == 0 ||
(initialLoanInfo.collateralAmount > 0 &&
initialLoanInfo.paid == true),
"Active loan"
);
uint256 extraAmountToliquidate = (_borrowedAmount *
minCollateralizationRatio) / 100;
require(
_collateralAmount >= (_borrowedAmount + extraAmountToliquidate),
"Insufficient collateral"
);
collateralToken.transferFrom(
msg.sender,
address(this),
_collateralAmount
);
LoanInfo memory loanInfo = LoanInfo({
borrower: msg.sender,
borrowedAmount: _borrowedAmount,
collateralAmount: _collateralAmount,
requestedAt: block.timestamp,
paid: false
});
_sendEthersTo(msg.sender, loanInfo.borrowedAmount);
loans[msg.sender] = loanInfo;
emit LoanGranted(msg.sender, _borrowedAmount, _collateralAmount);
}
function repayLoan() public payable {
LoanInfo storage loanInfo = loans[msg.sender];
require(loanInfo.borrowedAmount > 0, "No active loan");
uint256 collateralizationRatio = _calculateCollateralizationRatio(
loanInfo
);
require(
collateralizationRatio < minCollateralizationRatio,
"Collateralization ratio above minimum"
);
uint256 outstandingAmount = _calculateOutstandingAmount(loanInfo);
require(msg.value >= outstandingAmount, "Insufficient funds");
collateralToken.transfer(msg.sender, loanInfo.collateralAmount);
loanInfo.paid = true;
emit LoanRepaid(msg.sender, loanInfo.borrowedAmount);
}
function _sendEthersTo(
address _receiver,
uint256 _amount
) private returns (bool) {
(bool sent, ) = payable(_receiver).call{value: _amount}("");
require(sent, "Ether transfer failed");
return sent;
}
function _calculateOutstandingAmount(
LoanInfo storage loanInfo
) private view returns (uint256) {
uint256 timeElapsed = block.timestamp - loanInfo.requestedAt;
uint256 interestAccrued = (loanInfo.borrowedAmount *
interestRate *
timeElapsed) / (100 * 365 days);
return loanInfo.borrowedAmount + interestAccrued;
}
function _calculateCollateralizationRatio(
LoanInfo storage loanInfo
) private view returns (uint256) {
uint256 outstandingAmount = _calculateOutstandingAmount(loanInfo);
uint256 diff = outstandingAmount - loanInfo.borrowedAmount;
return
(diff * 100) /
loanInfo.borrowedAmount;
}
receive() external payable {}
}
This contract, named CryptoCollateralizedLoan, utilizes the Ethereum blockchain to implement a secure, transparent, and efficient framework for collateralized loans.
Let's dissect the variables, events, and functions embedded within this smart contract to gain a comprehensive understanding of its inner workings and the advantages it offers to both borrowers and lenders alike.
Also, Read | Code Analysis Tools for Solidity Smart Contracts
You may also like | Best Practices for Smart Contract Development
By leveraging the power of blockchain technology, this contract introduces a secure and transparent platform for collateralized loans. By leveraging collateral as a key feature, this contract establishes a trustless framework that empowers borrowers and lenders.
Looking for smart contract development services? Get in touch with our smart contract developers to discuss your project requirements.
September 8, 2024 at 02:36 am
Your comment is awaiting moderation.