Solidity ERC20 Token Transfers: approve, transfer, transferFrom

ERC20 tokens exhibit 12 critical edge cases that can cause vulnerabilities in DeFi protocols: (1) Fee-on-transfer and rebase tokens change balance on transfer, requiring developers to measure actual received amounts rather than assuming transfer amounts; (2) Callback tokens (777s) enable re-entrancy attacks by allowing callbacks before or after transfers; (3) Safe Transfer standardizes failure behavior across tokens that either return false or revert; (4) Some tokens revert on zero address or zero amount transfers; (5) Tokens like USDT lack return values for transfer functions despite ERC20 interface expectations; (6) Blacklisted tokens prevent transfers involving blacklisted addresses, potentially causing liquidation failures; (7) USDT requires resetting approvals to zero before setting new ones to prevent front-running attacks; (8) Some tokens like TrueUSD have multiple addresses controlling the same balance mapping; (9) Upgradeable tokens like USDC can change behavior over time; (10) Flash mintable tokens like DYDX allow temporary borrowing within single transactions; (11) Some tokens transfer less than specified amount when balance is insufficient; (12) Tokens with high decimal precision (e.g., 24 decimals) can confuse systems expecting standard precision.

In Ethereum smart contracts, front running occurs when a spender exploits the time gap between an owner's accidental large ERC20 token approval and their intended smaller approval update, allowing the spender to withdraw more tokens than authorized; this vulnerability is mitigated by using safeDecreaseAllowance functions that first check the current allowance state before updating, ensuring the spender cannot claim additional tokens beyond what was originally approved.

Reentrancy attacks exploit vulnerable contracts by recursively calling functions before state updates complete, as demonstrated by the 2016 DAO attack that drained millions. Prevention requires the checks-effects-interactions pattern: update state before external calls, or use OpenZeppelin's nonReentrant modifier. The ERC-20 standard defines fungible tokens with interchangeable units, requiring totalSupply, balanceOf, transfer, approve, and allowance methods. Decimals (default 18) enable fractional precision. Transfer functions perform validity checks before updating balances. Approve grants spenders permission to transfer tokens, with unlimited access possible via maximum uint256 values, though modern wallets now preview approvals before signing to prevent exploitation.

ERC-20 tokens use approve() and transferFrom() for controlled token transfers. A subtle but devastating vulnerability occurs when contracts incorrectly reference the wrong allowance address in transferFrom(). Attackers can exploit this by approving infinite tokens, then calling transferFrom with zero tokens (passing permission checks), which reads the infinite allowance and grants themselves full access. This simple typo can wipe out millions of dollars in user funds.

Reentrancy attacks can drain funds through recursive calls and cause gas limit exhaustion. The CEI pattern prevents this by zeroing balances immediately after transfers. Receive functions handle funds sent without function calls, while fallback functions handle funds with invalid selectors. ERC-20 tokens cannot be vulnerable to reentrancy because tokens transfer through balance updates within the same contract. However, timing vulnerabilities exist between allowance changes and transfers. ERC-721 NFTs are more vulnerable due to the onERC721Received hook, which allows receiving contracts to reject transfers. Gas limit exhaustion can occur through recursive calls in reentrancy attacks.

ERC-1363 is a simple extension of ERC-20 that adds hooks for token transfers. ERC-2612 extends ERC-20 with permit functionality, which allows token approvals to be packaged within transfer transactions using EIP-712 signatures. This solves the problem of users needing to make two separate transactions (one for approval, one for transfer) in web3 applications, making the process more convenient.

The permit standard (EIP-2612) enables gasless token approvals by allowing pre-signed permissions that can be submitted later. This mechanism allows certain tokens to be approved without immediate gas payment, addressing a key friction point in DeFi interactions where approval transactions consume gas and create user barriers.

