|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
interface IAccessControl {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
|
|
|
|
|
|
|
|
|
|
function hasRole(bytes32 role, address account) external view returns (bool);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function getRoleAdmin(bytes32 role) external view returns (bytes32);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function grantRole(bytes32 role, address account) external;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function revokeRole(bytes32 role, address account) external;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function renounceRole(bytes32 role, address account) external;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
library Strings {
|
|
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
|
|
uint8 private constant _ADDRESS_LENGTH = 20;
|
|
|
|
|
|
|
|
|
|
function toString(uint256 value) internal pure returns (string memory) {
|
|
|
|
|
|
|
|
if (value == 0) {
|
|
return "0";
|
|
}
|
|
uint256 temp = value;
|
|
uint256 digits;
|
|
while (temp != 0) {
|
|
digits++;
|
|
temp /= 10;
|
|
}
|
|
bytes memory buffer = new bytes(digits);
|
|
while (value != 0) {
|
|
digits -= 1;
|
|
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
|
|
value /= 10;
|
|
}
|
|
return string(buffer);
|
|
}
|
|
|
|
|
|
|
|
|
|
function toHexString(uint256 value) internal pure returns (string memory) {
|
|
if (value == 0) {
|
|
return "0x00";
|
|
}
|
|
uint256 temp = value;
|
|
uint256 length = 0;
|
|
while (temp != 0) {
|
|
length++;
|
|
temp >>= 8;
|
|
}
|
|
return toHexString(value, length);
|
|
}
|
|
|
|
|
|
|
|
|
|
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
|
|
bytes memory buffer = new bytes(2 * length + 2);
|
|
buffer[0] = "0";
|
|
buffer[1] = "x";
|
|
for (uint256 i = 2 * length + 1; i > 1; --i) {
|
|
buffer[i] = _HEX_SYMBOLS[value & 0xf];
|
|
value >>= 4;
|
|
}
|
|
require(value == 0, "Strings: hex length insufficient");
|
|
return string(buffer);
|
|
}
|
|
|
|
|
|
|
|
|
|
function toHexString(address addr) internal pure returns (string memory) {
|
|
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
interface IERC165 {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function supportsInterface(bytes4 interfaceId) external view returns (bool);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
abstract contract ERC165 is IERC165 {
|
|
|
|
|
|
|
|
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
|
|
return interfaceId == type(IERC165).interfaceId;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
abstract contract AccessControl is Context, IAccessControl, ERC165 {
|
|
struct RoleData {
|
|
mapping(address => bool) members;
|
|
bytes32 adminRole;
|
|
}
|
|
|
|
mapping(bytes32 => RoleData) private _roles;
|
|
|
|
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
modifier onlyRole(bytes32 role) {
|
|
_checkRole(role);
|
|
_;
|
|
}
|
|
|
|
|
|
|
|
|
|
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
|
|
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
|
|
}
|
|
|
|
|
|
|
|
|
|
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
|
|
return _roles[role].members[account];
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _checkRole(bytes32 role) internal view virtual {
|
|
_checkRole(role, _msgSender());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _checkRole(bytes32 role, address account) internal view virtual {
|
|
if (!hasRole(role, account)) {
|
|
revert(
|
|
string(
|
|
abi.encodePacked(
|
|
"AccessControl: account ",
|
|
Strings.toHexString(uint160(account), 20),
|
|
" is missing role ",
|
|
Strings.toHexString(uint256(role), 32)
|
|
)
|
|
)
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
|
|
return _roles[role].adminRole;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
|
|
_grantRole(role, account);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
|
|
_revokeRole(role, account);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function renounceRole(bytes32 role, address account) public virtual override {
|
|
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
|
|
|
|
_revokeRole(role, account);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _setupRole(bytes32 role, address account) internal virtual {
|
|
_grantRole(role, account);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
|
|
bytes32 previousAdminRole = getRoleAdmin(role);
|
|
_roles[role].adminRole = adminRole;
|
|
emit RoleAdminChanged(role, previousAdminRole, adminRole);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _grantRole(bytes32 role, address account) internal virtual {
|
|
if (!hasRole(role, account)) {
|
|
_roles[role].members[account] = true;
|
|
emit RoleGranted(role, account, _msgSender());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _revokeRole(bytes32 role, address account) internal virtual {
|
|
if (hasRole(role, account)) {
|
|
_roles[role].members[account] = false;
|
|
emit RoleRevoked(role, account, _msgSender());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
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.1;
|
|
|
|
|
|
|
|
|
|
library Address {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function isContract(address account) internal view returns (bool) {
|
|
|
|
|
|
|
|
|
|
return account.code.length > 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
|
|
) internal 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
library SafeERC20 {
|
|
using Address for address;
|
|
|
|
function safeTransfer(
|
|
IERC20 token,
|
|
address to,
|
|
uint256 value
|
|
) internal {
|
|
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
|
|
}
|
|
|
|
function safeTransferFrom(
|
|
IERC20 token,
|
|
address from,
|
|
address to,
|
|
uint256 value
|
|
) internal {
|
|
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function safeApprove(
|
|
IERC20 token,
|
|
address spender,
|
|
uint256 value
|
|
) internal {
|
|
|
|
|
|
|
|
require(
|
|
(value == 0) || (token.allowance(address(this), spender) == 0),
|
|
"SafeERC20: approve from non-zero to non-zero allowance"
|
|
);
|
|
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
|
|
}
|
|
|
|
function safeIncreaseAllowance(
|
|
IERC20 token,
|
|
address spender,
|
|
uint256 value
|
|
) internal {
|
|
uint256 newAllowance = token.allowance(address(this), spender) + value;
|
|
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
|
|
}
|
|
|
|
function safeDecreaseAllowance(
|
|
IERC20 token,
|
|
address spender,
|
|
uint256 value
|
|
) internal {
|
|
unchecked {
|
|
uint256 oldAllowance = token.allowance(address(this), spender);
|
|
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
|
|
uint256 newAllowance = oldAllowance - value;
|
|
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
|
|
}
|
|
}
|
|
|
|
function safePermit(
|
|
IERC20Permit token,
|
|
address owner,
|
|
address spender,
|
|
uint256 value,
|
|
uint256 deadline,
|
|
uint8 v,
|
|
bytes32 r,
|
|
bytes32 s
|
|
) internal {
|
|
uint256 nonceBefore = token.nonces(owner);
|
|
token.permit(owner, spender, value, deadline, v, r, s);
|
|
uint256 nonceAfter = token.nonces(owner);
|
|
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.3;
|
|
|
|
|
|
|
|
|
|
contract YandaMultitokenProtocolV1 is AccessControl{
|
|
|
|
using SafeMath for uint256;
|
|
using SafeERC20 for IERC20;
|
|
|
|
uint internal TIME_FRAME_SIZE;
|
|
uint internal VALIDATORS_PERC;
|
|
uint internal BROKER_PERC;
|
|
uint internal FEE_NOMINATOR;
|
|
uint internal FEE_DENOMINATOR;
|
|
uint internal _penaltyPerc;
|
|
uint internal _lockingPeriod;
|
|
uint256 internal _totalStaked;
|
|
IERC20 internal _tokenContract;
|
|
address payable internal _beneficiary;
|
|
|
|
enum State { AWAITING_COST, AWAITING_TRANSFER, AWAITING_TERMINATION, AWAITING_VALIDATION, COMPLETED }
|
|
struct Process {
|
|
State state;
|
|
uint256 cost;
|
|
uint256 costConf;
|
|
address token;
|
|
address payable deposit;
|
|
address payable depositConf;
|
|
uint256 fee;
|
|
address service;
|
|
bytes32 productId;
|
|
uint256 startBlock;
|
|
address[] validatorsList;
|
|
address firstValidator;
|
|
bool firstResult;
|
|
address secondValidator;
|
|
bool secondResult;
|
|
}
|
|
struct Service {
|
|
address[] validators;
|
|
uint validationPerc;
|
|
uint commissionPerc;
|
|
uint validatorVersion;
|
|
}
|
|
struct Stake {
|
|
uint256 amount;
|
|
uint256 unlockingBlock;
|
|
}
|
|
mapping(address => mapping(bytes32 => Process)) internal _processes;
|
|
mapping(address => bytes32) internal _depositingProducts;
|
|
mapping(address => Service) internal _services;
|
|
mapping(address => uint256) internal _stakesByValidators;
|
|
mapping(address => address[]) internal _validatorStakers;
|
|
mapping(address => mapping(address => Stake)) internal _stakes;
|
|
|
|
event Deposit(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
uint256 weiAmount
|
|
);
|
|
event Action(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
string data
|
|
);
|
|
event Terminate(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
address[] validatorsList
|
|
);
|
|
event Complete(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
bool success
|
|
);
|
|
event CostRequest(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
address[] validatorsList,
|
|
string data
|
|
);
|
|
event CostResponse(
|
|
address indexed customer,
|
|
address indexed service,
|
|
bytes32 indexed productId,
|
|
uint cost
|
|
);
|
|
event Staked(
|
|
address indexed staker,
|
|
address indexed validator,
|
|
uint256 amount,
|
|
uint256 unlockingBlock
|
|
);
|
|
event UnStaked(
|
|
address indexed staker,
|
|
address indexed validator,
|
|
uint256 amount
|
|
);
|
|
|
|
modifier onlyService() {
|
|
require(_services[msg.sender].validators.length > 0, "Only service can call this method");
|
|
_;
|
|
}
|
|
|
|
constructor(uint penaltyPerc, uint lockingPeriod, address token) {
|
|
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
|
|
_beneficiary = payable(msg.sender);
|
|
|
|
_penaltyPerc = penaltyPerc;
|
|
_lockingPeriod = lockingPeriod;
|
|
_tokenContract = IERC20(token);
|
|
|
|
VALIDATORS_PERC = 15;
|
|
BROKER_PERC = 80;
|
|
FEE_NOMINATOR = 2;
|
|
FEE_DENOMINATOR = 1000;
|
|
TIME_FRAME_SIZE = 50;
|
|
}
|
|
|
|
function _containsAddress(address[] memory array, address search) internal pure returns(bool) {
|
|
for(uint x=0; x < array.length; x++) {
|
|
if (array[x] == search) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function setBeneficiary(address payable newAddr) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
_beneficiary = newAddr;
|
|
}
|
|
|
|
function setDefaultPerc(uint vPerc, uint bPerc) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
VALIDATORS_PERC = vPerc;
|
|
BROKER_PERC = bPerc;
|
|
}
|
|
|
|
function setProtocolFee(uint nominator, uint denominator) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
FEE_NOMINATOR = nominator;
|
|
FEE_DENOMINATOR = denominator;
|
|
}
|
|
|
|
function setValidationTimeFrame(uint blocks) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
TIME_FRAME_SIZE = blocks;
|
|
}
|
|
|
|
function getValidationTimeFrame() external view returns(uint) {
|
|
return TIME_FRAME_SIZE;
|
|
}
|
|
|
|
function getStakingTokenAddr() external view returns(address) {
|
|
return address(_tokenContract);
|
|
}
|
|
|
|
receive() external payable {
|
|
address sender = _msgSender();
|
|
Process storage process = _processes[sender][_depositingProducts[sender]];
|
|
require(process.state == State.AWAITING_TRANSFER, "You don't have a deposit awaiting process, please create it first");
|
|
require(process.cost == msg.value, "Deposit amount doesn't match with the requested deposit");
|
|
|
|
process.deposit.transfer(msg.value.sub(process.fee));
|
|
|
|
|
|
process.state = State.AWAITING_TERMINATION;
|
|
emit Deposit(sender, process.service, process.productId, msg.value);
|
|
}
|
|
|
|
function addService(address service, address[] memory vList) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
require(vList.length > 2, "Validators minimum quantity is 3");
|
|
_services[service] = Service({validators: vList, validationPerc: VALIDATORS_PERC, commissionPerc: BROKER_PERC, validatorVersion: 1});
|
|
}
|
|
|
|
function setServicePerc(address service, uint vPerc, uint bPerc) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
Service storage instance = _services[service];
|
|
instance.validationPerc = vPerc;
|
|
instance.commissionPerc = bPerc;
|
|
}
|
|
|
|
function setValidators(address[] memory vList) external onlyService {
|
|
_services[msg.sender].validators = vList;
|
|
}
|
|
|
|
function getValidatorVer(address service) external view returns(uint) {
|
|
return _services[service].validatorVersion;
|
|
}
|
|
|
|
function setValidatorVer(uint vVer) external onlyService {
|
|
_services[msg.sender].validatorVersion = vVer;
|
|
}
|
|
|
|
function getPenaltyPerc() external view returns(uint) {
|
|
return _penaltyPerc;
|
|
}
|
|
|
|
function setPenaltyPerc(uint newPenaltyPerc) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
_penaltyPerc = newPenaltyPerc;
|
|
}
|
|
|
|
function getLockingPeriod() external view returns(uint256) {
|
|
return _lockingPeriod;
|
|
}
|
|
|
|
function setLockingPeriod(uint256 newLockingPeriod) external onlyRole(DEFAULT_ADMIN_ROLE) {
|
|
_lockingPeriod = newLockingPeriod;
|
|
}
|
|
|
|
function inTimeFrame(address[] memory list, address search, uint256 startBlock, uint intSize) internal view returns(bool) {
|
|
for(uint x=0; x < list.length; x++) {
|
|
if(list[x] == search) {
|
|
return (
|
|
(x * intSize) <= (block.number - startBlock) &&
|
|
(block.number - startBlock) < (x * intSize + intSize)
|
|
);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function random() internal view returns(uint256) {
|
|
|
|
|
|
return uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp)));
|
|
}
|
|
|
|
function _randValidatorsList(address service, address exclude1, address exclude2) internal view returns(address[] memory) {
|
|
uint256 localTotalStaked = _totalStaked - _stakesByValidators[exclude1] - _stakesByValidators[exclude2];
|
|
uint256 index = 0;
|
|
uint resultLength = _services[service].validators.length;
|
|
if (exclude1 != address(0)) {
|
|
resultLength -= 1;
|
|
}
|
|
if (exclude2 != address(0)) {
|
|
resultLength -= 1;
|
|
}
|
|
address[] memory result = new address[](resultLength);
|
|
|
|
for(uint x=0; x < result.length; x++) {
|
|
index = random() % localTotalStaked;
|
|
for(uint y=0; y < _services[service].validators.length; y++) {
|
|
if (_services[service].validators[y] != exclude1 && _services[service].validators[y] != exclude2) {
|
|
if (_containsAddress(result, _services[service].validators[y]) == false) {
|
|
if (index <= _stakesByValidators[_services[service].validators[y]]) {
|
|
result[x] = _services[service].validators[y];
|
|
localTotalStaked -= _stakesByValidators[_services[service].validators[y]];
|
|
break;
|
|
}
|
|
index -= _stakesByValidators[_services[service].validators[y]];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function _createProcess(address token, address service, bytes32 productId, string calldata data) internal {
|
|
require(_services[service].validationPerc > 0, 'Requested service address not found');
|
|
require(_processes[msg.sender][productId].service == address(0), 'Process with specified productId already exist');
|
|
|
|
_processes[msg.sender][productId] = Process({
|
|
state: State.AWAITING_COST,
|
|
cost: 0,
|
|
costConf: 0,
|
|
token: token,
|
|
deposit: payable(address(0)),
|
|
depositConf: payable(address(0)),
|
|
fee: 0,
|
|
service: service,
|
|
productId: productId,
|
|
startBlock: block.number,
|
|
validatorsList: _randValidatorsList(service, address(0), address(0)),
|
|
firstValidator: address(0),
|
|
firstResult: false,
|
|
secondValidator: address(0),
|
|
secondResult: false
|
|
});
|
|
emit CostRequest(msg.sender, service, productId, _processes[msg.sender][productId].validatorsList, data);
|
|
|
|
if(_depositingProducts[msg.sender].length > 0) {
|
|
if(_processes[msg.sender][_depositingProducts[msg.sender]].state == State.AWAITING_TRANSFER) {
|
|
delete _processes[msg.sender][_depositingProducts[msg.sender]];
|
|
}
|
|
}
|
|
_depositingProducts[msg.sender] = productId;
|
|
}
|
|
|
|
function createProcess(address service, bytes32 productId, string calldata data) external {
|
|
_createProcess(address(0), service, productId, data);
|
|
}
|
|
|
|
function createProcess(address token, address service, bytes32 productId, string calldata data) external {
|
|
_createProcess(token, service, productId, data);
|
|
}
|
|
|
|
function _rewardLoop(address validator, uint256 reward, address token) internal returns(uint256) {
|
|
uint256 transfersSum = 0;
|
|
IERC20 tokenContract;
|
|
if(token != address(0)) {
|
|
tokenContract = IERC20(token);
|
|
}
|
|
|
|
for (uint256 i = 0; i < _validatorStakers[validator].length; i++) {
|
|
address staker = _validatorStakers[validator][i];
|
|
Stake storage stakeRecord = _stakes[staker][validator];
|
|
|
|
uint256 transferAmount = reward.mul(stakeRecord.amount.mul(100).div(_stakesByValidators[validator])).div(100);
|
|
|
|
if(token == address(0)) {
|
|
payable(staker).transfer(transferAmount);
|
|
} else {
|
|
tokenContract.transfer(staker, transferAmount);
|
|
}
|
|
transfersSum += transferAmount;
|
|
}
|
|
return transfersSum;
|
|
}
|
|
|
|
function _bonusLoop(address validator, uint256 bonus) internal returns(uint256) {
|
|
uint256 transfersSum = 0;
|
|
for (uint256 i = 0; i < _validatorStakers[validator].length; i++) {
|
|
address staker = _validatorStakers[validator][i];
|
|
|
|
uint256 transferAmount = bonus.mul(_stakes[staker][validator].amount.mul(100).div(_stakesByValidators[validator])).div(100);
|
|
|
|
_stakes[staker][validator].amount = _stakes[staker][validator].amount.add(transferAmount);
|
|
transfersSum += transferAmount;
|
|
}
|
|
return transfersSum;
|
|
}
|
|
|
|
function _rewardStakers(address firstValidator, address secondValidator, uint256 rewardAmount, address token) internal returns(uint256) {
|
|
uint256 firstReward = rewardAmount.mul(_stakesByValidators[firstValidator].mul(100).div(_stakesByValidators[firstValidator].add(_stakesByValidators[secondValidator]))).div(100);
|
|
uint256 secondReward = rewardAmount - firstReward;
|
|
uint256 firstRewardTsSum = _rewardLoop(firstValidator, firstReward, token);
|
|
uint256 secondRewardTsSum = _rewardLoop(secondValidator, secondReward, token);
|
|
|
|
return firstRewardTsSum + secondRewardTsSum;
|
|
}
|
|
|
|
function _rewardBonus(address firstValidator, address secondValidator, uint256 bonus) internal {
|
|
uint256 firstBonus = bonus.mul(_stakesByValidators[firstValidator].mul(100).div(_stakesByValidators[firstValidator].add(_stakesByValidators[secondValidator]))).div(100);
|
|
uint256 secondBonus = bonus - firstBonus;
|
|
uint256 firstBonusTsSum = _bonusLoop(firstValidator, firstBonus);
|
|
uint256 secondBonusTsSum = _bonusLoop(secondValidator, secondBonus);
|
|
|
|
_stakesByValidators[firstValidator] += firstBonusTsSum;
|
|
_stakesByValidators[secondValidator] += secondBonusTsSum;
|
|
}
|
|
|
|
function _makePayouts(address customer, bytes32 productId, bool needRefund, uint256 bonus) internal {
|
|
Process storage process = _processes[customer][productId];
|
|
uint256 reward_amount = process.fee.mul(_services[process.service].validationPerc).div(100);
|
|
uint256 transfers_sum = _rewardStakers(process.firstValidator, process.secondValidator, reward_amount, process.token);
|
|
if(bonus > 0) {
|
|
_rewardBonus(process.firstValidator, process.secondValidator, bonus);
|
|
}
|
|
|
|
if(needRefund == false) {
|
|
uint256 commission_amount = process.fee.mul(_services[process.service].commissionPerc).div(100);
|
|
if(process.token == address(0)) {
|
|
payable(process.service).transfer(commission_amount);
|
|
_beneficiary.transfer(process.fee - transfers_sum - commission_amount);
|
|
} else {
|
|
IERC20 tokenContract = IERC20(process.token);
|
|
tokenContract.transfer(process.service, commission_amount);
|
|
tokenContract.transfer(address(_beneficiary), process.fee - transfers_sum - commission_amount);
|
|
}
|
|
} else {
|
|
if(process.token == address(0)) {
|
|
payable(customer).transfer(process.fee - transfers_sum);
|
|
} else {
|
|
IERC20 tokenContract = IERC20(process.token);
|
|
tokenContract.transfer(customer, process.fee - transfers_sum);
|
|
}
|
|
}
|
|
}
|
|
|
|
function _penalizeLoop(address validator, uint256 penalty) internal returns(uint256) {
|
|
uint256 transfersSum = 0;
|
|
for (uint256 i = 0; i < _validatorStakers[validator].length; i++) {
|
|
address staker = _validatorStakers[validator][i];
|
|
uint256 transferAmount = penalty.mul(_stakes[staker][validator].amount.mul(100).div(_stakesByValidators[validator])).div(100);
|
|
_stakes[staker][validator].amount = _stakes[staker][validator].amount - transferAmount;
|
|
transfersSum += transferAmount;
|
|
}
|
|
|
|
_stakesByValidators[validator] -= transfersSum;
|
|
|
|
return transfersSum;
|
|
}
|
|
|
|
function setProcessCost(address customer, bytes32 productId, uint256 cost, address payable depositAddr) external {
|
|
require(_stakesByValidators[msg.sender] > 0, "Only validator with stakes can call this method");
|
|
Process storage process = _processes[customer][productId];
|
|
require(_containsAddress(_services[process.service].validators, msg.sender), "Your address is not whitelisted in the product service settings");
|
|
require(process.state == State.AWAITING_COST, "Cost is already set, check the state");
|
|
require(
|
|
inTimeFrame(
|
|
process.validatorsList,
|
|
msg.sender,
|
|
process.startBlock,
|
|
TIME_FRAME_SIZE
|
|
),
|
|
"Cannot accept validation, you are out of time"
|
|
);
|
|
|
|
if(process.firstValidator == address(0)) {
|
|
process.firstValidator = msg.sender;
|
|
process.cost = cost;
|
|
process.deposit = depositAddr;
|
|
process.startBlock = block.number;
|
|
process.validatorsList = _randValidatorsList(process.service, process.firstValidator, address(0));
|
|
emit CostRequest(customer, process.service, productId, process.validatorsList, '');
|
|
} else if(process.secondValidator == address(0)) {
|
|
process.secondValidator = msg.sender;
|
|
process.costConf = cost;
|
|
process.depositConf = depositAddr;
|
|
if(process.cost == process.costConf && process.deposit == process.depositConf) {
|
|
process.fee = cost.mul(FEE_NOMINATOR).div(FEE_DENOMINATOR);
|
|
process.state = State.AWAITING_TRANSFER;
|
|
emit CostResponse(customer, process.service, productId, cost);
|
|
} else {
|
|
process.startBlock = block.number;
|
|
process.validatorsList = _randValidatorsList(process.service, process.firstValidator, process.secondValidator);
|
|
emit CostRequest(customer, process.service, productId, process.validatorsList, '');
|
|
}
|
|
} else {
|
|
if(process.cost == cost && process.deposit == depositAddr) {
|
|
process.secondValidator = msg.sender;
|
|
process.costConf = cost;
|
|
process.depositConf = depositAddr;
|
|
} else {
|
|
process.firstValidator = msg.sender;
|
|
process.cost = cost;
|
|
process.deposit = depositAddr;
|
|
}
|
|
process.cost = cost;
|
|
process.fee = cost.mul(FEE_NOMINATOR).div(FEE_DENOMINATOR);
|
|
process.state = State.AWAITING_TRANSFER;
|
|
emit CostResponse(customer, process.service, productId, cost);
|
|
}
|
|
}
|
|
|
|
function declareAction(address customer, bytes32 productId, string calldata data) external onlyService {
|
|
emit Action(customer, msg.sender, productId, data);
|
|
}
|
|
|
|
function startTermination(address customer, bytes32 productId) external {
|
|
require((_services[msg.sender].validationPerc > 0) || (msg.sender == customer), "Only service or product customer can call this method");
|
|
Process storage process = _processes[customer][productId];
|
|
require(process.state == State.AWAITING_TERMINATION, "Cannot start termination, check the state");
|
|
|
|
process.state = State.AWAITING_VALIDATION;
|
|
process.startBlock = block.number;
|
|
process.validatorsList = _randValidatorsList(process.service, address(0), address(0));
|
|
process.firstValidator = address(0);
|
|
process.firstResult = false;
|
|
process.secondValidator = address(0);
|
|
process.secondResult = false;
|
|
emit Terminate(customer, msg.sender, productId, process.validatorsList);
|
|
}
|
|
|
|
function validateTermination(address customer, bytes32 productId, bool result) external {
|
|
require(_stakesByValidators[msg.sender] > 0, "Only validator with stakes can call this method");
|
|
Process storage process = _processes[customer][productId];
|
|
require(_containsAddress(_services[process.service].validators, msg.sender), "Your address is not whitelisted in the product service settings");
|
|
require(process.state == State.AWAITING_VALIDATION, "Cannot accept validation, check the state");
|
|
require(
|
|
inTimeFrame(
|
|
process.validatorsList,
|
|
msg.sender,
|
|
process.startBlock,
|
|
TIME_FRAME_SIZE
|
|
),
|
|
"Cannot accept validation, you are out of time"
|
|
);
|
|
|
|
|
|
if(process.firstValidator == address(0)) {
|
|
process.firstValidator = msg.sender;
|
|
process.firstResult = result;
|
|
process.startBlock = block.number;
|
|
process.validatorsList = _randValidatorsList(process.service, process.firstValidator, address(0));
|
|
emit Terminate(customer, process.service, productId, process.validatorsList);
|
|
|
|
} else if(process.secondValidator == address(0)) {
|
|
process.secondValidator = msg.sender;
|
|
process.secondResult = result;
|
|
|
|
if(process.firstResult == process.secondResult) {
|
|
_makePayouts(customer, productId, !process.firstResult, 0);
|
|
process.state = State.COMPLETED;
|
|
emit Complete(customer, process.service, productId, process.firstResult);
|
|
|
|
} else {
|
|
process.startBlock = block.number;
|
|
process.validatorsList = _randValidatorsList(process.service, process.firstValidator, process.secondValidator);
|
|
emit Terminate(customer, process.service, productId, process.validatorsList);
|
|
}
|
|
|
|
} else {
|
|
if(process.firstResult == result) {
|
|
uint256 penalty = _stakesByValidators[process.secondValidator].mul(_penaltyPerc).div(100);
|
|
uint256 appliedPenalty = _penalizeLoop(process.secondValidator, penalty);
|
|
process.secondValidator = msg.sender;
|
|
process.secondResult = result;
|
|
_makePayouts(customer, productId, !process.firstResult, appliedPenalty);
|
|
} else {
|
|
uint256 penalty = _stakesByValidators[process.firstValidator].mul(_penaltyPerc).div(100);
|
|
uint256 appliedPenalty = _penalizeLoop(process.firstValidator, penalty);
|
|
process.firstValidator = msg.sender;
|
|
process.firstResult = result;
|
|
_makePayouts(customer, productId, !process.firstResult, appliedPenalty);
|
|
}
|
|
process.state = State.COMPLETED;
|
|
emit Complete(customer, process.service, productId, process.firstResult);
|
|
}
|
|
}
|
|
|
|
function getProcess(address customer, bytes32 productId) external view returns(Process memory) {
|
|
return _processes[customer][productId];
|
|
}
|
|
|
|
function stake(address validator, uint256 amount) external {
|
|
require(validator != address(0), "Validator address cannot be 0");
|
|
require(amount > 0, "Cannot stake 0");
|
|
|
|
bool success = _tokenContract.transferFrom(msg.sender, address(this), amount);
|
|
if(success) {
|
|
_totalStaked = _totalStaked.add(amount);
|
|
bool alreadyStaked = false;
|
|
if (_stakes[msg.sender][validator].amount > 0) {
|
|
alreadyStaked = true;
|
|
}
|
|
_stakes[msg.sender][validator].amount = _stakes[msg.sender][validator].amount.add(amount);
|
|
_stakes[msg.sender][validator].unlockingBlock = block.number + _lockingPeriod;
|
|
_stakesByValidators[validator] = _stakesByValidators[validator].add(amount);
|
|
if (alreadyStaked == false && _containsAddress(_validatorStakers[validator], msg.sender) == false) {
|
|
_validatorStakers[validator].push(msg.sender);
|
|
}
|
|
emit Staked(msg.sender, validator, amount, _stakes[msg.sender][validator].unlockingBlock);
|
|
} else {
|
|
revert("Wasn't able to transfer your token");
|
|
}
|
|
}
|
|
|
|
function unStake(address validator, uint256 amount) external {
|
|
require(amount > 0, "Cannot unstake 0");
|
|
require(_stakes[msg.sender][validator].amount >= amount, "Your balance is lower than the amount of tokens you want to unstake");
|
|
|
|
require(_stakes[msg.sender][validator].unlockingBlock <= block.number, "The locking period didn't pass, you cannot unstake");
|
|
|
|
bool success = _tokenContract.transfer(msg.sender, amount);
|
|
if(success) {
|
|
_totalStaked -= amount;
|
|
_stakes[msg.sender][validator].amount = _stakes[msg.sender][validator].amount - amount;
|
|
_stakesByValidators[validator] = _stakesByValidators[validator] - amount;
|
|
emit UnStaked(msg.sender, validator, amount);
|
|
} else {
|
|
revert("Wasn't able to execute transfer of your tokens");
|
|
}
|
|
}
|
|
|
|
function stakeOf(address staker, address validator) external view returns (Stake memory) {
|
|
return _stakes[staker][validator];
|
|
}
|
|
|
|
function totalStakeOf(address validator) external view returns (uint256) {
|
|
return _stakesByValidators[validator];
|
|
}
|
|
|
|
function totalStaked() external view returns (uint256) {
|
|
return _totalStaked;
|
|
}
|
|
|
|
function deposit(uint256 amount) external {
|
|
Process storage process = _processes[msg.sender][_depositingProducts[msg.sender]];
|
|
require(process.token != address(0), "The current process doesn't wait for an ERC20 token deposit");
|
|
require(process.state == State.AWAITING_TRANSFER, "You don't have a deposit awaiting process, please create it first");
|
|
require(process.cost == amount, "Deposit amount doesn't match with the requested cost");
|
|
|
|
IERC20 tokenContract = IERC20(process.token);
|
|
|
|
tokenContract.safeTransferFrom(_msgSender(), address(this), amount);
|
|
|
|
tokenContract.safeTransfer(address(process.deposit), amount.sub(process.fee));
|
|
|
|
process.state = State.AWAITING_TERMINATION;
|
|
emit Deposit(_msgSender(), process.service, process.productId, amount);
|
|
|
|
}
|
|
|
|
} |