caTokens

By minting caTokens, users (1) earn interest through the caToken's exchange rate, which increases in value relative to the underlying asset, and (2) gain the ability to use caTokens as collateral.

caTokens are the primary means of interacting with the CapyFi Protocol; when a user mints, redeems, borrows, repays a borrow, liquidates a borrow, or transfers caTokens, she will do so using the caToken contract.

There are currently two types of caTokens: CErc20 and CEther. Though both types expose the EIP-20 interface, CErc20 wraps an underlying ERC-20 asset, while CEther simply wraps Ether itself.

The mint function transfers an asset into the protocol, which begins accumulating interest based on the current Supply Rate for the asset. The user receives a quantity of caTokens equal to the underlying tokens supplied, divided by the current Exchange Rate.

Erc20 underlying = Erc20(0xToken...);     // get a handle for the underlying asset contract
CErc20 cToken = CErc20(0x3FDA...);        // get a handle for the corresponding cToken contract
underlying.approve(address(cToken), 100); // approve the transfer
assert(cToken.mint(100) == 0);            // mint the caTokens and assert there is no error

const cToken = CEther.at(0x3FDB...);
await cToken.methods.mint().send({from: myAccount, value: 50});

The redeem function converts a specified quantity of caTokens into the underlying asset, and returns them to the user. The amount of underlying tokens received is equal to the quantity of caTokens redeemed, multiplied by the current Exchange Rate.

CEther cToken = CEther(0x3FDB...);
require(cToken.redeem(7) == 0, "something went wrong");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.redeem(1).send({from: ...});

The redeem underlying function converts caTokens into a specified quantity of the underlying asset, and returns them to the user. The amount of caTokens redeemed is equal to the quantity of underlying tokens received, divided by the current Exchange Rate.

CEther cToken = CEther(0x3FDB...);
require(cToken.redeemUnderlying(50) == 0, "something went wrong");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.redeemUnderlying(10).send({from: ...});

The borrow function transfers an asset from the protocol to the user, and creates a borrow balance which begins accumulating interest based on the Borrow Rate for the asset. The amount borrowed must be less than the user's Account Liquidity and the market's available liquidity.

CErc20 cToken = CErc20(0x3FDA...);
require(cToken.borrow(100) == 0, "borrow failed");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.borrow(50).send({from: myAccount});

The repay borrow function transfers an asset into the protocol, reducing the user's borrow balance. The amount repaid must be less than or equal to the user's current borrow balance.

CErc20 cToken = CErc20(0x3FDA...);
require(cToken.repayBorrow(100) == 0, "repay failed");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.repayBorrow(50).send({from: myAccount});

The repay borrow behalf function transfers an asset into the protocol, reducing the target user's borrow balance. The amount repaid must be less than or equal to the target user's current borrow balance.

CErc20 cToken = CErc20(0x3FDA...);
require(cToken.repayBorrowBehalf(borrower, 100) == 0, "repay behalf failed");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.repayBorrowBehalf(borrower, 50).send({from: myAccount});

caTokens can be transferred between accounts, but exercise caution! By transferring caTokens, you're transferring your balance of the underlying asset inside the CapyFi protocol. A caToken transfer will fail if the account has entered that caToken market and the transfer would have put the account into a state of negative liquidity.

CErc20 cToken = CErc20(0x3FDA...);
require(cToken.transfer(recipient, 100), "transfer failed");

const cToken = CErc20.at(0x3FDA...);
cToken.methods.transfer(recipient, 50).send({from: myAccount});

The liquidate borrow function allows users to repay a borrower's debt on behalf of that borrower and in return receive a discounted amount of collateral held by the borrower. This function is used to liquidate undercollateralized accounts.

CErc20 cToken = CErc20(0x3FDA...);
CErc20 collateral = CErc20(0x3FDB...);
require(cToken.liquidateBorrow(borrower, 100, collateral) == 0, "liquidation failed");