TX Relay API (now Gasless API) enables gasless token approvals and swaps by allowing third parties to submit transactions and pay gas fees on behalf of users, reducing the primary cause of abandoned trades (insufficient gas) and improving user experience in DeFi applications. The implementation uses EIP-712 for typed message signing and EIP-2612 for permit functions, with a four-endpoint workflow (price quote, submit, status) that handles both gasless-approved tokens (supporting permit) and non-gasless-approved tokens.

The ERC20 token standard provides the foundational framework for fungible tokens on Ethereum. Token standards emerged from developer collaboration through Ethereum Improvement Proposals (EIP) to solve common problems abstractly, ensuring compatibility with wallets and applications while incorporating security expertise. The standard defines required events (Transfer and Approval) and functions (name, symbol, decimals, totalSupply, balanceOf, transfer, approve, transferFrom) that enable interoperability across the ecosystem. Core implementation requires Solidity 0.8+ for automatic underflow/overflow checks, using mappings for balance and allowance tracking. Beyond the core standard, extensions like ERC2771 (forwarder contracts), ERC1383 (conditional token transfers), ERC2612 (signed approvals via EIP712), and ERC4626 (tokenized vaults) provide specialized functionality for advanced financial applications. Understanding both the core mechanics and extension capabilities is essential for building robust token-based applications on Ethereum.

Permit 2 is a token approval standard that allows users to make swaps without paying gas fees for approvals. To configure Permit 2, users should open the official Uniswap documentation, navigate to the Permit 2 section for Base network, and copy the Permit 2 contract address. This address is then pasted into the spender field in the USDC contract's approve function, with the value field set to zero and a large number of 'fs' to call maximum approval.

Allowance mappings enable delegated spending where one address authorizes another to spend tokens on its behalf. The mapping structure uses nested mappings: outer key is the token owner, inner key is the spender address, and value is the approved amount. This mechanism allows smart contracts to pull tokens from user accounts without direct transfers.

An Automated Market Maker (AMM) is a smart contract that acts as a decentralized exchange, using mathematical formulas instead of order books to determine prices and execute trades. AMMs operate through liquidity pools—virtual vaults containing two or more tokens (e.g., ETH and USDC). Users trade directly with the pool by depositing one token and receiving another, with the smart contract calculating output based on current token ratios. Liquidity providers deposit both tokens and receive LP tokens representing their share, earning fees from every trade. This eliminates centralized authorities and single points of failure, creating self-operating exchanges based purely on code.

Automated Market Makers (AMM) are smart contract protocols that determine asset prices using mathematical formulas, replacing traditional market makers. Liquidity pools contain reserves of cryptocurrencies available for trading. Uniswap is the most prominent example. AMMs enable trading without order books, though they may suffer from impermanent loss and require careful liquidity management.

Automated Market Maker (AMM) is a smart contract algorithm that automatically determines exchange rates in DeFi pools using mathematical formulas. The most common AMM uses the constant product formula (x * y = k), where x and y are asset quantities. When a pool starts with 100 of asset A and 100 of asset B, k = 10,000. If someone withdraws 20 of asset B, the pool must have 80 of asset B remaining. To maintain k = 10,000, the pool must have 125 of asset A (125 * 80 = 10,000), meaning the user must deposit 25 of asset A to receive 20 of asset B. This creates an automated market maker system that adjusts prices based on supply and demand. Liquidity pools are smart contract-based pools where users deposit equal value of two assets to enable trading and lending. Users who deposit into pools become liquidity providers and earn fees from trades. The pool maintains the constant product, meaning as one asset is withdrawn, the other must increase proportionally to maintain the constant.

Automated Market Makers (AMMs) are smart contracts that provide liquidity on decentralized exchanges using automated algorithms. Unlike traditional order books, AMMs use mathematical formulas to determine prices and automatically match trades. Users can add liquidity by depositing pairs of tokens (like Solana and USDC), and in return, they earn trading fees from the platform as compensation for providing this liquidity.