// SPDX-License-Identifier: MIT pragma solidity ^0.8.24; /// @notice Minimal ERC20 interface for YAM. interface IYAM { function transfer(address to, uint256 amount) external returns (bool); function transferFrom(address from, address to, uint256 amount) external returns (bool); function balanceOf(address account) external view returns (uint256); function toInternal(uint256 effectiveAmount) external view returns (uint256); function toEffective(uint256 internalAmount) external view returns (uint256); function scalingFactor() external view returns (uint256); function internalBalanceOf(address account) external view returns (uint256); } /// @title WYAM — non-rebasing wrapper around YAM /// @notice Sushi V3 (and most DEX/lending) can't handle rebasing tokens because pool /// accounting reads balanceOf; a rebase would silently change the pool's YAM balance. /// WYAM tracks internal (pre-scalingFactor) units. 1 WYAM at deploy = 1 YAM at deploy. /// As scalingFactor grows, redeeming WYAM returns MORE YAM. /// /// Wrap: send N YAM → mint N * BASE / scalingFactor WYAM /// Unwrap: burn N WYAM → send N * scalingFactor / BASE YAM contract WYAM { // NOTE: filename is WYAM.sol for repo consistency, but SYMBOL is "YAM". // This is the static, DEX-facing token — what Sushi pools hold and wallets show. // YAM.sol (rebasing) has symbol "sYAM". Users buy YAM (this), convert to sYAM for rebase. string public constant name = "YAM"; string public constant symbol = "YAM"; uint8 public constant decimals = 18; IYAM public immutable yam; uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); event Wrap(address indexed user, uint256 yamIn, uint256 wyamOut); event Unwrap(address indexed user, uint256 wyamIn, uint256 yamOut); error InsufficientBalance(); error InsufficientAllowance(); constructor(address _yam) { yam = IYAM(_yam); } /// @notice Wrap YAM into WYAM. Pulls `yamAmount` from caller. function wrap(uint256 yamAmount) external returns (uint256 wyamAmount) { // Take YAM from user first, then measure delta in internal units uint256 before = yam.internalBalanceOf(address(this)); yam.transferFrom(msg.sender, address(this), yamAmount); uint256 delta = yam.internalBalanceOf(address(this)) - before; wyamAmount = delta; // 1 WYAM = 1 internal YAM unit balanceOf[msg.sender] += wyamAmount; totalSupply += wyamAmount; emit Transfer(address(0), msg.sender, wyamAmount); emit Wrap(msg.sender, yamAmount, wyamAmount); } /// @notice Unwrap WYAM into YAM. Burns `wyamAmount` from caller. function unwrap(uint256 wyamAmount) external returns (uint256 yamAmount) { if (balanceOf[msg.sender] < wyamAmount) revert InsufficientBalance(); unchecked { balanceOf[msg.sender] -= wyamAmount; } totalSupply -= wyamAmount; yamAmount = yam.toEffective(wyamAmount); yam.transfer(msg.sender, yamAmount); emit Transfer(msg.sender, address(0), wyamAmount); emit Unwrap(msg.sender, wyamAmount, yamAmount); } // ─── ERC20 core ───────────────────────────────────────────────────── function transfer(address to, uint256 amount) external returns (bool) { if (balanceOf[msg.sender] < amount) revert InsufficientBalance(); unchecked { balanceOf[msg.sender] -= amount; } balanceOf[to] += amount; emit Transfer(msg.sender, to, amount); return true; } function transferFrom(address from, address to, uint256 amount) external returns (bool) { uint256 current = allowance[from][msg.sender]; if (current < amount) revert InsufficientAllowance(); if (current != type(uint256).max) allowance[from][msg.sender] = current - amount; if (balanceOf[from] < amount) revert InsufficientBalance(); unchecked { balanceOf[from] -= amount; } balanceOf[to] += amount; emit Transfer(from, to, amount); return true; } function approve(address spender, uint256 amount) external returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } }