These docs are a comprehensive guide to the ChumHum protocol, based on the ChumHum Whitepaper (Feb 2021). The protocol codebase is hosted on Github, and maintained by the community.

Please join the #development room in the ChumHum community Discord server; our team, and members of the community, look forward to helping you build an application on top of ChumHum. Your questions help us improve, so please don't hesitate to ask if you can't find what you are looking for here.


Setting up an Matic Chain Development Environment

Supplying Assets to the ChumHum Protocol

Borrowing Assets from the ChumHum Protocol

Create a ChumHum API with Infura

Building a Governance Interface

Delegation & Voting

Contributing to the Protocol


The ChumHum Protocol is currently deployed on the following networks:

You can also see a full list of all deployed contract addresses here.

Protocol Math

The ChumHum protocol contracts use a system of exponential math, Exponential.sol, in order to represent fractional quantities with sufficient precision.

Most numbers are represented as a mantissa, an unsigned integer scaled by 1 * 10 ^ 18, in order to perform basic math at a high level of precision.

cToken and Underlying Decimals

Prices and exchange rates are scaled by the decimals unique to each asset; cTokens are ERC-20 tokens with 8 decimals, while their underlying tokens vary, and have a public member named decimals.

cToken cToken Decimals Underlying Underlying Decimals
cWETH 8 BAT 18

Interpreting Exchange Rates

The cToken Exchange Rate is scaled by the difference in decimals between the cToken and the underlying asset.

oneCTokenInUnderlying = exchangeRateCurrent / (1 * 10 ^ (18 + underlyingDecimals - cTokenDecimals))

Here is an example of finding the value of 1 cBAT in BAT with Web3.js JavaScript.

const cTokenDecimals = 8; // all cTokens have 8 decimal places
const underlying = new web3.eth.Contract(erc20Abi, wethAddress);
const cToken = new web3.eth.Contract(cTokenAbi, cWETHAddress);
const underlyingDecimals = await underlying.methods.decimals().call();
const exchangeRateCurrent = await cToken.methods.exchangeRateCurrent().call();
const mantissa = 18 + parseInt(underlyingDecimals) - cTokenDecimals;
const oneCTokenInUnderlying = exchangeRateCurrent / Math.pow(10, mantissa);
console.log('1 cWETH can be redeemed for', oneCTokenInUnderlying, 'WETH');

There is no underlying contract for MATIC, so to do this with cMATIC, set underlyingDecimals to 18.

To find the number of underlying tokens that can be redeemed for cTokens, multiply the number of cTokens by the above value oneCTokenInUnderlying.

underlyingTokens = cTokenAmount * oneCTokenInUnderlying

Calculating Accrued Interest

Interest rates for each market update on any block in which the ratio of borrowed assets to supplied assets in the market has changed. The amount interest rates are changed depends on the interest rate model smart contract implemented for the market, and the amount of change in the ratio of borrowed assets to supplied assets in the market.

See the interest rate data visualization notebook on Observable to visualize which interest rate model is currently applied to each market.

Historical interest rates can be retrieved from the MarketHistoryService API.

Interest accrues to all suppliers and borrowers in a market when any Matic Chain address interacts with the market’s cToken contract, calling one of these functions: mint, redeem, borrow, or repay. Successful execution of one of these functions triggers the accrueInterest method, which causes interest to be added to the underlying balance of every supplier and borrower in the market. Interest accrues for the current block, as well as each prior block in which the accrueInterest method was not triggered (no user interacted with the cToken contract). Interest compounds only during blocks in which the cToken contract has one of the aforementioned methods invoked.

Here is an example of supply interest accrual:

Alice supplies 1 MATIC to the ChumHum protocol. At the time of supply, the supplyRatePerBlock is 37893605 Wei, or 0.000000000037893605 MATIC per block. No one interacts with the cMATIC contract for 3 Matic Chain blocks. On the subsequent 4th block, Bob borrows some MATIC. Alice’s underlying balance is now 1.000000000151574420 MATIC (which is 37893605 Wei times 4 blocks, plus the original 1 MATIC). Alice’s underlying MATIC balance in subsequent blocks will have interest accrued based on the new value of 1.000000000151574420 MATIC instead of the initial 1 MATIC. Note that the supplyRatePerBlock value may change at any time.

Calculating the APY Using Rate Per Block

The Annual Percentage Yield (APY) for supplying or borrowing in each market can be calculated using the value of supplyRatePerBlock (for supply APY) or borrowRatePerBlock (for borrow APY) in this formula:

Rate = cToken.supplyRatePerBlock(); // Integer
Rate = 37893566
MATIC Mantissa = 1 * 10 ^ 18 (MATIC has 18 decimal places)
Blocks Per Day = 4 * 60 * 24 (based on 4 blocks occurring every minute)
Days Per Year = 365
APY = ((((Rate / MATIC Mantissa * Blocks Per Day + 1) ^ Days Per Year)) - 1) * 100

Here is an example of calculating the supply and borrow APY with Web3.js JavaScript:

const maticMantissa = 1e18;
const blocksPerDay = 30 * 60 * 24;
const daysPerYear = 365;
const cToken = new web3.eth.Contract(cMATICAbi, cMATICAddress);
const supplyRatePerBlock = await cToken.methods.supplyRatePerBlock().call();
const borrowRatePerBlock = await cToken.methods.borrowRatePerBlock().call();
const supplyApy = (((Math.pow((supplyRatePerBlock / maticMantissa * blocksPerDay) + 1, daysPerYear))) - 1) * 100;
const borrowApy = (((Math.pow((borrowRatePerBlock / maticMantissa * blocksPerDay) + 1, daysPerYear))) - 1) * 100;
console.log(`Supply APY for MATIC ${supplyApy} %`);
console.log(`Borrow APY for MATIC ${borrowApy} %`);

Gas Costs

The gas usage of the protocol functions may fluctuate by market and user. External calls, such as to underlying ERC-20 tokens, may use an arbitrary amount of gas. Any calculations that involve checking account liquidity, have gas costs that increase with the number of entered markets. Thus, while it can be difficult to provide any guarantees about costs, we provide the table below for guidance:

Function Typical Gas Cost
Mint < 150K, cUSDT < 300k
Redeem, Transfer < 250K if borrowing, otherwise < 90K
Borrow < 300K
Repay Borrow < 90K
Liquidate Borrow < 400K