File 1 of 1: StakingApp.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, 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 from, address to, uint256 amount) external returns (bool);
}
pragma solidity ^0.8.0;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
pragma solidity ^0.8.0;
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 to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, 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) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, 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;
unchecked {
_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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
pragma solidity ^0.8.0;
library EnumerableMap {
using EnumerableSet for EnumerableSet.Bytes32Set;
struct Bytes32ToBytes32Map {
EnumerableSet.Bytes32Set _keys;
mapping(bytes32 => bytes32) _values;
}
function set(Bytes32ToBytes32Map storage map, bytes32 key, bytes32 value) internal returns (bool) {
map._values[key] = value;
return map._keys.add(key);
}
function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns (bool) {
delete map._values[key];
return map._keys.remove(key);
}
function contains(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool) {
return map._keys.contains(key);
}
function length(Bytes32ToBytes32Map storage map) internal view returns (uint256) {
return map._keys.length();
}
function at(Bytes32ToBytes32Map storage map, uint256 index) internal view returns (bytes32, bytes32) {
bytes32 key = map._keys.at(index);
return (key, map._values[key]);
}
function tryGet(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bool, bytes32) {
bytes32 value = map._values[key];
if (value == bytes32(0)) {
return (contains(map, key), bytes32(0));
} else {
return (true, value);
}
}
function get(Bytes32ToBytes32Map storage map, bytes32 key) internal view returns (bytes32) {
bytes32 value = map._values[key];
require(value != 0 || contains(map, key), "EnumerableMap: nonexistent key");
return value;
}
function get(
Bytes32ToBytes32Map storage map,
bytes32 key,
string memory errorMessage
) internal view returns (bytes32) {
bytes32 value = map._values[key];
require(value != 0 || contains(map, key), errorMessage);
return value;
}
function keys(Bytes32ToBytes32Map storage map) internal view returns (bytes32[] memory) {
return map._keys.values();
}
struct UintToUintMap {
Bytes32ToBytes32Map _inner;
}
function set(UintToUintMap storage map, uint256 key, uint256 value) internal returns (bool) {
return set(map._inner, bytes32(key), bytes32(value));
}
function remove(UintToUintMap storage map, uint256 key) internal returns (bool) {
return remove(map._inner, bytes32(key));
}
function contains(UintToUintMap storage map, uint256 key) internal view returns (bool) {
return contains(map._inner, bytes32(key));
}
function length(UintToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
function at(UintToUintMap storage map, uint256 index) internal view returns (uint256, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (uint256(key), uint256(value));
}
function tryGet(UintToUintMap storage map, uint256 key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
return (success, uint256(value));
}
function get(UintToUintMap storage map, uint256 key) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(key)));
}
function get(UintToUintMap storage map, uint256 key, string memory errorMessage) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(key), errorMessage));
}
function keys(UintToUintMap storage map) internal view returns (uint256[] memory) {
bytes32[] memory store = keys(map._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
struct UintToAddressMap {
Bytes32ToBytes32Map _inner;
}
function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
return set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
}
function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
return remove(map._inner, bytes32(key));
}
function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
return contains(map._inner, bytes32(key));
}
function length(UintToAddressMap storage map) internal view returns (uint256) {
return length(map._inner);
}
function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (uint256(key), address(uint160(uint256(value))));
}
function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(key));
return (success, address(uint160(uint256(value))));
}
function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
return address(uint160(uint256(get(map._inner, bytes32(key)))));
}
function get(
UintToAddressMap storage map,
uint256 key,
string memory errorMessage
) internal view returns (address) {
return address(uint160(uint256(get(map._inner, bytes32(key), errorMessage))));
}
function keys(UintToAddressMap storage map) internal view returns (uint256[] memory) {
bytes32[] memory store = keys(map._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
struct AddressToUintMap {
Bytes32ToBytes32Map _inner;
}
function set(AddressToUintMap storage map, address key, uint256 value) internal returns (bool) {
return set(map._inner, bytes32(uint256(uint160(key))), bytes32(value));
}
function remove(AddressToUintMap storage map, address key) internal returns (bool) {
return remove(map._inner, bytes32(uint256(uint160(key))));
}
function contains(AddressToUintMap storage map, address key) internal view returns (bool) {
return contains(map._inner, bytes32(uint256(uint160(key))));
}
function length(AddressToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
function at(AddressToUintMap storage map, uint256 index) internal view returns (address, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (address(uint160(uint256(key))), uint256(value));
}
function tryGet(AddressToUintMap storage map, address key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, bytes32(uint256(uint160(key))));
return (success, uint256(value));
}
function get(AddressToUintMap storage map, address key) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(uint256(uint160(key)))));
}
function get(
AddressToUintMap storage map,
address key,
string memory errorMessage
) internal view returns (uint256) {
return uint256(get(map._inner, bytes32(uint256(uint160(key))), errorMessage));
}
function keys(AddressToUintMap storage map) internal view returns (address[] memory) {
bytes32[] memory store = keys(map._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct Bytes32ToUintMap {
Bytes32ToBytes32Map _inner;
}
function set(Bytes32ToUintMap storage map, bytes32 key, uint256 value) internal returns (bool) {
return set(map._inner, key, bytes32(value));
}
function remove(Bytes32ToUintMap storage map, bytes32 key) internal returns (bool) {
return remove(map._inner, key);
}
function contains(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool) {
return contains(map._inner, key);
}
function length(Bytes32ToUintMap storage map) internal view returns (uint256) {
return length(map._inner);
}
function at(Bytes32ToUintMap storage map, uint256 index) internal view returns (bytes32, uint256) {
(bytes32 key, bytes32 value) = at(map._inner, index);
return (key, uint256(value));
}
function tryGet(Bytes32ToUintMap storage map, bytes32 key) internal view returns (bool, uint256) {
(bool success, bytes32 value) = tryGet(map._inner, key);
return (success, uint256(value));
}
function get(Bytes32ToUintMap storage map, bytes32 key) internal view returns (uint256) {
return uint256(get(map._inner, key));
}
function get(
Bytes32ToUintMap storage map,
bytes32 key,
string memory errorMessage
) internal view returns (uint256) {
return uint256(get(map._inner, key, errorMessage));
}
function keys(Bytes32ToUintMap storage map) internal view returns (bytes32[] memory) {
bytes32[] memory store = keys(map._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
}
pragma solidity ^0.8.0;
library Clones {
function clone(address implementation) internal returns (address instance) {
assembly {
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create(0, 0x09, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
assembly {
mstore(0x00, or(shr(0xe8, shl(0x60, implementation)), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
mstore(0x20, or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3))
instance := create2(0, 0x09, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
function predictDeterministicAddress(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x38), deployer)
mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
mstore(add(ptr, 0x14), implementation)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
mstore(add(ptr, 0x58), salt)
mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
predicted := keccak256(add(ptr, 0x43), 0x55)
}
}
function predictDeterministicAddress(
address implementation,
bytes32 salt
) internal view returns (address predicted) {
return predictDeterministicAddress(implementation, salt, address(this));
}
}
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
pragma solidity ^0.8.20;
contract ReToken is ERC20 {
address private _deployer;
address private _token;
modifier onlyDeployer {
require(msg.sender == _deployer, "Only callable by deployer");
_;
}
constructor() ERC20("", "") {
_deployer = msg.sender;
}
function initialize(address token) external {
require(_deployer == address(0), "Initialized");
_deployer = msg.sender;
_token = token;
}
function name() public view override returns (string memory) {
return string.concat("Rebase ", ERC20(_token).name());
}
function symbol() public view override returns (string memory) {
return string.concat("re", ERC20(_token).symbol());
}
function decimals() public view override returns (uint8) {
return ERC20(_token).decimals();
}
function mint(address to, uint tokens) external onlyDeployer {
_mint(to, tokens);
}
function burn(address from, uint tokens) external onlyDeployer {
_burn(from, tokens);
}
}
pragma solidity ^0.8.20;
interface Rebased {
function onStake(address user, address token, uint quantity) external;
function onUnstake(address user, address token, uint quantity) external;
}
interface WETH {
function deposit() external payable;
function withdraw(uint amount) external;
}
contract Rebase is ReentrancyGuard {
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableMap for EnumerableMap.AddressToUintMap;
using EnumerableMap for EnumerableMap.UintToAddressMap;
using SafeMath for uint256;
struct User {
EnumerableSet.AddressSet apps;
mapping(address => EnumerableMap.AddressToUintMap) appTokenStakes;
}
EnumerableMap.UintToAddressMap private _tokenReToken;
mapping(address => User) private _users;
mapping(address => EnumerableMap.AddressToUintMap) private _appTokenStakes;
mapping(address => EnumerableSet.AddressSet) private _appUsers;
address private constant _WETH = 0x4200000000000000000000000000000000000006;
address private immutable _clonableToken;
uint public constant UNRESTAKE_GAS_LIMIT = 1000000;
event Stake (
address indexed user,
address indexed app,
address indexed token,
uint quantity
);
event Unstake (
address indexed user,
address indexed app,
address indexed token,
uint quantity,
bool forced
);
constructor() {
_clonableToken = address(new ReToken());
}
receive() external payable { }
function stake(address token, uint quantity, address app) external nonReentrant {
require(ERC20(token).transferFrom(msg.sender, address(this), quantity), "Unable to transfer token");
_getReToken(token).mint(msg.sender, quantity);
_stake(app, token, quantity);
}
function stakeETH(address app) external payable nonReentrant {
WETH(_WETH).deposit{value: msg.value}();
_getReToken(_WETH).mint(msg.sender, msg.value);
_stake(app, _WETH, msg.value);
}
function unstake(address token, uint quantity, address app) external nonReentrant {
_unstake(app, token, quantity);
_getReToken(token).burn(msg.sender, quantity);
require(ERC20(token).transfer(msg.sender, quantity), "Unable to transfer token");
}
function unstakeETH(uint quantity, address app) external nonReentrant {
_unstake(app, _WETH, quantity);
_getReToken(_WETH).burn(msg.sender, quantity);
WETH(_WETH).withdraw(quantity);
(bool transferred,) = msg.sender.call{value: quantity}("");
require(transferred, "Transfer failed");
}
function restake(address token, uint quantity, address fromApp, address toApp) external nonReentrant {
_unstake(fromApp, token, quantity);
_stake(toApp, token, quantity);
}
function _stake(address app, address token, uint quantity) internal {
User storage user = _users[msg.sender];
(,uint userStake) = user.appTokenStakes[app].tryGet(token);
(,uint appStake) = _appTokenStakes[app].tryGet(token);
require(quantity > 0, "Invalid token quantity");
user.apps.add(app);
user.appTokenStakes[app].set(token, userStake.add(quantity));
_appTokenStakes[app].set(token, appStake.add(quantity));
_appUsers[app].add(msg.sender);
Rebased(app).onStake(msg.sender, token, quantity);
emit Stake(msg.sender, app, token, quantity);
}
function _unstake(address app, address token, uint quantity) internal {
User storage user = _users[msg.sender];
(,uint userStake) = user.appTokenStakes[app].tryGet(token);
(,uint appStake) = _appTokenStakes[app].tryGet(token);
require(quantity > 0 && quantity <= userStake, "Invalid token quantity");
if (userStake == quantity) {
user.appTokenStakes[app].remove(token);
if (user.appTokenStakes[app].length() == 0) {
user.apps.remove(app);
_appUsers[app].remove(msg.sender);
}
} else {
user.appTokenStakes[app].set(token, userStake.sub(quantity));
}
_appTokenStakes[app].set(token, appStake.sub(quantity));
bool forced = false;
try Rebased(app).onUnstake{gas: UNRESTAKE_GAS_LIMIT}(msg.sender, token, quantity) { }
catch { forced = true; }
emit Unstake(msg.sender, app, token, quantity, forced);
}
function _getReToken(address token) internal returns (ReToken) {
uint tokenId = _tokenToId(token);
(bool exists, address reToken) = _tokenReToken.tryGet(tokenId);
if (!exists) {
reToken = Clones.cloneDeterministic(_clonableToken, bytes32(tokenId));
ReToken(reToken).initialize(token);
_tokenReToken.set(tokenId, reToken);
}
return ReToken(reToken);
}
function _tokenToId(address token) internal pure returns (uint) {
return uint(uint160(token));
}
function getUserApps(address user) external view returns (address[] memory) {
return _users[user].apps.values();
}
function getUserAppAt(address user, uint index) external view returns (address) {
return _users[user].apps.at(index);
}
function getNumUserApps(address user) external view returns (uint) {
return _users[user].apps.length();
}
function getAppUsers(address app) external view returns (address[] memory) {
return _appUsers[app].values();
}
function getAppUserAt(address app, uint index) external view returns (address) {
return _appUsers[app].at(index);
}
function getNumAppUsers(address app) external view returns (uint) {
return _appUsers[app].length();
}
function getAppStake(address app, address token) external view returns (uint) {
(,uint appStake) = _appTokenStakes[app].tryGet(token);
return appStake;
}
function getAppStakes(address app) external view returns (address[] memory, uint[] memory) {
EnumerableMap.AddressToUintMap storage appStakes = _appTokenStakes[app];
address[] memory tokens = appStakes.keys();
uint[] memory stakes = new uint[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
stakes[i] = appStakes.get(tokens[i]);
}
return (tokens, stakes);
}
function getAppStakeAt(address app, uint index) external view returns (address, uint) {
return _appTokenStakes[app].at(index);
}
function getNumAppStakes(address app) external view returns (uint) {
return _appTokenStakes[app].length();
}
function getUserAppStake(address user, address app, address token) external view returns (uint) {
(,uint userStake) = _users[user].appTokenStakes[app].tryGet(token);
return userStake;
}
function getUserAppStakes(address user, address app) external view returns (address[] memory, uint[] memory) {
EnumerableMap.AddressToUintMap storage userStakes = _users[user].appTokenStakes[app];
address[] memory tokens = userStakes.keys();
uint[] memory stakes = new uint[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
stakes[i] = userStakes.get(tokens[i]);
}
return (tokens, stakes);
}
function getUserAppStakeAt(address user, address app, uint index) external view returns (address, uint) {
return _users[user].appTokenStakes[app].at(index);
}
function getNumUserAppStakes(address user, address app) external view returns (uint) {
return _users[user].appTokenStakes[app].length();
}
function getReToken(address token) external view returns (address) {
return _tokenReToken.get(_tokenToId(token));
}
}
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
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 & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
pragma solidity ^0.8.0;
contract RewardPool {
using SafeMath for uint256;
uint256 public immutable rewardTotal;
uint256 public immutable rewardDuration;
address public immutable rewardDistributor;
address public immutable rewardToken;
uint256 public immutable periodFinish;
uint256 public immutable rewardRate;
uint256 public lastUpdateTime;
uint256 public rewardPerTokenStored;
mapping(address => uint256) public userRewardPerTokenPaid;
mapping(address => uint256) public rewards;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
event RewardAdded(uint256 reward);
event RewardPaid(address indexed user, uint256 reward);
modifier updateReward(address user) {
rewardPerTokenStored = rewardPerToken();
lastUpdateTime = lastTimeRewardApplicable();
if (user != address(0)) {
rewards[user] = earned(user);
userRewardPerTokenPaid[user] = rewardPerTokenStored;
}
_;
}
modifier onlyRewardDistributor() {
require(msg.sender == rewardDistributor, "Caller is not reward distribution");
_;
}
constructor(uint reward, address token, uint duration) {
rewardTotal = reward;
rewardDuration = duration;
rewardDistributor = msg.sender;
rewardToken = token;
lastUpdateTime = block.timestamp;
periodFinish = block.timestamp.add(rewardDuration);
rewardRate = reward.div(rewardDuration);
emit RewardAdded(reward);
}
function lastTimeRewardApplicable() public view returns (uint256) {
return Math.min(block.timestamp, periodFinish);
}
function rewardPerToken() public view returns (uint256) {
if (_totalSupply == 0) {
return rewardPerTokenStored;
}
return
rewardPerTokenStored.add(
lastTimeRewardApplicable()
.sub(lastUpdateTime)
.mul(rewardRate)
.mul(1e18)
.div(_totalSupply)
);
}
function earned(address user) public view returns (uint256) {
return
balanceOf(user)
.mul(rewardPerToken().sub(userRewardPerTokenPaid[user]))
.div(1e18)
.add(rewards[user]);
}
function add(address user, uint256 amount) external onlyRewardDistributor updateReward(user) {
_totalSupply = _totalSupply.add(amount);
_balances[user] = _balances[user].add(amount);
}
function remove(address user, uint256 amount) external onlyRewardDistributor updateReward(user) {
_totalSupply = _totalSupply.sub(amount);
_balances[user] = _balances[user].sub(amount);
}
function payReward(address user) public onlyRewardDistributor updateReward(user) {
uint256 reward = earned(user);
if (reward > 0) {
rewards[user] = 0;
ERC20(rewardToken).transfer(user, reward);
emit RewardPaid(user, reward);
}
}
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
function balanceOf(address user) public view returns (uint256) {
return _balances[user];
}
function getStartTime() public view returns (uint256) {
return periodFinish - rewardDuration;
}
function getEndTime() public view returns (uint256) {
return periodFinish;
}
function getTotalReward() public view returns (uint256) {
return rewardTotal;
}
}
pragma solidity ^0.8.0;
contract StakingApp is Rebased, Ownable {
using EnumerableSet for EnumerableSet.AddressSet;
using EnumerableMap for EnumerableMap.AddressToUintMap;
using SafeMath for uint256;
address private constant _rebase = 0x89fA20b30a88811FBB044821FEC130793185c60B;
address private immutable _rewardToken;
EnumerableSet.AddressSet private _tokens;
mapping(address => EnumerableSet.AddressSet) private _tokenPools;
mapping(address => EnumerableSet.AddressSet) private _userPools;
mapping(address => EnumerableMap.AddressToUintMap) private _userTokenStakes;
modifier onlyRebase {
require(msg.sender == _rebase, "Only Rebase");
_;
}
constructor(address rewardToken) {
_rewardToken = rewardToken;
}
function createPool(address[] memory tokens, uint[] memory quantities, uint[] memory durations) external onlyOwner {
require(tokens.length == quantities.length && tokens.length == durations.length, "Array mismatch");
for (uint i = 0; i < tokens.length; i++) {
address token = tokens[i];
uint quantity = quantities[i];
uint duration = durations[i];
address pool = address(new RewardPool(quantity, _rewardToken, duration));
require(ERC20(_rewardToken).transferFrom(msg.sender, pool, quantity), "Unable to transfer token");
_tokenPools[token].add(pool);
_tokens.add(token);
}
}
function onStake(address user, address token, uint quantity) external onlyRebase {
address[] memory pools = _tokenPools[token].values();
require(pools.length > 0, "No pools for token");
EnumerableSet.AddressSet storage userPools = _userPools[user];
(,uint stake) = _userTokenStakes[user].tryGet(token);
uint newBalance = stake.add(quantity);
for (uint i = 0; i < pools.length; i++) {
address pool = pools[i];
if (userPools.contains(pool)) {
RewardPool(pool).add(user, quantity);
} else {
userPools.add(pool);
RewardPool(pool).add(user, newBalance);
}
}
_userTokenStakes[user].set(token, newBalance);
}
function onUnstake(address user, address token, uint quantity) external onlyRebase {
address[] memory pools = _tokenPools[token].values();
EnumerableSet.AddressSet storage userPools = _userPools[user];
(,uint stake) = _userTokenStakes[user].tryGet(token);
for (uint i = 0; i < pools.length; i++) {
address pool = pools[i];
if (userPools.contains(pool)) {
RewardPool(pool).remove(user, quantity);
}
}
_userTokenStakes[user].set(token, stake.sub(quantity));
}
function syncPools(address[] memory tokens) external {
EnumerableSet.AddressSet storage userPools = _userPools[msg.sender];
for (uint j = 0; j < tokens.length; j++) {
address token = tokens[j];
(,uint stake) = _userTokenStakes[msg.sender].tryGet(token);
if (stake > 0) {
address[] memory pools = _tokenPools[token].values();
for (uint i = 0; i < pools.length; i++) {
address pool = pools[i];
if (!userPools.contains(pool)) {
userPools.add(pool);
RewardPool(pool).add(msg.sender, stake);
}
}
}
}
}
function claimRewards() external {
address[] memory pools = _userPools[msg.sender].values();
for (uint i = 0; i < pools.length; i++) {
RewardPool(pools[i]).payReward(msg.sender);
}
}
function getRewards(address user) external view returns (uint) {
uint earned = 0;
address[] memory pools = _userPools[user].values();
for (uint i = 0; i < pools.length; i++) {
earned += RewardPool(pools[i]).earned(user);
}
return earned;
}
function getTokens() public view returns (address[] memory) {
return _tokens.values();
}
function getTokenAt(uint index) external view returns (address) {
return _tokens.at(index);
}
function getNumTokens() external view returns (uint) {
return _tokens.length();
}
function getUserPools(address user) external view returns (address[] memory) {
return _userPools[user].values();
}
function getUserPoolAt(address user, uint index) external view returns (address) {
return _userPools[user].at(index);
}
function getNumUserPools(address user) external view returns (uint) {
return _userPools[user].length();
}
function getTokenPools(address token) external view returns (address[] memory) {
return _tokenPools[token].values();
}
function getTokenPoolAt(address token, uint index) external view returns (address) {
return _tokenPools[token].at(index);
}
function getNumTokenPools(address token) external view returns (uint) {
return _tokenPools[token].length();
}
function getUserStake(address user, address token) external view returns (uint) {
(,uint userStake) = _userTokenStakes[user].tryGet(token);
return userStake;
}
function getUserStakes(address user) external view returns (address[] memory, uint[] memory) {
EnumerableMap.AddressToUintMap storage userStakes = _userTokenStakes[user];
address[] memory tokens = userStakes.keys();
uint[] memory stakes = new uint[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
stakes[i] = userStakes.get(tokens[i]);
}
return (tokens, stakes);
}
function getUserStakeAt(address user, uint index) external view returns (address, uint) {
return _userTokenStakes[user].at(index);
}
function getNumUserStakes(address user) external view returns (uint) {
return _userTokenStakes[user].length();
}
function getRewardToken() external view returns (address) {
return _rewardToken;
}
}