const cToken = CErc20.at(0x3FDA...);
const collateral = CErc20.at(0x3FDB...);
cToken.methods.liquidateBorrow(borrower, 50, collateral.address).send({from: myAccount});

Each cToken is convertible into an ever increasing quantity of the underlying asset, as interest accrues in the market. The exchange rate between a cToken and the underlying asset is equal to:

CErc20 cToken = CToken(0x3FDA...);
uint exchangeRateMantissa = cToken.exchangeRateCurrent();

const cToken = CEther.at(0x3FDB...);
const exchangeRate = (await cToken.methods.exchangeRateCurrent().call()) / 1e18;

Cash is the amount of underlying balance owned by this cToken contract. One may query the total amount of cash currently available to this market.

CErc20 cToken = CToken(0x3FDA...);
uint cash = cToken.getCash();

const cToken = CEther.at(0x3FDB...);
const cash = (await cToken.methods.getCash().call());

Total Borrows is the amount of underlying currently loaned out by the market, and the amount upon which interest is accumulated to suppliers of the market.

CErc20 cToken = CToken(0x3FDA...);
uint borrows = cToken.totalBorrowsCurrent();

const cToken = CEther.at(0x3FDB...);
const borrows = (await cToken.methods.totalBorrowsCurrent().call());

A user who borrows assets from the protocol is subject to accumulated interest based on the current borrow rate. Interest is accumulated every block and integrations may use this function to obtain the current value of a user's borrow balance with interest.

CErc20 cToken = CToken(0x3FDA...);
uint borrows = cToken.borrowBalanceCurrent(msg.caller);

const cToken = CEther.at(0x3FDB...);
const borrows = await cToken.methods.borrowBalanceCurrent(account).call();

At any point in time one may query the contract to get the current borrow rate per block.

CErc20 cToken = CToken(0x3FDA...);
uint borrowRateMantissa = cToken.borrowRatePerBlock();

const cToken = CEther.at(0x3FDB...);
const borrowRate = (await cToken.methods.borrowRatePerBlock().call()) / 1e18;

Total Supply is the number of tokens currently in circulation in this cToken market. It is part of the EIP-20 interface of the cToken contract.

CErc20 cToken = CToken(0x3FDA...);
uint tokens = cToken.totalSupply();

const cToken = CEther.at(0x3FDB...);
const tokens = (await cToken.methods.totalSupply().call());

The user's underlying balance, representing their assets in the protocol, is equal to the user's cToken balance multiplied by the Exchange Rate.

CErc20 cToken = CToken(0x3FDA...);
uint tokens = cToken.balanceOfUnderlying(msg.caller);

const cToken = CEther.at(0x3FDB...);
const tokens = await cToken.methods.balanceOfUnderlying(account).call();

At any point in time one may query the contract to get the current supply rate per block. The supply rate is derived from the borrow rate, reserve factor and the amount of total borrows.

CErc20 cToken = CToken(0x3FDA...);
uint supplyRateMantissa = cToken.supplyRatePerBlock();

const cToken = CEther.at(0x3FDB...);
const supplyRate = (await cToken.methods.supplyRatePerBlock().call()) / 1e18;

Reserves are an accounting entry in each cToken contract that represents a portion of historical interest set aside as cash which can be withdrawn or transferred through the protocol's governance. A small portion of borrower interest accrues into the protocol, determined by the reserve factor.

CErc20 cToken = CToken(0x3FDA...);
uint reserves = cToken.totalReserves();

const cToken = CEther.at(0x3FDB...);
const reserves = (await cToken.methods.totalReserves().call());

The reserve factor defines the portion of borrower interest that is converted into reserves.

CErc20 cToken = CToken(0x3FDA...);
uint reserveFactorMantissa = cToken.reserveFactorMantissa();

const cToken = CEther.at(0x3FDB...);
const reserveFactor = (await cToken.methods.reserveFactorMantissa().call()) / 1e18;