文件 1 的 1：FraxCCFarmV4_cvxLP.sol
pragma solidity >=0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return payable(msg.sender);
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
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);
}
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);
}
}
}
}
contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;
constructor (string memory __name, string memory __symbol) public {
_name = __name;
_symbol = __symbol;
_decimals = 18;
}
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view 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);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
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);
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(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 = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function burn(uint256 amount) public virtual {
_burn(_msgSender(), amount);
}
function burnFrom(address account, uint256 amount) public virtual {
uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance");
_approve(account, _msgSender(), decreasedAllowance);
_burn(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);
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(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 _burnFrom(address account, uint256 amount) internal virtual {
_burn(account, amount);
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}
library SafeERC20 {
using SafeMath for uint256;
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).add(value);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
_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");
}
}
}
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 sqrt(uint y) internal pure returns (uint z) {
if (y > 3) {
z = y;
uint x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
}
contract Owned {
address public owner;
address public nominatedOwner;
constructor (address _owner) public {
require(_owner != address(0), "Owner address cannot be 0");
owner = _owner;
emit OwnerChanged(address(0), _owner);
}
function nominateNewOwner(address _owner) external onlyOwner {
nominatedOwner = _owner;
emit OwnerNominated(_owner);
}
function acceptOwnership() external {
require(msg.sender == nominatedOwner, "You must be nominated before you can accept ownership");
emit OwnerChanged(owner, nominatedOwner);
owner = nominatedOwner;
nominatedOwner = address(0);
}
modifier onlyOwner {
require(msg.sender == owner, "Only the contract owner may perform this action");
_;
}
event OwnerNominated(address newOwner);
event OwnerChanged(address oldOwner, address newOwner);
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: APPROVE_FAILED');
}
function safeTransfer(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FAILED');
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), 'TransferHelper: TRANSFER_FROM_FAILED');
}
function safeTransferETH(address to, uint value) internal {
(bool success,) = to.call{value:value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor () internal {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
contract FraxCrossChainRewarder is Owned, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for ERC20;
address public reward_token_address;
address public timelock_address;
address public curator_address;
address public farm_address;
bool public distributionsOn;
modifier onlyByOwnGov() {
require(msg.sender == owner || msg.sender == timelock_address, "Not owner or timelock");
_;
}
modifier onlyByOwnerOrCuratorOrGovernance() {
require(msg.sender == owner || msg.sender == curator_address || msg.sender == timelock_address, "Not owner, curator, or timelock");
_;
}
modifier isDistributing() {
require(distributionsOn == true, "Distributions are off");
_;
}
constructor (
address _owner,
address _curator_address,
address _reward_token_address
) Owned(_owner) {
curator_address = _curator_address;
reward_token_address = _reward_token_address;
distributionsOn = true;
}
function distributeReward() public isDistributing nonReentrant returns (uint256 reward_balance) {
reward_balance = ERC20(reward_token_address).balanceOf(address(this));
TransferHelper.safeTransfer(reward_token_address, farm_address, reward_balance);
emit RewardDistributed(farm_address, reward_balance);
}
function toggleDistributions() external onlyByOwnerOrCuratorOrGovernance {
distributionsOn = !distributionsOn;
emit DistributionsToggled(distributionsOn);
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
TransferHelper.safeTransfer(tokenAddress, owner, tokenAmount);
emit RecoveredERC20(tokenAddress, tokenAmount);
}
function execute(
address _to,
uint256 _value,
bytes calldata _data
) external onlyByOwnGov returns (bool, bytes memory) {
(bool success, bytes memory result) = _to.call{value:_value}(_data);
return (success, result);
}
function setFarmAddress(address _farm_address) external onlyByOwnGov {
farm_address = _farm_address;
emit FarmAddressChanged(farm_address);
}
function setTimelock(address _new_timelock) external onlyByOwnGov {
timelock_address = _new_timelock;
}
function setCurator(address _new_curator_address) external onlyByOwnGov {
curator_address = _new_curator_address;
}
event RewardDistributed(address indexed farm_address, uint256 reward_amount);
event RecoveredERC20(address token, uint256 amount);
event FarmAddressChanged(address farm_address);
event DistributionsToggled(bool distibutions_state);
}
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 {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
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 tryRecover(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 tryRecover(hash, r, vs);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s;
uint8 v;
assembly {
s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)
v := add(shr(255, vs), 27)
}
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
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));
}
}
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 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);
}
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 PERMIT_TYPEHASH() external view returns (bytes32) {
return _PERMIT_TYPEHASH;
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
contract CrossChainCanonical is ERC20Permit, Owned, ReentrancyGuard {
using SafeMath for uint256;
address public timelock_address;
address public custodian_address;
uint256 public mint_cap;
mapping(address => uint256[2]) public swap_fees;
mapping(address => bool) public fee_exempt_list;
address[] public bridge_tokens_array;
mapping(address => bool) public bridge_tokens;
address[] public minters_array;
mapping(address => bool) public minters;
uint256 private constant PRICE_PRECISION = 1e6;
bool public exchangesPaused;
mapping(address => bool) public canSwap;
modifier onlyByOwnGov() {
require(msg.sender == timelock_address || msg.sender == owner, "Not owner or timelock");
_;
}
modifier onlyByOwnGovCust() {
require(msg.sender == timelock_address || msg.sender == owner || msg.sender == custodian_address, "Not owner, tlck, or custd");
_;
}
modifier onlyMinters() {
require(minters[msg.sender], "Not a minter");
_;
}
modifier onlyMintersOwnGov() {
require(_isMinterOwnGov(msg.sender), "Not minter, owner, or tlck");
_;
}
modifier validBridgeToken(address token_address) {
require(bridge_tokens[token_address], "Invalid old token");
_;
}
constructor (
string memory _name,
string memory _symbol,
address _creator_address,
uint256 _initial_mint_amt,
address _custodian_address,
address[] memory _bridge_tokens
) ERC20(_name, _symbol) ERC20Permit(_name) Owned(_creator_address) {
custodian_address = _custodian_address;
for (uint256 i = 0; i < _bridge_tokens.length; i++){
bridge_tokens[_bridge_tokens[i]] = true;
bridge_tokens_array.push(_bridge_tokens[i]);
swap_fees[_bridge_tokens[i]] = [400, 400];
canSwap[_bridge_tokens[i]] = true;
}
mint_cap = _initial_mint_amt;
super._mint(_creator_address, _initial_mint_amt);
}
function allBridgeTokens() external view returns (address[] memory) {
return bridge_tokens_array;
}
function _isMinterOwnGov(address the_address) internal view returns (bool) {
return (the_address == timelock_address || the_address == owner || minters[the_address]);
}
function _isFeeExempt(address the_address) internal view returns (bool) {
return (_isMinterOwnGov(the_address) || fee_exempt_list[the_address]);
}
function _mint_capped(address account, uint256 amount) internal {
require(totalSupply() + amount <= mint_cap, "Mint cap");
super._mint(account, amount);
}
function exchangeOldForCanonical(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 canonical_tokens_out) {
require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");
TransferHelper.safeTransferFrom(bridge_token_address, msg.sender, address(this), token_amount);
canonical_tokens_out = token_amount;
if (!_isFeeExempt(msg.sender)) {
canonical_tokens_out -= ((canonical_tokens_out * swap_fees[bridge_token_address][0]) / PRICE_PRECISION);
}
_mint_capped(msg.sender, canonical_tokens_out);
}
function exchangeCanonicalForOld(address bridge_token_address, uint256 token_amount) external nonReentrant validBridgeToken(bridge_token_address) returns (uint256 bridge_tokens_out) {
require(!exchangesPaused && canSwap[bridge_token_address], "Exchanges paused");
super._burn(msg.sender, token_amount);
bridge_tokens_out = token_amount;
if (!_isFeeExempt(msg.sender)) {
bridge_tokens_out -= ((bridge_tokens_out * swap_fees[bridge_token_address][1]) / PRICE_PRECISION);
}
TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_tokens_out);
}
function withdrawBridgeTokens(address bridge_token_address, uint256 bridge_token_amount) external onlyMintersOwnGov validBridgeToken(bridge_token_address) {
TransferHelper.safeTransfer(bridge_token_address, msg.sender, bridge_token_amount);
}
function minter_mint(address m_address, uint256 m_amount) external onlyMinters {
_mint_capped(m_address, m_amount);
emit TokenMinted(msg.sender, m_address, m_amount);
}
function minter_burn(uint256 amount) external onlyMinters {
super._burn(msg.sender, amount);
emit TokenBurned(msg.sender, amount);
}
function toggleExchanges() external onlyByOwnGovCust {
exchangesPaused = !exchangesPaused;
}
function addBridgeToken(address bridge_token_address, uint256 _brdg_to_can_fee, uint256 _can_to_brdg_fee) external onlyByOwnGov {
for (uint i = 0; i < bridge_tokens_array.length; i++){
if (bridge_tokens_array[i] == bridge_token_address){
revert("Token already present");
}
}
bridge_tokens[bridge_token_address] = true;
bridge_tokens_array.push(bridge_token_address);
canSwap[bridge_token_address] = true;
swap_fees[bridge_token_address][0] = _brdg_to_can_fee;
swap_fees[bridge_token_address][1] = _can_to_brdg_fee;
emit BridgeTokenAdded(bridge_token_address);
}
function toggleBridgeToken(address bridge_token_address) external onlyByOwnGov {
bool bridge_tkn_found;
for (uint i = 0; i < bridge_tokens_array.length; i++){
if (bridge_tokens_array[i] == bridge_token_address){
bridge_tkn_found = true;
break;
}
}
require(bridge_tkn_found, "Bridge tkn not in array");
bridge_tokens[bridge_token_address] = !bridge_tokens[bridge_token_address];
canSwap[bridge_token_address] = !canSwap[bridge_token_address];
emit BridgeTokenToggled(bridge_token_address, !bridge_tokens[bridge_token_address]);
}
function addMinter(address minter_address) external onlyByOwnGov {
require(minter_address != address(0), "Zero address detected");
require(minters[minter_address] == false, "Address already exists");
minters[minter_address] = true;
minters_array.push(minter_address);
emit MinterAdded(minter_address);
}
function removeMinter(address minter_address) external onlyByOwnGov {
require(minter_address != address(0), "Zero address detected");
require(minters[minter_address] == true, "Address nonexistent");
delete minters[minter_address];
for (uint i = 0; i < minters_array.length; i++){
if (minters_array[i] == minter_address) {
minters_array[i] = address(0);
break;
}
}
emit MinterRemoved(minter_address);
}
function setMintCap(uint256 _mint_cap) external onlyByOwnGov {
mint_cap = _mint_cap;
emit MintCapSet(_mint_cap);
}
function setSwapFees(address bridge_token_address, uint256 _bridge_to_canonical, uint256 _canonical_to_old) external onlyByOwnGov {
swap_fees[bridge_token_address] = [_bridge_to_canonical, _canonical_to_old];
}
function toggleFeesForAddress(address the_address) external onlyByOwnGov {
fee_exempt_list[the_address] = !fee_exempt_list[the_address];
}
function setTimelock(address new_timelock) external onlyByOwnGov {
require(new_timelock != address(0), "Zero address detected");
timelock_address = new_timelock;
emit TimelockSet(new_timelock);
}
function setCustodian(address _custodian_address) external onlyByOwnGov {
require(_custodian_address != address(0), "Zero address detected");
custodian_address = _custodian_address;
emit CustodianSet(_custodian_address);
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
require(!bridge_tokens[tokenAddress], "Cannot withdraw bridge tokens");
require(tokenAddress != address(this), "Cannot withdraw these tokens");
TransferHelper.safeTransfer(address(tokenAddress), msg.sender, tokenAmount);
}
event TokenBurned(address indexed from, uint256 amount);
event TokenMinted(address indexed from, address indexed to, uint256 amount);
event BridgeTokenAdded(address indexed bridge_token_address);
event BridgeTokenToggled(address indexed bridge_token_address, bool state);
event MinterAdded(address pool_address);
event MinterRemoved(address pool_address);
event MintCapSet(uint256 new_mint_cap);
event TimelockSet(address new_timelock);
event CustodianSet(address custodian_address);
}
contract CrossChainCanonicalFXS is CrossChainCanonical {
constructor (
string memory _name,
string memory _symbol,
address _creator_address,
uint256 _initial_mint_amt,
address _custodian_address,
address[] memory _bridge_tokens
)
CrossChainCanonical(_name, _symbol, _creator_address, _initial_mint_amt, _custodian_address, _bridge_tokens)
{}
}
interface IveFXS {
struct LockedBalance {
int128 amount;
uint256 end;
}
function commit_transfer_ownership(address addr) external;
function apply_transfer_ownership() external;
function commit_smart_wallet_checker(address addr) external;
function apply_smart_wallet_checker() external;
function toggleEmergencyUnlock() external;
function recoverERC20(address token_addr, uint256 amount) external;
function get_last_user_slope(address addr) external view returns (int128);
function user_point_history__ts(address _addr, uint256 _idx) external view returns (uint256);
function locked__end(address _addr) external view returns (uint256);
function checkpoint() external;
function deposit_for(address _addr, uint256 _value) external;
function create_lock(uint256 _value, uint256 _unlock_time) external;
function increase_amount(uint256 _value) external;
function increase_unlock_time(uint256 _unlock_time) external;
function withdraw() external;
function balanceOf(address addr) external view returns (uint256);
function balanceOf(address addr, uint256 _t) external view returns (uint256);
function balanceOfAt(address addr, uint256 _block) external view returns (uint256);
function totalSupply() external view returns (uint256);
function totalSupply(uint256 t) external view returns (uint256);
function totalSupplyAt(uint256 _block) external view returns (uint256);
function totalFXSSupply() external view returns (uint256);
function totalFXSSupplyAt(uint256 _block) external view returns (uint256);
function changeController(address _newController) external;
function token() external view returns (address);
function supply() external view returns (uint256);
function locked(address addr) external view returns (LockedBalance memory);
function epoch() external view returns (uint256);
function point_history(uint256 arg0) external view returns (int128 bias, int128 slope, uint256 ts, uint256 blk, uint256 fxs_amt);
function user_point_history(address arg0, uint256 arg1) external view returns (int128 bias, int128 slope, uint256 ts, uint256 blk, uint256 fxs_amt);
function user_point_epoch(address arg0) external view returns (uint256);
function slope_changes(uint256 arg0) external view returns (int128);
function controller() external view returns (address);
function transfersEnabled() external view returns (bool);
function emergencyUnlockActive() external view returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function version() external view returns (string memory);
function decimals() external view returns (uint256);
function future_smart_wallet_checker() external view returns (address);
function smart_wallet_checker() external view returns (address);
function admin() external view returns (address);
function future_admin() external view returns (address);
}
interface IanyFXS {
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external view returns (bytes32);
function Swapin(bytes32 txhash, address account, uint256 amount) external returns (bool);
function Swapout(uint256 amount, address bindaddr) external returns (bool);
function TRANSFER_TYPEHASH() external view returns (bytes32);
function allowance(address, address) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
function balanceOf(address) external view returns (uint256);
function burn(address from, uint256 amount) external returns (bool);
function changeMPCOwner(address newVault) external returns (bool);
function changeVault(address newVault) external returns (bool);
function decimals() external view returns (uint8);
function deposit(uint256 amount, address to) external returns (uint256);
function deposit(uint256 amount) external returns (uint256);
function deposit() external returns (uint256);
function depositVault(uint256 amount, address to) external returns (uint256);
function depositWithPermit(address target, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s, address to) external returns (uint256);
function depositWithTransferPermit(address target, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s, address to) external returns (uint256);
function mint(address to, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function nonces(address) external view returns (uint256);
function owner() external view returns (address);
function permit(address target, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function transferWithPermit(address target, address to, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external returns (bool);
function underlying() external view returns (address);
function vault() external view returns (address);
function withdraw(uint256 amount, address to) external returns (uint256);
function withdraw(uint256 amount) external returns (uint256);
function withdraw() external returns (uint256);
function withdrawVault(address from, uint256 amount, address to) external returns (uint256);
}
interface IConvexCvxLPRewardPoolCombo {
struct EarnedData {
address token;
uint256 amount;
}
function addExtraReward ( address _token ) external;
function allowance ( address owner, address spender ) external view returns ( uint256 );
function approve ( address spender, uint256 amount ) external returns ( bool );
function balanceOf ( address account ) external view returns ( uint256 );
function claimable_reward ( address, address ) external view returns ( uint256 );
function convexBooster ( ) external view returns ( address );
function convexPoolId ( ) external view returns ( uint256 );
function convexStaker ( ) external view returns ( address );
function crv ( ) external view returns ( address );
function curveGauge ( ) external view returns ( address );
function decimals ( ) external pure returns ( uint8 );
function decreaseAllowance ( address spender, uint256 subtractedValue ) external returns ( bool );
function earned ( address _account ) external returns ( EarnedData[] memory claimable );
function emergencyWithdraw ( uint256 _amount ) external returns ( bool );
function getReward ( address _account, address _forwardTo ) external;
function getReward ( address _account ) external;
function increaseAllowance ( address spender, uint256 addedValue ) external returns ( bool );
function initialize ( address _crv, address _curveGauge, address _convexStaker, address _convexBooster, address _lptoken, uint256 _poolId ) external;
function invalidateReward ( address _token ) external;
function maxRewards ( ) external view returns ( uint256 );
function name ( ) external view returns ( string memory );
function rewardHook ( ) external view returns ( address );
function rewardLength ( ) external view returns ( uint256 );
function rewardMap ( address ) external view returns ( uint256 );
function rewardRedirect ( address ) external view returns ( address );
function reward_integral_for ( address, address ) external view returns ( uint256 );
function rewards ( uint256 ) external view returns ( address reward_token, uint256 reward_integral, uint256 reward_remaining );
function setRewardHook ( address _hook ) external;
function setRewardRedirect ( address _to ) external;
function stakeFor ( address _for, uint256 _amount ) external returns ( bool );
function symbol ( ) external view returns ( string memory );
function totalSupply ( ) external view returns ( uint256 );
function transfer ( address recipient, uint256 amount ) external returns ( bool );
function transferFrom ( address sender, address recipient, uint256 amount ) external returns ( bool );
function user_checkpoint ( address _account ) external returns ( bool );
function withdraw ( uint256 _amount, bool _claim ) external returns ( bool );
function withdrawAll ( bool claim ) external;
}
interface I2poolTokenNoLending {
function initialize ( string memory _name, string memory _symbol, address[4] memory _coins, uint256[4] memory _rate_multipliers, uint256 _A, uint256 _fee ) external;
function decimals ( ) external view returns ( uint8 );
function transfer ( address _to, uint256 _value ) external returns ( bool );
function transferFrom ( address _from, address _to, uint256 _value ) external returns ( bool );
function approve ( address _spender, uint256 _value ) external returns ( bool );
function permit ( address _owner, address _spender, uint256 _value, uint256 _deadline, uint8 _v, bytes32 _r, bytes32 _s ) external returns ( bool );
function last_price ( ) external view returns ( uint256 );
function ema_price ( ) external view returns ( uint256 );
function get_balances ( ) external view returns ( uint256[2] memory );
function admin_fee ( ) external view returns ( uint256 );
function A ( ) external view returns ( uint256 );
function A_precise ( ) external view returns ( uint256 );
function get_p ( ) external view returns ( uint256 );
function price_oracle ( ) external view returns ( uint256 );
function get_virtual_price ( ) external view returns ( uint256 );
function calc_token_amount ( uint256[2] memory _amounts, bool _is_deposit ) external view returns ( uint256 );
function add_liquidity ( uint256[2] memory _amounts, uint256 _min_mint_amount ) external returns ( uint256 );
function add_liquidity ( uint256[2] memory _amounts, uint256 _min_mint_amount, address _receiver ) external returns ( uint256 );
function get_dy ( int128 i, int128 j, uint256 dx ) external view returns ( uint256 );
function get_dx ( int128 i, int128 j, uint256 dy ) external view returns ( uint256 );
function exchange ( int128 i, int128 j, uint256 _dx, uint256 _min_dy ) external returns ( uint256 );
function exchange ( int128 i, int128 j, uint256 _dx, uint256 _min_dy, address _receiver ) external returns ( uint256 );
function remove_liquidity ( uint256 _burn_amount, uint256[2] memory _min_amounts ) external returns ( uint256[2] memory );
function remove_liquidity ( uint256 _burn_amount, uint256[2] memory _min_amounts, address _receiver ) external returns ( uint256[2] memory );
function remove_liquidity_imbalance ( uint256[2] memory _amounts, uint256 _max_burn_amount ) external returns ( uint256 );
function remove_liquidity_imbalance ( uint256[2] memory _amounts, uint256 _max_burn_amount, address _receiver ) external returns ( uint256 );
function calc_withdraw_one_coin ( uint256 _burn_amount, int128 i ) external view returns ( uint256 );
function remove_liquidity_one_coin ( uint256 _burn_amount, int128 i, uint256 _min_received ) external returns ( uint256 );
function remove_liquidity_one_coin ( uint256 _burn_amount, int128 i, uint256 _min_received, address _receiver ) external returns ( uint256 );
function ramp_A ( uint256 _future_A, uint256 _future_time ) external;
function stop_ramp_A ( ) external;
function set_ma_exp_time ( uint256 _ma_exp_time ) external;
function admin_balances ( uint256 i ) external view returns ( uint256 );
function commit_new_fee ( uint256 _new_fee ) external;
function apply_new_fee ( ) external;
function withdraw_admin_fees ( ) external;
function version ( ) external pure returns ( string memory );
function factory ( ) external view returns ( address );
function coins ( uint256 arg0 ) external view returns ( address );
function balances ( uint256 arg0 ) external view returns ( uint256 );
function fee ( ) external view returns ( uint256 );
function future_fee ( ) external view returns ( uint256 );
function admin_action_deadline ( ) external view returns ( uint256 );
function initial_A ( ) external view returns ( uint256 );
function future_A ( ) external view returns ( uint256 );
function initial_A_time ( ) external view returns ( uint256 );
function future_A_time ( ) external view returns ( uint256 );
function name ( ) external view returns ( string memory );
function symbol ( ) external view returns ( string memory );
function balanceOf ( address arg0 ) external view returns ( uint256 );
function allowance ( address arg0, address arg1 ) external view returns ( uint256 );
function totalSupply ( ) external view returns ( uint256 );
function DOMAIN_SEPARATOR ( ) external view returns ( bytes32 );
function nonces ( address arg0 ) external view returns ( uint256 );
function ma_exp_time ( ) external view returns ( uint256 );
function ma_last_time ( ) external view returns ( uint256 );
}
interface ICurveChildLiquidityGauge {
struct Reward {
address distributor;
uint256 period_finish;
uint256 rate;
uint256 last_update;
uint256 integral;
}
function deposit ( uint256 _value ) external;
function deposit ( uint256 _value, address _user ) external;
function deposit ( uint256 _value, address _user, bool _claim_rewards ) external;
function withdraw ( uint256 _value ) external;
function withdraw ( uint256 _value, address _user ) external;
function withdraw ( uint256 _value, address _user, bool _claim_rewards ) external;
function transferFrom ( address _from, address _to, uint256 _value ) external returns ( bool );
function approve ( address _spender, uint256 _value ) external returns ( bool );
function permit ( address _owner, address _spender, uint256 _value, uint256 _deadline, uint8 _v, bytes32 _r, bytes32 _s ) external returns ( bool );
function transfer ( address _to, uint256 _value ) external returns ( bool );
function increaseAllowance ( address _spender, uint256 _added_value ) external returns ( bool );
function decreaseAllowance ( address _spender, uint256 _subtracted_value ) external returns ( bool );
function user_checkpoint ( address addr ) external returns ( bool );
function claimable_tokens ( address addr ) external returns ( uint256 );
function claimed_reward ( address _addr, address _token ) external view returns ( uint256 );
function claimable_reward ( address _user, address _reward_token ) external view returns ( uint256 );
function set_rewards_receiver ( address _receiver ) external;
function claim_rewards ( ) external;
function claim_rewards ( address _addr ) external;
function claim_rewards ( address _addr, address _receiver ) external;
function add_reward ( address _reward_token, address _distributor ) external;
function set_reward_distributor ( address _reward_token, address _distributor ) external;
function deposit_reward_token ( address _reward_token, uint256 _amount ) external;
function set_manager ( address _manager ) external;
function update_voting_escrow ( ) external;
function set_killed ( bool _is_killed ) external;
function decimals ( ) external view returns ( uint256 );
function integrate_checkpoint ( ) external view returns ( uint256 );
function version ( ) external view returns ( string memory );
function factory ( ) external view returns ( address );
function initialize ( address _lp_token, address _manager ) external;
function DOMAIN_SEPARATOR ( ) external view returns ( bytes32 );
function nonces ( address arg0 ) external view returns ( uint256 );
function name ( ) external view returns ( string memory );
function symbol ( ) external view returns ( string memory );
function allowance ( address arg0, address arg1 ) external view returns ( uint256 );
function balanceOf ( address arg0 ) external view returns ( uint256 );
function totalSupply ( ) external view returns ( uint256 );
function lp_token ( ) external view returns ( address );
function manager ( ) external view returns ( address );
function voting_escrow ( ) external view returns ( address );
function working_balances ( address arg0 ) external view returns ( uint256 );
function working_supply ( ) external view returns ( uint256 );
function period ( ) external view returns ( uint256 );
function period_timestamp ( uint256 arg0 ) external view returns ( uint256 );
function integrate_checkpoint_of ( address arg0 ) external view returns ( uint256 );
function integrate_fraction ( address arg0 ) external view returns ( uint256 );
function integrate_inv_supply ( uint256 arg0 ) external view returns ( uint256 );
function integrate_inv_supply_of ( address arg0 ) external view returns ( uint256 );
function reward_count ( ) external view returns ( uint256 );
function reward_tokens ( uint256 arg0 ) external view returns ( address );
function reward_data ( address arg0 ) external view returns ( Reward memory );
function rewards_receiver ( address arg0 ) external view returns ( address );
function reward_integral_for ( address arg0, address arg1 ) external view returns ( uint256 );
function is_killed ( ) external view returns ( bool );
function inflation_rate ( uint256 arg0 ) external view returns ( uint256 );
}
contract FraxCrossChainFarmV4_ERC20 is Owned, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for ERC20;
IveFXS public veFXS;
address[] public rewardTokens;
IConvexCvxLPRewardPoolCombo public stakingToken;
FraxCrossChainRewarder public rewarder;
address public fraxAddress;
uint256 private constant MULTIPLIER_PRECISION = 1e18;
address public timelockAddress;
address public controllerAddress;
uint256 public periodFinish;
uint256 public lastUpdateTime;
uint256 public lock_max_multiplier = uint256(3e18);
uint256 public lock_time_for_max_multiplier = 3 * 365 * 86400;
uint256 public lock_time_min = 1;
uint256 public vefxs_per_frax_for_max_boost = uint256(4e18);
uint256 public vefxs_max_multiplier = uint256(2e18);
mapping(address => uint256) private _vefxsMultiplierStored;
uint256[] public rewardRates;
mapping(address => bool) internal isRewardToken;
mapping(address => uint256) public rewardTokenAddrToIdx;
uint256 public rewardsDuration = 604800;
uint256[] public ttlRewsOwed;
uint256[] public ttlRewsPaid;
uint256[] private rewardsPerTokenStored;
mapping(address => mapping(uint256 => uint256)) private userRewardsPerTokenPaid;
mapping(address => mapping(uint256 => uint256)) private rewards;
uint256 public lastRewardPull;
mapping(address => uint256) internal lastRewardClaimTime;
uint256 private _total_liquidity_locked;
uint256 private _total_combined_weight;
mapping(address => uint256) private _locked_liquidity;
mapping(address => uint256) private _combined_weights;
bool frax_is_token0;
mapping(address => LockedStake[]) public lockedStakes;
mapping(address => bool) public valid_migrators;
mapping(address => mapping(address => bool)) public staker_allowed_migrators;
bool public migrationsOn;
bool public stakesUnlocked;
bool public withdrawalsPaused;
bool public rewardsCollectionPaused;
bool public stakingPaused;
bool public collectRewardsOnWithdrawalPaused;
bool public isInitialized;
string public version = "0.0.8";
struct LockedStake {
bytes32 kek_id;
uint256 start_timestamp;
uint256 liquidity;
uint256 ending_timestamp;
uint256 lock_multiplier;
}
modifier onlyByOwnGov() {
require(msg.sender == owner || msg.sender == timelockAddress, "Not owner or timelock");
_;
}
modifier onlyByOwnGovCtrlr() {
require(msg.sender == owner || msg.sender == timelockAddress || msg.sender == controllerAddress, "Not own, tlk, or ctrlr");
_;
}
modifier isMigrating() {
require(migrationsOn == true, "Not in migration");
_;
}
modifier notStakingPaused() {
require(stakingPaused == false, "Staking paused");
_;
}
modifier updateRewardAndBalance(address account, bool sync_too) {
_updateRewardAndBalance(account, sync_too, false);
_;
}
constructor (
address _owner,
address[] memory _rewardTokens,
address _stakingToken,
address _fraxAddress,
address _timelockAddress,
address _rewarder_address
) Owned(_owner){
fraxAddress = _fraxAddress;
rewardTokens = _rewardTokens;
for (uint256 i = 0; i < _rewardTokens.length; i++) {
rewardTokenAddrToIdx[_rewardTokens[i]] = i;
isRewardToken[_rewardTokens[i]] = true;
rewardsPerTokenStored.push(0);
ttlRewsOwed.push(0);
ttlRewsPaid.push(0);
rewardRates.push(0);
}
stakingToken = IConvexCvxLPRewardPoolCombo(_stakingToken);
timelockAddress = _timelockAddress;
rewarder = FraxCrossChainRewarder(_rewarder_address);
migrationsOn = false;
stakesUnlocked = false;
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardsDuration);
}
function totalLiquidityLocked() external view returns (uint256) {
return _total_liquidity_locked;
}
function lockedLiquidityOf(address account) external view returns (uint256) {
return _locked_liquidity[account];
}
function totalCombinedWeight() external view returns (uint256) {
return _total_combined_weight;
}
function combinedWeightOf(address account) external view returns (uint256) {
return _combined_weights[account];
}
function lockedStakesOf(address account) external view returns (LockedStake[] memory) {
return lockedStakes[account];
}
function lockMultiplier(uint256 secs) public view returns (uint256) {
return Math.min(
lock_max_multiplier,
(secs * lock_max_multiplier) / lock_time_for_max_multiplier
) ;
}
function lastTimeRewardApplicable() internal view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function fraxPerLPToken() public view returns (uint256) {
uint256 frax_per_lp_token;
{
ICurveChildLiquidityGauge gauge = ICurveChildLiquidityGauge(stakingToken.curveGauge());
I2poolTokenNoLending pool = I2poolTokenNoLending(gauge.lp_token());
address coin0 = pool.coins(0);
uint256 total_frax_reserves;
uint256[2] memory _balanceResults = pool.get_balances();
if (coin0 == fraxAddress) {
total_frax_reserves = _balanceResults[0];
}
else {
total_frax_reserves = _balanceResults[1];
}
frax_per_lp_token = total_frax_reserves.mul(1e18).div(pool.totalSupply());
}
return frax_per_lp_token;
}
function userStakedFrax(address account) public view returns (uint256) {
return (fraxPerLPToken()).mul(_locked_liquidity[account]).div(1e18);
}
function minVeFXSForMaxBoost(address account) public view returns (uint256) {
return (userStakedFrax(account)).mul(vefxs_per_frax_for_max_boost).div(MULTIPLIER_PRECISION);
}
function veFXSMultiplier(address account) public view returns (uint256) {
if (address(veFXS) != address(0)){
uint256 veFXS_needed_for_max_boost = minVeFXSForMaxBoost(account);
if (veFXS_needed_for_max_boost > 0){
uint256 user_vefxs_fraction = (veFXS.balanceOf(account)).mul(MULTIPLIER_PRECISION).div(veFXS_needed_for_max_boost);
uint256 vefxs_multiplier = ((user_vefxs_fraction).mul(vefxs_max_multiplier)).div(MULTIPLIER_PRECISION);
if (vefxs_multiplier > vefxs_max_multiplier) vefxs_multiplier = vefxs_max_multiplier;
return vefxs_multiplier;
}
else return 0;
}
else return 0;
}
function calcCurrLockMultiplier(address account, uint256 stake_idx) public view returns (uint256 midpoint_lock_multiplier) {
LockedStake memory thisStake = lockedStakes[account][stake_idx];
uint256 accrue_start_time;
if (lastRewardClaimTime[account] < thisStake.start_timestamp) {
accrue_start_time = thisStake.start_timestamp;
}
else {
accrue_start_time = lastRewardClaimTime[account];
}
if (thisStake.ending_timestamp <= block.timestamp) {
if (lastRewardClaimTime[account] < thisStake.ending_timestamp){
uint256 time_before_expiry = thisStake.ending_timestamp - accrue_start_time;
uint256 time_after_expiry = block.timestamp - thisStake.ending_timestamp;
uint256 pre_expiry_avg_multiplier = lockMultiplier(time_before_expiry / 2);
uint256 numerator = (pre_expiry_avg_multiplier * time_before_expiry) + (0 * time_after_expiry);
midpoint_lock_multiplier = numerator / (time_before_expiry + time_after_expiry);
}
else {
midpoint_lock_multiplier = 0;
}
}
else {
uint256 avg_time_left;
{
uint256 time_left_p1 = thisStake.ending_timestamp - accrue_start_time;
uint256 time_left_p2 = thisStake.ending_timestamp - block.timestamp;
avg_time_left = (time_left_p1 + time_left_p2) / 2;
}
midpoint_lock_multiplier = lockMultiplier(avg_time_left);
}
if (midpoint_lock_multiplier > thisStake.lock_multiplier) midpoint_lock_multiplier = thisStake.lock_multiplier;
}
function calcCurCombinedWeight(address account) public view
returns (
uint256 old_combined_weight,
uint256 new_vefxs_multiplier,
uint256 new_combined_weight
)
{
old_combined_weight = _combined_weights[account];
new_vefxs_multiplier = veFXSMultiplier(account);
uint256 midpoint_vefxs_multiplier;
if (
(_locked_liquidity[account] == 0 && _combined_weights[account] == 0) ||
(new_vefxs_multiplier >= _vefxsMultiplierStored[account])
) {
midpoint_vefxs_multiplier = new_vefxs_multiplier;
}
else {
midpoint_vefxs_multiplier = (new_vefxs_multiplier + _vefxsMultiplierStored[account]) / 2;
}
new_combined_weight = 0;
for (uint256 i = 0; i < lockedStakes[account].length; i++) {
LockedStake memory thisStake = lockedStakes[account][i];
uint256 midpoint_lock_multiplier = calcCurrLockMultiplier(account, i);
uint256 liquidity = thisStake.liquidity;
uint256 combined_boosted_amount = liquidity + ((liquidity * (midpoint_lock_multiplier + midpoint_vefxs_multiplier)) / MULTIPLIER_PRECISION);
new_combined_weight += combined_boosted_amount;
}
}
function rewardPerToken() public view returns (uint256[] memory _rtnRewardsPerTokenStored) {
_rtnRewardsPerTokenStored = new uint256[](rewardTokens.length);
if (_total_liquidity_locked == 0 || _total_combined_weight == 0) {
_rtnRewardsPerTokenStored = rewardsPerTokenStored;
}
else {
for (uint256 i = 0; i < rewardTokens.length; i++) {
_rtnRewardsPerTokenStored[i] = rewardsPerTokenStored[i].add(
lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRates[i]).mul(1e18).div(_total_combined_weight)
);
}
}
}
function earned(address account) public view returns (uint256[] memory _rtnEarned) {
_rtnEarned = new uint256[](rewardTokens.length);
if (_combined_weights[account] == 0){
for (uint256 i = 0; i < rewardTokens.length; i++) {
_rtnEarned[i] = 0;
}
}
else {
uint256[] memory _rtnRewardsPerToken = rewardPerToken();
for (uint256 i = 0; i < rewardTokens.length; i++) {
_rtnEarned[i] = (_combined_weights[account].mul(_rtnRewardsPerToken[i].sub(userRewardsPerTokenPaid[account][i]))).div(1e18).add(rewards[account][i]);
}
}
}
function getRewardForDuration() external view returns (uint256[] memory _rtnRewardForDuration) {
_rtnRewardForDuration = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardTokens.length; i++) {
_rtnRewardForDuration[i] = rewardRates[i].mul(rewardsDuration);
}
}
function _getStake(address staker_address, bytes32 kek_id) internal view returns (LockedStake memory locked_stake, uint256 arr_idx) {
for (uint256 i = 0; i < lockedStakes[staker_address].length; i++) {
if (kek_id == lockedStakes[staker_address][i].kek_id){
locked_stake = lockedStakes[staker_address][i];
arr_idx = i;
break;
}
}
require(locked_stake.kek_id == kek_id, "Stake not found");
}
function _updateRewardAndBalance(address account, bool sync_too, bool pre_sync_vemxstored) internal {
if (sync_too){
sync();
}
if (pre_sync_vemxstored){
_vefxsMultiplierStored[account] = veFXSMultiplier(account);
}
if (account != address(0)) {
(
uint256 old_combined_weight,
uint256 new_vefxs_multiplier,
uint256 new_combined_weight
) = calcCurCombinedWeight(account);
_syncEarned(account);
_vefxsMultiplierStored[account] = new_vefxs_multiplier;
if (new_combined_weight >= old_combined_weight) {
uint256 weight_diff = new_combined_weight.sub(old_combined_weight);
_total_combined_weight = _total_combined_weight.add(weight_diff);
_combined_weights[account] = old_combined_weight.add(weight_diff);
} else {
uint256 weight_diff = old_combined_weight.sub(new_combined_weight);
_total_combined_weight = _total_combined_weight.sub(weight_diff);
_combined_weights[account] = old_combined_weight.sub(weight_diff);
}
}
}
function lockAdditional(bytes32 kek_id, uint256 addl_liq) nonReentrant updateRewardAndBalance(msg.sender, true) public {
require(!stakingPaused, "Staking paused");
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(msg.sender, kek_id);
uint256 new_amt = thisStake.liquidity + addl_liq;
require(addl_liq >= 0, "Must be nonzero");
TransferHelper.safeTransferFrom(address(stakingToken), msg.sender, address(this), addl_liq);
lockedStakes[msg.sender][theArrayIndex] = LockedStake(
kek_id,
thisStake.start_timestamp,
new_amt,
thisStake.ending_timestamp,
thisStake.lock_multiplier
);
_total_liquidity_locked += addl_liq;
_locked_liquidity[msg.sender] += addl_liq;
_updateRewardAndBalance(msg.sender, false, true);
emit LockedAdditional(msg.sender, kek_id, addl_liq);
}
function lockLonger(bytes32 kek_id, uint256 new_ending_ts) nonReentrant updateRewardAndBalance(msg.sender, true) public {
require(!stakingPaused, "Staking paused");
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(msg.sender, kek_id);
require(new_ending_ts > block.timestamp, "Must be in the future");
uint256 time_left = (thisStake.ending_timestamp > block.timestamp) ? thisStake.ending_timestamp - block.timestamp : 0;
uint256 new_secs = new_ending_ts - block.timestamp;
require(new_secs > time_left, "Cannot shorten lock time");
require(new_secs >= lock_time_min, "Minimum stake time not met");
require(new_secs <= lock_time_for_max_multiplier, "Trying to lock for too long");
lockedStakes[msg.sender][theArrayIndex] = LockedStake(
kek_id,
block.timestamp,
thisStake.liquidity,
new_ending_ts,
lockMultiplier(new_secs)
);
_updateRewardAndBalance(msg.sender, false, true);
emit LockedLonger(msg.sender, kek_id, new_secs, block.timestamp, new_ending_ts);
}
function _syncEarned(address account) internal {
if (account != address(0)) {
uint256[] memory _earneds = earned(account);
for (uint256 i = 0; i < rewardTokens.length; i++) {
rewards[account][i] = _earneds[i];
userRewardsPerTokenPaid[account][i] = rewardsPerTokenStored[i];
}
}
}
function stakerAllowMigrator(address migrator_address) external {
require(valid_migrators[migrator_address], "Invalid migrator address");
staker_allowed_migrators[msg.sender][migrator_address] = true;
}
function stakerDisallowMigrator(address migrator_address) external {
delete staker_allowed_migrators[msg.sender][migrator_address];
}
function stakeLocked(uint256 liquidity, uint256 secs) nonReentrant public {
_stakeLocked(msg.sender, msg.sender, liquidity, secs, block.timestamp);
}
function _stakeLocked(
address staker_address,
address source_address,
uint256 liquidity,
uint256 secs,
uint256 start_timestamp
) internal updateRewardAndBalance(staker_address, true) {
require(!stakingPaused || valid_migrators[msg.sender] == true, "Staking paused or in migration");
require(liquidity > 0, "Must stake more than zero");
require(secs >= lock_time_min, "Minimum stake time not met");
require(secs <= lock_time_for_max_multiplier,"Trying to lock for too long");
uint256 lock_multiplier = lockMultiplier(secs);
bytes32 kek_id = keccak256(abi.encodePacked(staker_address, start_timestamp, liquidity, _locked_liquidity[staker_address]));
lockedStakes[staker_address].push(LockedStake(
kek_id,
start_timestamp,
liquidity,
start_timestamp.add(secs),
lock_multiplier
));
TransferHelper.safeTransferFrom(address(stakingToken), source_address, address(this), liquidity);
_total_liquidity_locked = _total_liquidity_locked.add(liquidity);
_locked_liquidity[staker_address] = _locked_liquidity[staker_address].add(liquidity);
_updateRewardAndBalance(staker_address, false, true);
emit StakeLocked(staker_address, liquidity, secs, kek_id, source_address);
}
function withdrawLocked(bytes32 kek_id, bool claim_rewards) nonReentrant public {
require(withdrawalsPaused == false, "Withdrawals paused");
_withdrawLocked(msg.sender, msg.sender, kek_id, claim_rewards);
}
function _withdrawLocked(address staker_address, address destination_address, bytes32 kek_id, bool claim_rewards) internal {
if (claim_rewards || !collectRewardsOnWithdrawalPaused) _getReward(staker_address, destination_address);
else {
_updateRewardAndBalance(staker_address, true, false);
}
(LockedStake memory thisStake, uint256 theArrayIndex) = _getStake(staker_address, kek_id);
require(thisStake.kek_id == kek_id, "Stake not found");
require(block.timestamp >= thisStake.ending_timestamp || stakesUnlocked == true || valid_migrators[msg.sender] == true, "Stake is still locked!");
uint256 liquidity = thisStake.liquidity;
if (liquidity > 0) {
_total_liquidity_locked = _total_liquidity_locked.sub(liquidity);
_locked_liquidity[staker_address] = _locked_liquidity[staker_address].sub(liquidity);
delete lockedStakes[staker_address][theArrayIndex];
_updateRewardAndBalance(staker_address, true, true);
stakingToken.transfer(destination_address, liquidity);
emit WithdrawLocked(staker_address, liquidity, kek_id, destination_address);
}
}
function getReward() external nonReentrant returns (uint256[] memory) {
require(rewardsCollectionPaused == false,"Rewards collection paused");
return _getReward(msg.sender, msg.sender);
}
function _getReward(address rewardee, address destination_address) internal updateRewardAndBalance(rewardee, true) returns (uint256[] memory _rtnRewards) {
_rtnRewards = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardTokens.length; i++) {
_rtnRewards[i] = rewards[rewardee][i];
if (_rtnRewards[i] > 0) {
rewards[rewardee][i] = 0;
ERC20(rewardTokens[i]).transfer(destination_address, _rtnRewards[i]);
ttlRewsPaid[i] += _rtnRewards[i];
emit RewardPaid(rewardee, _rtnRewards[i], rewardTokens[i], destination_address);
}
}
lastRewardClaimTime[rewardee] = block.timestamp;
}
function syncRewards() internal {
if ((block.timestamp).sub(lastRewardPull) >= rewardsDuration) {
if (address(rewarder) != address(0)) {
rewarder.distributeReward();
}
{
stakingToken.getReward(address(this));
}
lastRewardPull = block.timestamp;
}
uint256 _eligibleElapsedTime = Math.min((block.timestamp).sub(lastUpdateTime), rewardsDuration);
uint256[] memory _reward = rewardPerToken();
for (uint256 i = 0; i < rewardTokens.length; i++) {
uint256 _currBal = ERC20(rewardTokens[i]).balanceOf(address(this));
ttlRewsOwed[i] += rewardRates[i].mul(_eligibleElapsedTime);
rewardsPerTokenStored[i] = _reward[i];
{
uint256 _unpaid = ttlRewsOwed[i].sub(ttlRewsPaid[i]);
if (_currBal <= _unpaid){
rewardRates[i] = 0;
}
else {
uint256 _free = _currBal.sub(_unpaid);
rewardRates[i] = (_free).div(rewardsDuration);
}
}
}
}
function sync() public {
require(isInitialized, "Contract not initialized");
syncRewards();
lastUpdateTime = block.timestamp;
periodFinish = (block.timestamp).add(rewardsDuration);
}
function initializeDefault() external onlyByOwnGovCtrlr {
require(!isInitialized, "Already initialized");
isInitialized = true;
sync();
emit DefaultInitialization();
}
function migrator_stakeLocked_for(address staker_address, uint256 amount, uint256 secs, uint256 start_timestamp) external isMigrating {
require(staker_allowed_migrators[staker_address][msg.sender] && valid_migrators[msg.sender], "Mig. invalid or unapproved");
_stakeLocked(staker_address, msg.sender, amount, secs, start_timestamp);
}
function migrator_withdraw_locked(address staker_address, bytes32 kek_id) external isMigrating {
require(staker_allowed_migrators[staker_address][msg.sender] && valid_migrators[msg.sender], "Mig. invalid or unapproved");
_withdrawLocked(staker_address, msg.sender, kek_id, true);
}
function addMigrator(address migrator_address) external onlyByOwnGov {
valid_migrators[migrator_address] = true;
}
function removeMigrator(address migrator_address) external onlyByOwnGov {
require(valid_migrators[migrator_address] == true, "Address nonexistent");
delete valid_migrators[migrator_address];
}
function recoverERC20(address tokenAddress, uint256 tokenAmount) external onlyByOwnGov {
if(!migrationsOn){
require(tokenAddress != address(stakingToken), "Not in migration");
}
ERC20(tokenAddress).transfer(owner, tokenAmount);
emit Recovered(tokenAddress, tokenAmount);
}
function setMultipliers(uint256 _lock_max_multiplier, uint256 _vefxs_max_multiplier, uint256 _vefxs_per_frax_for_max_boost) external onlyByOwnGov {
require(_lock_max_multiplier >= MULTIPLIER_PRECISION, "Mult must be >= MULTIPLIER_PRECISION");
require(_vefxs_max_multiplier >= 0, "veFXS mul must be >= 0");
require(_vefxs_per_frax_for_max_boost > 0, "veFXS pct max must be >= 0");
lock_max_multiplier = _lock_max_multiplier;
vefxs_max_multiplier = _vefxs_max_multiplier;
vefxs_per_frax_for_max_boost = _vefxs_per_frax_for_max_boost;
emit MaxVeFXSMultiplier(vefxs_max_multiplier);
emit LockedStakeMaxMultiplierUpdated(lock_max_multiplier);
emit veFXSPerFraxForMaxBoostUpdated(vefxs_per_frax_for_max_boost);
}
function setLockedStakeTimeForMinAndMaxMultiplier(uint256 _lock_time_for_max_multiplier, uint256 _lock_time_min) external onlyByOwnGov {
require(_lock_time_for_max_multiplier >= 1, "Mul max time must be >= 1");
require(_lock_time_min >= 1, "Mul min time must be >= 1");
lock_time_for_max_multiplier = _lock_time_for_max_multiplier;
lock_time_min = _lock_time_min;
emit LockedStakeTimeForMaxMultiplier(lock_time_for_max_multiplier);
emit LockedStakeMinTime(_lock_time_min);
}
function unlockStakes() external onlyByOwnGov {
stakesUnlocked = !stakesUnlocked;
}
function toggleMigrations() external onlyByOwnGov {
migrationsOn = !migrationsOn;
}
function toggleCollectRewardsOnWithdrawal() external onlyByOwnGov {
collectRewardsOnWithdrawalPaused = !collectRewardsOnWithdrawalPaused;
}
function toggleStaking() external onlyByOwnGov {
stakingPaused = !stakingPaused;
}
function toggleWithdrawals() external onlyByOwnGov {
withdrawalsPaused = !withdrawalsPaused;
}
function toggleRewardsCollection() external onlyByOwnGov {
rewardsCollectionPaused = !rewardsCollectionPaused;
}
function setTimelock(address _new_timelock) external onlyByOwnGov {
timelockAddress = _new_timelock;
}
function setController(address _controllerAddress) external onlyByOwnGov {
controllerAddress = _controllerAddress;
}
function setVeFXS(address _vefxs_address) external onlyByOwnGov {
veFXS = IveFXS(_vefxs_address);
}
event StakeLocked(address indexed user, uint256 amount, uint256 secs, bytes32 kek_id, address source_address);
event WithdrawLocked(address indexed user, uint256 amount, bytes32 kek_id, address destination_address);
event RewardPaid(address indexed user, uint256 reward, address token_address, address destination_address);
event DefaultInitialization();
event Recovered(address token, uint256 amount);
event LockedStakeMaxMultiplierUpdated(uint256 multiplier);
event LockedStakeTimeForMaxMultiplier(uint256 secs);
event LockedStakeMinTime(uint256 secs);
event LockedAdditional(address indexed user, bytes32 kek_id, uint256 amount);
event LockedLonger(address indexed user, bytes32 kek_id, uint256 new_secs, uint256 new_start_ts, uint256 new_end_ts);
event MaxVeFXSMultiplier(uint256 multiplier);
event veFXSPerFraxForMaxBoostUpdated(uint256 scale_factor);
}
contract FraxCCFarmV4_cvxLP is FraxCrossChainFarmV4_ERC20 {
string public farm_type = "FraxCCFarmV4_cvxLP";
constructor (
address _owner,
address[] memory _rewardTokens,
address _stakingToken,
address _fraxAddress,
address _timelockAddress,
address _rewarder_address
)
FraxCrossChainFarmV4_ERC20(_owner, _rewardTokens, _stakingToken, _fraxAddress, _timelockAddress, _rewarder_address)
{}
}
