Understanding approve and depositCollateral: The Core of ERC-20 Token Transfers in Solidity

prince — Mon, 25 Nov 2024 12:25:25 +0000

If you're diving into Solidity development, particularly in the realm of DeFi, you'll often encounter patterns like approve and depositCollateral. These functions form the backbone of how ERC-20 tokens are transferred and managed within smart contracts. Let's break it down so you can master this concept!

What Are We Looking At?
Here's the code snippet we’ll analyze:

ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);
dsce.depositCollateral(weth, AMOUNT_COLLATERAL);

Grants a smart contract permission to transfer a specific amount of tokens on behalf of the user.
Executes the actual transfer of those tokens into the smart contract as collateral.

First Step: approve
What Does It Do?
The approve function allows a user to authorize another address (typically a smart contract) to spend tokens on their behalf. This is part of the ERC-20 token standard and is essential for enabling interactions between users and DeFi protocols.

Breaking It Down:
solidity

ERC20Mock(weth).approve(address(dsce), AMOUNT_COLLATERAL);

ERC20Mock(weth): Represents the token contract (mocked here for testing) deployed at the weth address.
.approve(address(dsce), AMOUNT_COLLATERAL): Authorizes the dsce contract to spend up to AMOUNT_COLLATERAL worth of weth tokens on the user’s behalf.

How It Works Behind the Scenes:
The ERC-20 token contract maintains an internal mapping called allowances, which tracks how much a spender is allowed to use. When approve is called, it updates this mapping:

allowances[msg.sender][spender] = amount;

msg.sender: The user who is calling the function.
spender: The contract being authorized (here, dsce).
amount: The maximum tokens allowed for transfer.

Second Step: depositCollateral
What Does It Do?
The depositCollateral function moves the user’s tokens from their wallet into the smart contract. It’s the action step that follows the permission granted by approve.

dsce.depositCollateral(weth, AMOUNT_COLLATERAL);

dsce: The contract where collateral will be deposited.
.depositCollateral(weth, AMOUNT_COLLATERAL): Tells the contract to pull AMOUNT_COLLATERAL worth of weth tokens from the user’s account.

How They Work Together
To better understand the flow, let’s visualize the sequence:

Before approve:

User Balance: 100 weth
Contract Balance: 0 weth
Allowance: 0

After approve:

User Balance: 100 weth
Contract Balance: 0 weth
Allowance: 10 weth (assuming AMOUNT_COLLATERAL = 10)
After depositCollateral:

User Balance: 90 weth
Contract Balance: 10 weth
Allowance: 0

Real-World Analogy

Imagine you’re storing gold coins in a locker. Here’s how the process maps to our code:

approve:
You tell the attendant, “You can take up to 10 coins from me.”
depositCollateral:
The attendant takes the 10 coins and puts them in the locker for safekeeping.

Key Takeaways
approve: Grants permission for token transfers.
depositCollateral: Executes the transfer and updates balances.
ERC-20 Standards: This process ensures security and interoperability in DeFi systems.

Why Multiply and Divide by 1𝑒18 in Solidity?

prince — Fri, 22 Nov 2024 09:49:43 +0000

When developing smart contracts for decentralized finance (DeFi), precision handling is crucial. A common pattern you’ll encounter is multiplying and then dividing by 1e18 in calculations involving token prices, amounts, and values. At first glance, this may seem redundant—but it serves a critical purpose.

-Ethereum and DeFi systems heavily rely on consistent precision across calculations:
Ethereum’s 18 Decimal Standard: Most tokens, including ERC20 tokens, use 18 decimal places for their values.
For example, 1 ETH is represented as 1 × 10 ^18 . This standard ensures consistency across token operations.

-Chainlink Price Feed Precision: Chainlink, a popular oracle for fetching token prices, provides values with 8 decimal places (e.g., 1000 × 10 ^8 ).
This mismatch in precision needs to be addressed when integrating Chainlink data with Ethereum-based systems.

The Problem: Mismatched Precisions Imagine you want to calculate the USD value of 1 ETH: Token Price from Chainlink = 1000 × 10^8
Token Amount = 1×10 ^18.
If you directly multiply these values:

USD Value = 1000 × 10^8 * 10^18

The result has 26 decimal places, far exceeding Ethereum’s standard of 18. Using this value in other parts of your contract—such as calculating collateralization or health factors—can lead to inconsistencies and errors.

The Solution:
1.Multiply the price by 1e10 to bring Chainlink's 8-decimal precision up to 18-decimal precision.

-Adjust price precision: 1000 10^8 * 10^10 = 1000 10^18

2.Multiply the result by the token amount

-Multiply by the token amount of 1ETH:
(1000*10^18) *(1*10^18) = 1000 * 10^36

Divide by 1e18 to normalize the final value back to 18 decimals

Note 10e8 = 10^8 0r 10 raised to the power of 8.
10e18 = 10^18 or 10 raised to the power of 18.

An Example Let’s calculate the USD value of 1 ETH at $1,000:

Inputs: -Price = 1000 × 10^8 (from Chainlink) -Amount = 1 × 10^18 (1 ETH).

Step-by-Step Calculation:

-Adjust price precision: 1000 10^8 * 10^10 = 1000 10^18
-Multiply by the amount:(1000*10^18) *(1*10^18) = 1000 *
10^36
-Normalize precision:
USD Value = 1000 * 10^36 / 10^18 = 1000 * 10^18

1000 * 10^18 represents $1,000 in 18-decimal precision.
NOTE:
Without dividing by 1e18, the result would have 36 decimals, making it incompatible with other values that adhere to Ethereum’s 18-decimal standard.

DEV Community: prince

Understanding approve and depositCollateral: The Core of ERC-20 Token Transfers in Solidity

Why Multiply and Divide by 1𝑒18 in Solidity?