文件 1 的 1：BToken.sol
pragma solidity 0.8.6;
interface IBetaBank {
function bTokens(address _underlying) external view returns (address);
function underlyings(address _bToken) external view returns (address);
function oracle() external view returns (address);
function config() external view returns (address);
function interestModel() external view returns (address);
function getPositionTokens(address _owner, uint _pid)
external
view
returns (address _collateral, address _bToken);
function fetchPositionDebt(address _owner, uint _pid) external returns (uint);
function fetchPositionLTV(address _owner, uint _pid) external returns (uint);
function open(
address _owner,
address _underlying,
address _collateral
) external returns (uint pid);
function borrow(
address _owner,
uint _pid,
uint _amount
) external;
function repay(
address _owner,
uint _pid,
uint _amount
) external;
function put(
address _owner,
uint _pid,
uint _amount
) external;
function take(
address _owner,
uint _pid,
uint _amount
) external;
function liquidate(
address _owner,
uint _pid,
uint _amount
) external;
}
interface IBetaConfig {
function getRiskLevel(address token) external view returns (uint);
function reserveRate() external view returns (uint);
function reserveBeneficiary() external view returns (address);
function getCollFactor(address token) external view returns (uint);
function getCollMaxAmount(address token) external view returns (uint);
function getSafetyLTV(address token) external view returns (uint);
function getLiquidationLTV(address token) external view returns (uint);
function getKillBountyRate(address token) external view returns (uint);
}
interface IBetaInterestModel {
function initialRate() external view returns (uint);
function getNextInterestRate(
uint prevRate,
uint totalAvailable,
uint totalLoan,
uint timePast
) external view returns (uint);
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) private pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
library ECDSA {
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return recover(hash, v, r, s);
} else if (signature.length == 64) {
bytes32 r;
bytes32 vs;
assembly {
r := mload(add(signature, 0x20))
vs := mload(add(signature, 0x40))
}
return recover(hash, r, vs);
} else {
revert("ECDSA: invalid signature length");
}
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return recover(hash, v, r, s);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
require(
uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0,
"ECDSA: invalid signature 's' value"
);
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
address signer = ecrecover(hash, v, r, s);
require(signer != address(0), "ECDSA: invalid signature");
return signer;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
library Math {
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b + (a % b == 0 ? 0 : 1);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
abstract contract EIP712 {
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
function paused() public view virtual returns (bool) {
return _paused;
}
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
_transfer(_msgSender(), recipient, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
_approve(_msgSender(), spender, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
_transfer(sender, recipient, amount);
uint256 currentAllowance = _allowances[sender][_msgSender()];
require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
unchecked {
_approve(sender, _msgSender(), currentAllowance - amount);
}
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
uint256 currentAllowance = _allowances[_msgSender()][spender];
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(_msgSender(), spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(sender, recipient, amount);
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[sender] = senderBalance - amount;
}
_balances[recipient] += amount;
emit Transfer(sender, recipient, amount);
_afterTokenTransfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_balances[account] += amount;
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual {}
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private immutable _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
contract BToken is ERC20Permit, ReentrancyGuard {
using SafeERC20 for IERC20;
event Accrue(uint interest);
event Mint(address indexed caller, address indexed to, uint amount, uint credit);
event Burn(address indexed caller, address indexed to, uint amount, uint credit);
uint public constant MINIMUM_LIQUIDITY = 10**6;
address public immutable betaBank;
address public immutable underlying;
uint public interestRate;
uint public lastAccrueTime;
uint public totalLoanable;
uint public totalLoan;
uint public totalDebtShare;
constructor(address _betaBank, address _underlying)
ERC20Permit('B Token')
ERC20('B Token', 'bTOKEN')
{
require(_betaBank != address(0), 'constructor/betabank-zero-address');
require(_underlying != address(0), 'constructor/underlying-zero-address');
betaBank = _betaBank;
underlying = _underlying;
interestRate = IBetaInterestModel(IBetaBank(_betaBank).interestModel()).initialRate();
lastAccrueTime = block.timestamp;
}
function name() public view override returns (string memory) {
try IERC20Metadata(underlying).name() returns (string memory data) {
return string(abi.encodePacked('B ', data));
} catch (bytes memory) {
return ERC20.name();
}
}
function symbol() public view override returns (string memory) {
try IERC20Metadata(underlying).symbol() returns (string memory data) {
return string(abi.encodePacked('b', data));
} catch (bytes memory) {
return ERC20.symbol();
}
}
function decimals() public view override returns (uint8) {
try IERC20Metadata(underlying).decimals() returns (uint8 data) {
return data;
} catch (bytes memory) {
return ERC20.decimals();
}
}
function accrue() public {
uint timePassed = block.timestamp - lastAccrueTime;
if (timePassed == 0) return;
lastAccrueTime = block.timestamp;
require(!Pausable(betaBank).paused(), 'BetaBank/paused');
(uint totalLoan_, uint totalLoanable_, uint interestRate_) = (
totalLoan,
totalLoanable,
interestRate
);
IBetaConfig config = IBetaConfig(IBetaBank(betaBank).config());
IBetaInterestModel model = IBetaInterestModel(IBetaBank(betaBank).interestModel());
uint interest = (interestRate_ * totalLoan_ * timePassed) / (365 days) / 1e18;
totalLoan_ += interest;
totalLoan = totalLoan_;
interestRate = model.getNextInterestRate(interestRate_, totalLoanable_, totalLoan_, timePassed);
if (interest > 0) {
uint reserveRate = config.reserveRate();
if (reserveRate > 0) {
uint toReserve = (interest * reserveRate) / 1e18;
_mint(
config.reserveBeneficiary(),
(toReserve * totalSupply()) / (totalLoan_ + totalLoanable_ - toReserve)
);
}
emit Accrue(interest);
}
}
function fetchDebtShareValue(uint _debtShare) external returns (uint) {
accrue();
if (_debtShare == 0) {
return 0;
}
return Math.ceilDiv(_debtShare * totalLoan, totalDebtShare);
}
function mint(address _to, uint _amount) external nonReentrant returns (uint credit) {
accrue();
uint amount;
{
uint balBefore = IERC20(underlying).balanceOf(address(this));
IERC20(underlying).safeTransferFrom(msg.sender, address(this), _amount);
uint balAfter = IERC20(underlying).balanceOf(address(this));
amount = balAfter - balBefore;
}
uint supply = totalSupply();
if (supply == 0) {
credit = amount - MINIMUM_LIQUIDITY;
totalLoanable += credit;
totalLoan += MINIMUM_LIQUIDITY;
totalDebtShare += MINIMUM_LIQUIDITY;
_mint(address(1), MINIMUM_LIQUIDITY);
} else {
credit = (amount * supply) / (totalLoanable + totalLoan);
totalLoanable += amount;
}
require(credit > 0, 'mint/no-credit-minted');
_mint(_to, credit);
emit Mint(msg.sender, _to, _amount, credit);
}
function burn(address _to, uint _credit) external nonReentrant returns (uint amount) {
accrue();
uint supply = totalSupply();
amount = (_credit * (totalLoanable + totalLoan)) / supply;
require(amount > 0, 'burn/no-amount-returned');
totalLoanable -= amount;
_burn(msg.sender, _credit);
IERC20(underlying).safeTransfer(_to, amount);
emit Burn(msg.sender, _to, amount, _credit);
}
function borrow(address _to, uint _amount) external nonReentrant returns (uint debtShare) {
require(msg.sender == betaBank, 'borrow/not-BetaBank');
accrue();
IERC20(underlying).safeTransfer(_to, _amount);
debtShare = Math.ceilDiv(_amount * totalDebtShare, totalLoan);
totalLoanable -= _amount;
totalLoan += _amount;
totalDebtShare += debtShare;
}
function repay(address _from, uint _amount) external nonReentrant returns (uint debtShare) {
require(msg.sender == betaBank, 'repay/not-BetaBank');
accrue();
uint amount;
{
uint balBefore = IERC20(underlying).balanceOf(address(this));
IERC20(underlying).safeTransferFrom(_from, address(this), _amount);
uint balAfter = IERC20(underlying).balanceOf(address(this));
amount = balAfter - balBefore;
}
require(amount <= totalLoan, 'repay/amount-too-high');
debtShare = (amount * totalDebtShare) / totalLoan;
totalLoanable += amount;
totalLoan -= amount;
totalDebtShare -= debtShare;
require(totalDebtShare >= MINIMUM_LIQUIDITY, 'repay/too-low-sum-debt-share');
}
function recover(
address _token,
address _to,
uint _amount
) external nonReentrant {
require(msg.sender == betaBank, 'recover/not-BetaBank');
if (_amount == type(uint).max) {
_amount = IERC20(_token).balanceOf(address(this));
}
IERC20(_token).safeTransfer(_to, _amount);
}
}
