Polygon Sponsored slots available. Book your slot here!
Overview
Max Total Supply
6.08850857 renBTC
Holders
1,911 (0.00%)
Total Transfers
-
Market
Price
$92,634.00 @ 129,267.646760 POL (+0.73%)
Onchain Market Cap
$564,002.90
Circulating Supply Market Cap
$28,198,834.00
Other Info
Token Contract (WITH 8 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
MintGatewayProxy
Compiler Version
v0.5.17+commit.d19bba13
Optimization Enabled:
No with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/upgrades/contracts/upgradeability/InitializableAdminUpgradeabilityProxy.sol"; import "../Governance/Claimable.sol"; import "../libraries/String.sol"; import "./RenERC20.sol"; import "./interfaces/IGateway.sol"; import "../libraries/CanReclaimTokens.sol"; import "./MintGatewayV1.sol"; contract MintGatewayStateV2 { struct Burn { uint256 _blocknumber; bytes _to; uint256 _amount; // Optional string _chain; bytes _payload; } mapping(uint256 => Burn) internal burns; bytes32 public selectorHash; // Initialize to 0x1 because 0x0 is the default value returned by `recover` // when it encounters an error. address public _legacy_mintAuthority; } /// @notice Gateway handles verifying mint and burn requests. A mintAuthority /// approves new assets to be minted by providing a digital signature. An owner /// of an asset can request for it to be burnt. contract MintGatewayLogicV2 is Initializable, Claimable, CanReclaimTokens, IGateway, MintGatewayStateV1, MintGatewayStateV2 { using SafeMath for uint256; event LogMintAuthorityUpdated(address indexed _newMintAuthority); event LogMint( address indexed _to, uint256 _amount, uint256 indexed _n, // Log the nHash instead of sHash so that it can be queried without // knowing the sHash. bytes32 indexed _nHash ); event LogBurn( bytes _to, uint256 _amount, uint256 indexed _n, bytes indexed _indexedTo ); /// @notice Only allow the Darknode Payment contract. modifier onlyOwnerOrMintAuthority() { require( msg.sender == mintAuthority || msg.sender == owner(), "MintGateway: caller is not the owner or mint authority" ); _; } /// @param _token The RenERC20 this Gateway is responsible for. /// @param _feeRecipient The recipient of burning and minting fees. /// @param _mintAuthority The address of the key that can sign mint /// requests. /// @param _mintFee The amount subtracted each mint request and /// forwarded to the feeRecipient. In BIPS. /// @param _burnFee The amount subtracted each burn request and /// forwarded to the feeRecipient. In BIPS. function initialize( RenERC20LogicV1 _token, address _feeRecipient, address _mintAuthority, uint16 _mintFee, uint16 _burnFee, uint256 _minimumBurnAmount ) public initializer { Claimable.initialize(msg.sender); CanReclaimTokens.initialize(msg.sender); minimumBurnAmount = _minimumBurnAmount; token = _token; mintFee = _mintFee; burnFee = _burnFee; updateMintAuthority(_mintAuthority); updateFeeRecipient(_feeRecipient); } /// @param _selectorHash Hash of the token and chain selector. /// The hash should calculated from /// `SHA256(4 bytes of selector length, selector)` function updateSelectorHash(bytes32 _selectorHash) public onlyOwner { selectorHash = _selectorHash; } /// @notice Allow the owner to update the token symbol. function updateSymbol(string memory symbol) public onlyOwner { token.updateSymbol(symbol); } // Public functions //////////////////////////////////////////////////////// /// @notice Claims ownership of the token passed in to the constructor. /// `transferStoreOwnership` must have previously been called. /// Anyone can call this function. function claimTokenOwnership() public { token.claimOwnership(); } /// @notice Allow the owner to update the owner of the RenERC20 token. function transferTokenOwnership(MintGatewayLogicV2 _nextTokenOwner) public onlyOwner { token.transferOwnership(address(_nextTokenOwner)); _nextTokenOwner.claimTokenOwnership(); } /// @notice Allow the owner to update the mint authority. /// /// @param _nextMintAuthority The new mint authority address. function updateMintAuthority(address _nextMintAuthority) public onlyOwnerOrMintAuthority { // The mint authority should not be set to 0, which is the result // returned by ecrecover for an invalid signature. require( _nextMintAuthority != address(0), "MintGateway: mintAuthority cannot be set to address zero" ); mintAuthority = _nextMintAuthority; emit LogMintAuthorityUpdated(mintAuthority); } /// @notice Allow the owner to update the legacy mint authority. /// /// @param _nextMintAuthority The new legacy mint authority address. function _legacy_updateMintAuthority(address _nextMintAuthority) public onlyOwner { _legacy_mintAuthority = _nextMintAuthority; } /// @notice Allow the owner to update the minimum burn amount. /// /// @param _minimumBurnAmount The new min burn amount. function updateMinimumBurnAmount(uint256 _minimumBurnAmount) public onlyOwner { minimumBurnAmount = _minimumBurnAmount; } /// @notice Allow the owner to update the fee recipient. /// /// @param _nextFeeRecipient The address to start paying fees to. function updateFeeRecipient(address _nextFeeRecipient) public onlyOwner { // 'mint' and 'burn' will fail if the feeRecipient is 0x0 require( _nextFeeRecipient != address(0x0), "MintGateway: fee recipient cannot be 0x0" ); feeRecipient = _nextFeeRecipient; } /// @notice Allow the owner to update the 'mint' fee. /// /// @param _nextMintFee The new fee for minting and burning. function updateMintFee(uint16 _nextMintFee) public onlyOwner { mintFee = _nextMintFee; } /// @notice Allow the owner to update the burn fee. /// /// @param _nextBurnFee The new fee for minting and burning. function updateBurnFee(uint16 _nextBurnFee) public onlyOwner { burnFee = _nextBurnFee; } /// @notice mint verifies a mint approval signature from RenVM and creates /// tokens after taking a fee for the `_feeRecipient`. /// /// @param _pHash (payload hash) The hash of the payload associated with the /// mint. /// @param _amountUnderlying The amount of the token being minted, in its smallest /// value. (e.g. satoshis for BTC). /// @param _nHash (nonce hash) The hash of the nonce, amount and pHash. /// @param _sig The signature of the hash of the following values: /// (pHash, amount, msg.sender, nHash), signed by the mintAuthority. function mint( bytes32 _pHash, uint256 _amountUnderlying, bytes32 _nHash, bytes memory _sig ) public returns (uint256) { // Calculate the hash signed by RenVM. bytes32 sigHash = hashForSignature(_pHash, _amountUnderlying, msg.sender, _nHash); // Calculate the v0.2 signature hash for backwards-compatibility. bytes32 legacySigHash = _legacy_hashForSignature( _pHash, _amountUnderlying, msg.sender, _nHash ); // Check that neither signature has been redeemed. require( status[sigHash] == false && status[legacySigHash] == false, "MintGateway: nonce hash already spent" ); // If both signatures fail verification, throw an error. If any one of // them passed the verification, continue. if ( !verifySignature(sigHash, _sig) && !_legacy_verifySignature(legacySigHash, _sig) ) { // Return a detailed string containing the hash and recovered // signer. This is somewhat costly but is only run in the revert // branch. revert( String.add8( "MintGateway: invalid signature. pHash: ", String.fromBytes32(_pHash), ", amount: ", String.fromUint(_amountUnderlying), ", msg.sender: ", String.fromAddress(msg.sender), ", _nHash: ", String.fromBytes32(_nHash) ) ); } // Update the status for both signature hashes. This is to ensure that // legacy signatures can't be re-redeemed if `updateSelectorHash` is // ever called - thus changing the result of `sigHash` but not // `legacySigHash`. status[sigHash] = true; status[legacySigHash] = true; uint256 amountScaled = token.fromUnderlying(_amountUnderlying); // Mint `amount - fee` for the recipient and mint `fee` for the minter uint256 absoluteFeeScaled = amountScaled.mul(mintFee).div(BIPS_DENOMINATOR); uint256 receivedAmountScaled = amountScaled.sub( absoluteFeeScaled, "MintGateway: fee exceeds amount" ); // Mint amount minus the fee token.mint(msg.sender, receivedAmountScaled); // Mint the fee if (absoluteFeeScaled > 0) { token.mint(feeRecipient, absoluteFeeScaled); } // Emit a log with a unique identifier 'n'. uint256 receivedAmountUnderlying = token.toUnderlying(receivedAmountScaled); emit LogMint(msg.sender, receivedAmountUnderlying, nextN, _nHash); nextN += 1; return receivedAmountScaled; } /// @notice burn destroys tokens after taking a fee for the `_feeRecipient`, /// allowing the associated assets to be released on their native /// chain. /// /// @param _to The address to receive the un-bridged asset. The format of /// this address should be of the destination chain. /// For example, when burning to Bitcoin, _to should be a /// Bitcoin address. /// @param _amount The amount of the token being burnt, in its /// smallest value. (e.g. satoshis for BTC) function burn(bytes memory _to, uint256 _amount) public returns (uint256) { // The recipient must not be empty. Better validation is possible, // but would need to be customized for each destination ledger. require(_to.length != 0, "MintGateway: to address is empty"); // Calculate fee, subtract it from amount being burnt. uint256 fee = _amount.mul(burnFee).div(BIPS_DENOMINATOR); uint256 amountAfterFee = _amount.sub(fee, "MintGateway: fee exceeds amount"); // If the scaled token can represent more precision than the underlying // token, the difference is lost. This won't exceed 1 sat, so is // negligible compared to burning and transaction fees. uint256 amountAfterFeeUnderlying = token.toUnderlying(amountAfterFee); // Burn the whole amount, and then re-mint the fee. token.burn(msg.sender, _amount); if (fee > 0) { token.mint(feeRecipient, fee); } require( // Must be strictly greater, to that the release transaction is of // at least one unit. amountAfterFeeUnderlying > minimumBurnAmount, "MintGateway: amount is less than the minimum burn amount" ); emit LogBurn(_to, amountAfterFeeUnderlying, nextN, _to); // Store burn so that it can be looked up instead of relying on event // logs. bytes memory payload; MintGatewayStateV2.burns[nextN] = Burn({ _blocknumber: block.number, _to: _to, _amount: amountAfterFeeUnderlying, _chain: "", _payload: payload }); nextN += 1; return amountAfterFeeUnderlying; } function getBurn(uint256 _n) public view returns ( uint256 _blocknumber, bytes memory _to, uint256 _amount, // Optional string memory _chain, bytes memory _payload ) { Burn memory burnStruct = MintGatewayStateV2.burns[_n]; require(burnStruct._to.length > 0, "MintGateway: burn not found"); return ( burnStruct._blocknumber, burnStruct._to, burnStruct._amount, burnStruct._chain, burnStruct._payload ); } /// @notice verifySignature checks the the provided signature matches the /// provided parameters. function verifySignature(bytes32 _sigHash, bytes memory _sig) public view returns (bool) { return mintAuthority == ECDSA.recover(_sigHash, _sig); } /// @notice verifySignature checks the the provided signature matches the /// provided parameters. function _legacy_verifySignature(bytes32 _sigHash, bytes memory _sig) public view returns (bool) { require( _legacy_mintAuthority != address(0x0), "MintGateway: legacy mintAuthority not set" ); return _legacy_mintAuthority == ECDSA.recover(_sigHash, _sig); } /// @notice hashForSignature hashes the parameters so that they can be /// signed. function hashForSignature( bytes32 _pHash, uint256 _amount, address _to, bytes32 _nHash ) public view returns (bytes32) { return keccak256(abi.encode(_pHash, _amount, selectorHash, _to, _nHash)); } /// @notice _legacy_hashForSignature calculates the signature hash used by /// the 0.2 version of RenVM. It's kept here for backwards-compatibility. function _legacy_hashForSignature( bytes32 _pHash, uint256 _amount, address _to, bytes32 _nHash ) public view returns (bytes32) { return keccak256(abi.encode(_pHash, _amount, address(token), _to, _nHash)); } } /* solium-disable-next-line no-empty-blocks */ contract MintGatewayProxy is InitializableAdminUpgradeabilityProxy { }
pragma solidity ^0.5.17; import "./Gateway/MintGatewayV2.sol"; import "./Gateway/GatewayRegistry.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/StandaloneERC20.sol"; /// @notice Bindings imports all of the contracts for generating bindings. /* solium-disable-next-line no-empty-blocks */ contract Bindings { }
pragma solidity ^0.5.17; import "../Governance/Claimable.sol"; import "./RenERC20.sol"; import "../libraries/LinkedList.sol"; import "./interfaces/IGateway.sol"; import "../libraries/CanReclaimTokens.sol"; /// @notice GatewayRegistry is a mapping from assets to their associated /// RenERC20 and Gateway contracts. contract GatewayRegistry is Claimable, CanReclaimTokens { constructor() public { Claimable.initialize(msg.sender); CanReclaimTokens.initialize(msg.sender); } /// @dev The symbol is included twice because strings have to be hashed /// first in order to be used as a log index/topic. event LogGatewayRegistered( string _symbol, string indexed _indexedSymbol, address indexed _token, address indexed _gatewayContract ); event LogGatewayDeregistered( string _symbol, string indexed _indexedSymbol, address indexed _token, address indexed _gatewayContract ); event LogGatewayUpdated( address indexed _token, address indexed _currentGatewayContract, address indexed _newGatewayContract ); /// @notice The number of gateways registered. uint256 numGatewayContracts = 0; /// @notice A list of gateway contracts. LinkedList.List private gatewayContractList; /// @notice A list of ren token contracts. LinkedList.List private renTokenList; /// @notice A map of token addresses to canonical gateway contract addresses. mapping(address => address) private gatewayByToken; /// @notice A map of token symbols to token addresses. mapping(string => address) private tokenBySymbol; /// @notice Allow the owner to set the Gateway contract for a given /// RenERC20 token contract. /// /// @param _token The address of the RenERC20 token contract. /// @param _gatewayContract The address of the Gateway contract. function setGateway( string calldata _symbol, address _token, address _gatewayContract ) external onlyOwner { require( symbolIsValid(_symbol), "GatewayRegistry: symbol must be alphanumeric" ); // Check that token, Gateway and symbol haven't already been registered. require( !LinkedList.isInList(gatewayContractList, _gatewayContract), "GatewayRegistry: gateway already registered" ); require( gatewayByToken[_token] == address(0x0), "GatewayRegistry: token already registered" ); require( tokenBySymbol[_symbol] == address(0x0), "GatewayRegistry: symbol already registered" ); // Add to list of gateways. LinkedList.append(gatewayContractList, _gatewayContract); // Add to list of ren tokens. LinkedList.append(renTokenList, _token); tokenBySymbol[_symbol] = _token; gatewayByToken[_token] = _gatewayContract; numGatewayContracts += 1; emit LogGatewayRegistered(_symbol, _symbol, _token, _gatewayContract); } /// @notice Allow the owner to update the Gateway contract for a given /// RenERC20 contract. /// /// @param _token The address of the RenERC20 contract. /// @param _newGatewayContract The updated address of the Gateway contract. function updateGateway(address _token, address _newGatewayContract) external onlyOwner { // Check that token, Gateway are registered address currentGateway = gatewayByToken[_token]; require( currentGateway != address(0x0), "GatewayRegistry: token not registered" ); // Remove to list of Gateway contracts. LinkedList.remove(gatewayContractList, currentGateway); // Add to list of RenERC20 tokens. LinkedList.append(gatewayContractList, _newGatewayContract); gatewayByToken[_token] = _newGatewayContract; emit LogGatewayUpdated(_token, currentGateway, _newGatewayContract); } /// @notice Allows the owner to remove the Gateway contract for a given /// RenERC20 contract. /// /// @param _symbol The symbol of the token to deregister. function removeGateway(string calldata _symbol) external onlyOwner { // Look up token address address tokenAddress = tokenBySymbol[_symbol]; require( tokenAddress != address(0x0), "GatewayRegistry: symbol not registered" ); // Look up Gateway contract address address gatewayAddress = gatewayByToken[tokenAddress]; // Remove token and Gateway contract delete gatewayByToken[tokenAddress]; delete tokenBySymbol[_symbol]; LinkedList.remove(gatewayContractList, gatewayAddress); LinkedList.remove(renTokenList, tokenAddress); numGatewayContracts -= 1; emit LogGatewayDeregistered( _symbol, _symbol, tokenAddress, gatewayAddress ); } /// @dev To get all the registered Gateway contracts use count = 0. function getGateways(address _start, uint256 _count) external view returns (address[] memory) { return LinkedList.elements( gatewayContractList, _start, _count == 0 ? numGatewayContracts : _count ); } /// @dev To get all the registered RenERC20 tokens use count = 0. function getRenTokens(address _start, uint256 _count) external view returns (address[] memory) { return LinkedList.elements( renTokenList, _start, _count == 0 ? numGatewayContracts : _count ); } /// @notice Returns the Gateway contract for the given RenERC20 token /// address. /// /// @param _token The address of the RenERC20 token contract. function getGatewayByToken(address _token) external view returns (IGateway) { return IGateway(gatewayByToken[_token]); } /// @notice Returns the Gateway contract for the given RenERC20 token /// symbol. /// /// @param _tokenSymbol The symbol of the RenERC20 token contract. function getGatewayBySymbol(string calldata _tokenSymbol) external view returns (IGateway) { return IGateway(gatewayByToken[tokenBySymbol[_tokenSymbol]]); } /// @notice Returns the RenERC20 address for the given token symbol. /// /// @param _tokenSymbol The symbol of the RenERC20 token contract to /// lookup. function getTokenBySymbol(string calldata _tokenSymbol) external view returns (IERC20) { return IERC20(tokenBySymbol[_tokenSymbol]); } function symbolIsValid(string memory _tokenSymbol) public pure returns (bool) { for (uint256 i = 0; i < bytes(_tokenSymbol).length; i++) { uint8 char = uint8(bytes(_tokenSymbol)[i]); if ( !((char >= 65 && char <= 90) || (char >= 97 && char <= 122) || (char >= 48 && char <= 57)) ) { return false; } } return true; } }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "./ERC20Detailed.sol"; import "./ERC20Mintable.sol"; import "./ERC20Pausable.sol"; /** * @title Standard ERC20 token, with minting and pause functionality. * */ contract StandaloneERC20 is Initializable, ERC20Detailed, ERC20Mintable, ERC20Pausable { function initialize( string memory name, string memory symbol, uint8 decimals, uint256 initialSupply, address initialHolder, address[] memory minters, address[] memory pausers ) public initializer { ERC20Detailed.initialize(name, symbol, decimals); // Mint the initial supply _mint(initialHolder, initialSupply); // Initialize the minter and pauser roles, and renounce them ERC20Mintable.initialize(address(this)); _removeMinter(address(this)); ERC20Pausable.initialize(address(this)); _removePauser(address(this)); // Add the requested minters and pausers (this can be done after renouncing since // these are the internal calls) for (uint256 i = 0; i < minters.length; ++i) { _addMinter(minters[i]); } for (uint256 i = 0; i < pausers.length; ++i) { _addPauser(pausers[i]); } } function initialize( string memory name, string memory symbol, uint8 decimals, address[] memory minters, address[] memory pausers ) public initializer { ERC20Detailed.initialize(name, symbol, decimals); // Initialize the minter and pauser roles, and renounce them ERC20Mintable.initialize(address(this)); _removeMinter(address(this)); ERC20Pausable.initialize(address(this)); _removePauser(address(this)); // Add the requested minters and pausers (this can be done after renouncing since // these are the internal calls) for (uint256 i = 0; i < minters.length; ++i) { _addMinter(minters[i]); } for (uint256 i = 0; i < pausers.length; ++i) { _addPauser(pausers[i]); } } }
pragma solidity >=0.4.24 <0.7.0; /** * @title Initializable * * @dev Helper contract to support initializer functions. To use it, replace * the constructor with a function that has the `initializer` modifier. * WARNING: Unlike constructors, initializer functions must be manually * invoked. This applies both to deploying an Initializable contract, as well * as extending an Initializable contract via inheritance. * WARNING: When used with inheritance, manual care must be taken to not invoke * a parent initializer twice, or ensure that all initializers are idempotent, * because this is not dealt with automatically as with constructors. */ contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private initializing; /** * @dev Modifier to use in the initializer function of a contract. */ modifier initializer() { require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized"); bool isTopLevelCall = !initializing; if (isTopLevelCall) { initializing = true; initialized = true; } _; if (isTopLevelCall) { initializing = false; } } /// @dev Returns true if and only if the function is running in the constructor function isConstructor() private view returns (bool) { // extcodesize checks the size of the code stored in an address, and // address returns the current address. Since the code is still not // deployed when running a constructor, any checks on its code size will // yield zero, making it an effective way to detect if a contract is // under construction or not. address self = address(this); uint256 cs; assembly { cs := extcodesize(self) } return cs == 0; } // Reserved storage space to allow for layout changes in the future. uint256[50] private ______gap; }
pragma solidity ^0.5.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. * * _Available since v2.4.0._ */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. * * _Available since v2.4.0._ */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } }
pragma solidity ^0.5.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * NOTE: This call _does not revert_ if the signature is invalid, or * if the signer is otherwise unable to be retrieved. In those scenarios, * the zero address is returned. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // Check the signature length if (signature.length != 65) { revert("ECDSA: signature length is invalid"); } // Divide the signature in r, s and v variables bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. // solhint-disable-next-line no-inline-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { revert("ECDSA: signature.s is in the wrong range"); } if (v != 27 && v != 28) { revert("ECDSA: signature.v is in the wrong range"); } // If the signature is valid (and not malleable), return the signer address return ecrecover(hash, v, r, s); } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * replicates the behavior of the * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`] * JSON-RPC method. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } }
pragma solidity ^0.5.0; import './BaseAdminUpgradeabilityProxy.sol'; import './InitializableUpgradeabilityProxy.sol'; /** * @title InitializableAdminUpgradeabilityProxy * @dev Extends from BaseAdminUpgradeabilityProxy with an initializer for * initializing the implementation, admin, and init data. */ contract InitializableAdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, InitializableUpgradeabilityProxy { /** * Contract initializer. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize(address _logic, address _admin, bytes memory _data) public payable { require(_implementation() == address(0)); InitializableUpgradeabilityProxy.initialize(_logic, _data); assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; import "@openzeppelin/upgrades/contracts/Initializable.sol"; /** * @title Claimable * @dev Extension for the Ownable contract, where the ownership needs to be claimed. * This allows the new owner to accept the transfer. */ contract Claimable is Initializable, Ownable { address public pendingOwner; function initialize(address _nextOwner) public initializer { Ownable.initialize(_nextOwner); } modifier onlyPendingOwner() { require( _msgSender() == pendingOwner, "Claimable: caller is not the pending owner" ); _; } function transferOwnership(address newOwner) public onlyOwner { require( newOwner != owner() && newOwner != pendingOwner, "Claimable: invalid new owner" ); pendingOwner = newOwner; } // Allow skipping two-step transfer if the recipient is known to be a valid // owner, for use in smart-contracts only. function _directTransferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } function claimOwnership() public onlyPendingOwner { _transferOwnership(pendingOwner); delete pendingOwner; } }
pragma solidity ^0.5.17; library String { /// @notice Convert a uint value to its decimal string representation // solium-disable-next-line security/no-assign-params function fromUint(uint256 _i) internal pure returns (string memory) { if (_i == 0) { return "0"; } uint256 j = _i; uint256 len; while (j != 0) { len++; j /= 10; } bytes memory bstr = new bytes(len); uint256 k = len - 1; while (_i != 0) { bstr[k--] = bytes1(uint8(48 + (_i % 10))); _i /= 10; } return string(bstr); } /// @notice Convert a bytes32 value to its hex string representation. function fromBytes32(bytes32 _value) internal pure returns (string memory) { bytes memory alphabet = "0123456789abcdef"; bytes memory str = new bytes(32 * 2 + 2); str[0] = "0"; str[1] = "x"; for (uint256 i = 0; i < 32; i++) { str[2 + i * 2] = alphabet[uint256(uint8(_value[i] >> 4))]; str[3 + i * 2] = alphabet[uint256(uint8(_value[i] & 0x0f))]; } return string(str); } /// @notice Convert an address to its hex string representation. function fromAddress(address _addr) internal pure returns (string memory) { bytes32 value = bytes32(uint256(_addr)); bytes memory alphabet = "0123456789abcdef"; bytes memory str = new bytes(20 * 2 + 2); str[0] = "0"; str[1] = "x"; for (uint256 i = 0; i < 20; i++) { str[2 + i * 2] = alphabet[uint256(uint8(value[i + 12] >> 4))]; str[3 + i * 2] = alphabet[uint256(uint8(value[i + 12] & 0x0f))]; } return string(str); } /// @notice Append eight strings. function add8( string memory a, string memory b, string memory c, string memory d, string memory e, string memory f, string memory g, string memory h ) internal pure returns (string memory) { return string(abi.encodePacked(a, b, c, d, e, f, g, h)); } }
pragma solidity ^0.5.16; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; import "@openzeppelin/upgrades/contracts/upgradeability/InitializableAdminUpgradeabilityProxy.sol"; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol"; import "../Governance/Claimable.sol"; import "../libraries/CanReclaimTokens.sol"; import "./ERC20WithRate.sol"; import "./ERC20WithPermit.sol"; /// @notice RenERC20 represents a digital asset that has been bridged on to /// the Ethereum ledger. It exposes mint and burn functions that can only be /// called by it's associated Gateway contract. contract RenERC20LogicV1 is Initializable, ERC20, ERC20Detailed, ERC20WithRate, ERC20WithPermit, Claimable, CanReclaimTokens { /* solium-disable-next-line no-empty-blocks */ function initialize( uint256 _chainId, address _nextOwner, uint256 _initialRate, string memory _version, string memory _name, string memory _symbol, uint8 _decimals ) public initializer { ERC20Detailed.initialize(_name, _symbol, _decimals); ERC20WithRate.initialize(_nextOwner, _initialRate); ERC20WithPermit.initialize( _chainId, _version, _name, _symbol, _decimals ); Claimable.initialize(_nextOwner); CanReclaimTokens.initialize(_nextOwner); } function updateSymbol(string memory symbol) public onlyOwner { ERC20Detailed._symbol = symbol; } /// @notice mint can only be called by the tokens' associated Gateway /// contract. See Gateway's mint function instead. function mint(address _to, uint256 _amount) public onlyOwner { _mint(_to, _amount); } /// @notice burn can only be called by the tokens' associated Gateway /// contract. See Gateway's burn functions instead. function burn(address _from, uint256 _amount) public onlyOwner { _burn(_from, _amount); } function transfer(address recipient, uint256 amount) public returns (bool) { // Disallow sending tokens to the ERC20 contract address - a common // mistake caused by the Ethereum transaction's `to` needing to be // the token's address. require( recipient != address(this), "RenERC20: can't transfer to token address" ); return super.transfer(recipient, amount); } function transferFrom( address sender, address recipient, uint256 amount ) public returns (bool) { // Disallow sending tokens to the ERC20 contract address (see comment // in `transfer`). require( recipient != address(this), "RenERC20: can't transfer to token address" ); return super.transferFrom(sender, recipient, amount); } } /* solium-disable-next-line no-empty-blocks */ contract RenERC20Proxy is InitializableAdminUpgradeabilityProxy { }
pragma solidity ^0.5.17; interface IMintGateway { function mint( bytes32 _pHash, uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external returns (uint256); function mintFee() external view returns (uint256); } interface IBurnGateway { function burn(bytes calldata _to, uint256 _amountScaled) external returns (uint256); function burnFee() external view returns (uint256); } // TODO: In ^0.6.0, should be `interface IGateway is IMintGateway,IBurnGateway {}` interface IGateway { // is IMintGateway function mint( bytes32 _pHash, uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external returns (uint256); function mintFee() external view returns (uint256); // is IBurnGateway function burn(bytes calldata _to, uint256 _amountScaled) external returns (uint256); function burnFee() external view returns (uint256); }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/SafeERC20.sol"; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../Governance/Claimable.sol"; contract CanReclaimTokens is Claimable { using SafeERC20 for ERC20; mapping(address => bool) private recoverableTokensBlacklist; function initialize(address _nextOwner) public initializer { Claimable.initialize(_nextOwner); } function blacklistRecoverableToken(address _token) public onlyOwner { recoverableTokensBlacklist[_token] = true; } /// @notice Allow the owner of the contract to recover funds accidentally /// sent to the contract. To withdraw ETH, the token should be set to `0x0`. function recoverTokens(address _token) external onlyOwner { require( !recoverableTokensBlacklist[_token], "CanReclaimTokens: token is not recoverable" ); if (_token == address(0x0)) { msg.sender.transfer(address(this).balance); } else { ERC20(_token).safeTransfer( msg.sender, ERC20(_token).balanceOf(address(this)) ); } } }
pragma solidity 0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/upgrades/contracts/upgradeability/InitializableAdminUpgradeabilityProxy.sol"; import "../Governance/Claimable.sol"; import "../libraries/String.sol"; import "./RenERC20.sol"; import "./interfaces/IGateway.sol"; import "../libraries/CanReclaimTokens.sol"; contract MintGatewayStateV1 { uint256 constant BIPS_DENOMINATOR = 10000; uint256 public minimumBurnAmount; /// @notice Each Gateway is tied to a specific RenERC20 token. RenERC20LogicV1 public token; /// @notice The mintAuthority is an address that can sign mint requests. address public mintAuthority; /// @dev feeRecipient is assumed to be an address (or a contract) that can /// accept erc20 payments it cannot be 0x0. /// @notice When tokens are mint or burnt, a portion of the tokens are /// forwarded to a fee recipient. address public feeRecipient; /// @notice The mint fee in bips. uint16 public mintFee; /// @notice The burn fee in bips. uint16 public burnFee; /// @notice Each signature can only be seen once. mapping(bytes32 => bool) public status; // LogMint and LogBurn contain a unique `n` that identifies // the mint or burn event. uint256 public nextN = 0; } /// @notice Gateway handles verifying mint and burn requests. A mintAuthority /// approves new assets to be minted by providing a digital signature. An owner /// of an asset can request for it to be burnt. contract MintGatewayLogicV1 is Initializable, Claimable, CanReclaimTokens, IGateway, MintGatewayStateV1 { using SafeMath for uint256; event LogMintAuthorityUpdated(address indexed _newMintAuthority); event LogMint( address indexed _to, uint256 _amount, uint256 indexed _n, bytes32 indexed _signedMessageHash ); event LogBurn( bytes _to, uint256 _amount, uint256 indexed _n, bytes indexed _indexedTo ); /// @notice Only allow the Darknode Payment contract. modifier onlyOwnerOrMintAuthority() { require( msg.sender == mintAuthority || msg.sender == owner(), "Gateway: caller is not the owner or mint authority" ); _; } /// @param _token The RenERC20 this Gateway is responsible for. /// @param _feeRecipient The recipient of burning and minting fees. /// @param _mintAuthority The address of the key that can sign mint /// requests. /// @param _mintFee The amount subtracted each mint request and /// forwarded to the feeRecipient. In BIPS. /// @param _burnFee The amount subtracted each burn request and /// forwarded to the feeRecipient. In BIPS. function initialize( RenERC20LogicV1 _token, address _feeRecipient, address _mintAuthority, uint16 _mintFee, uint16 _burnFee, uint256 _minimumBurnAmount ) public initializer { Claimable.initialize(msg.sender); CanReclaimTokens.initialize(msg.sender); minimumBurnAmount = _minimumBurnAmount; token = _token; mintFee = _mintFee; burnFee = _burnFee; updateMintAuthority(_mintAuthority); updateFeeRecipient(_feeRecipient); } // Public functions //////////////////////////////////////////////////////// /// @notice Claims ownership of the token passed in to the constructor. /// `transferStoreOwnership` must have previously been called. /// Anyone can call this function. function claimTokenOwnership() public { token.claimOwnership(); } /// @notice Allow the owner to update the owner of the RenERC20 token. function transferTokenOwnership(MintGatewayLogicV1 _nextTokenOwner) public onlyOwner { token.transferOwnership(address(_nextTokenOwner)); _nextTokenOwner.claimTokenOwnership(); } /// @notice Allow the owner to update the mint authority. /// /// @param _nextMintAuthority The new mint authority address. function updateMintAuthority(address _nextMintAuthority) public onlyOwnerOrMintAuthority { // The mint authority should not be set to 0, which is the result // returned by ecrecover for an invalid signature. require( _nextMintAuthority != address(0), "Gateway: mintAuthority cannot be set to address zero" ); mintAuthority = _nextMintAuthority; emit LogMintAuthorityUpdated(mintAuthority); } /// @notice Allow the owner to update the minimum burn amount. /// /// @param _minimumBurnAmount The new min burn amount. function updateMinimumBurnAmount(uint256 _minimumBurnAmount) public onlyOwner { minimumBurnAmount = _minimumBurnAmount; } /// @notice Allow the owner to update the fee recipient. /// /// @param _nextFeeRecipient The address to start paying fees to. function updateFeeRecipient(address _nextFeeRecipient) public onlyOwner { // 'mint' and 'burn' will fail if the feeRecipient is 0x0 require( _nextFeeRecipient != address(0x0), "Gateway: fee recipient cannot be 0x0" ); feeRecipient = _nextFeeRecipient; } /// @notice Allow the owner to update the 'mint' fee. /// /// @param _nextMintFee The new fee for minting and burning. function updateMintFee(uint16 _nextMintFee) public onlyOwner { mintFee = _nextMintFee; } /// @notice Allow the owner to update the burn fee. /// /// @param _nextBurnFee The new fee for minting and burning. function updateBurnFee(uint16 _nextBurnFee) public onlyOwner { burnFee = _nextBurnFee; } /// @notice mint verifies a mint approval signature from RenVM and creates /// tokens after taking a fee for the `_feeRecipient`. /// /// @param _pHash (payload hash) The hash of the payload associated with the /// mint. /// @param _amountUnderlying The amount of the token being minted, in its smallest /// value. (e.g. satoshis for BTC). /// @param _nHash (nonce hash) The hash of the nonce, amount and pHash. /// @param _sig The signature of the hash of the following values: /// (pHash, amount, msg.sender, nHash), signed by the mintAuthority. function mint( bytes32 _pHash, uint256 _amountUnderlying, bytes32 _nHash, bytes memory _sig ) public returns (uint256) { // Calculate the hash signed by RenVM. bytes32 sigHash = hashForSignature(_pHash, _amountUnderlying, msg.sender, _nHash); // // Check that the signature hasn't been redeemed. require(status[sigHash] == false, "Gateway: nonce hash already spent"); // If the signature fails verification, throw an error. If any one of // them passed the verification, continue. if (!verifySignature(sigHash, _sig)) { // Return a detailed string containing the hash and recovered // signer. This is somewhat costly but is only run in the revert // branch. revert( String.add8( "Gateway: invalid signature. pHash: ", String.fromBytes32(_pHash), ", amount: ", String.fromUint(_amountUnderlying), ", msg.sender: ", String.fromAddress(msg.sender), ", _nHash: ", String.fromBytes32(_nHash) ) ); } // Update the status for the signature hash so that it can't be used // again. status[sigHash] = true; uint256 amountScaled = token.fromUnderlying(_amountUnderlying); // Mint `amount - fee` for the recipient and mint `fee` for the minter uint256 absoluteFeeScaled = amountScaled.mul(mintFee).div(BIPS_DENOMINATOR); uint256 receivedAmountScaled = amountScaled.sub(absoluteFeeScaled, "Gateway: fee exceeds amount"); // Mint amount minus the fee token.mint(msg.sender, receivedAmountScaled); // Mint the fee token.mint(feeRecipient, absoluteFeeScaled); // Emit a log with a unique identifier 'n'. uint256 receivedAmountUnderlying = token.toUnderlying(receivedAmountScaled); emit LogMint(msg.sender, receivedAmountUnderlying, nextN, sigHash); nextN += 1; return receivedAmountScaled; } /// @notice burn destroys tokens after taking a fee for the `_feeRecipient`, /// allowing the associated assets to be released on their native /// chain. /// /// @param _to The address to receive the un-bridged asset. The format of /// this address should be of the destination chain. /// For example, when burning to Bitcoin, _to should be a /// Bitcoin address. /// @param _amount The amount of the token being burnt, in its /// smallest value. (e.g. satoshis for BTC) function burn(bytes memory _to, uint256 _amount) public returns (uint256) { // The recipient must not be empty. Better validation is possible, // but would need to be customized for each destination ledger. require(_to.length != 0, "Gateway: to address is empty"); // Calculate fee, subtract it from amount being burnt. uint256 fee = _amount.mul(burnFee).div(BIPS_DENOMINATOR); uint256 amountAfterFee = _amount.sub(fee, "Gateway: fee exceeds amount"); // If the scaled token can represent more precision than the underlying // token, the difference is lost. This won't exceed 1 sat, so is // negligible compared to burning and transaction fees. uint256 amountAfterFeeUnderlying = token.toUnderlying(amountAfterFee); // Burn the whole amount, and then re-mint the fee. token.burn(msg.sender, _amount); token.mint(feeRecipient, fee); require( // Must be strictly greater, to that the release transaction is of // at least one unit. amountAfterFeeUnderlying > minimumBurnAmount, "Gateway: amount is less than the minimum burn amount" ); emit LogBurn(_to, amountAfterFeeUnderlying, nextN, _to); nextN += 1; return amountAfterFeeUnderlying; } /// @notice verifySignature checks the the provided signature matches the /// provided parameters. function verifySignature(bytes32 _sigHash, bytes memory _sig) public view returns (bool) { return mintAuthority == ECDSA.recover(_sigHash, _sig); } /// @notice hashForSignature hashes the parameters so that they can be /// signed. function hashForSignature( bytes32 _pHash, uint256 _amount, address _to, bytes32 _nHash ) public view returns (bytes32) { return keccak256(abi.encode(_pHash, _amount, address(token), _to, _nHash)); } } contract BTCGateway is InitializableAdminUpgradeabilityProxy {} contract ZECGateway is InitializableAdminUpgradeabilityProxy {} contract BCHGateway is InitializableAdminUpgradeabilityProxy {}
pragma solidity ^0.5.0; import './UpgradeabilityProxy.sol'; /** * @title BaseAdminUpgradeabilityProxy * @dev This contract combines an upgradeability proxy with an authorization * mechanism for administrative tasks. * All external functions in this contract must be guarded by the * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity * feature proposal that would enable this to be done automatically. */ contract BaseAdminUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Emitted when the administration has been transferred. * @param previousAdmin Address of the previous admin. * @param newAdmin Address of the new admin. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Modifier to check whether the `msg.sender` is the admin. * If it is, it will run the function. Otherwise, it will delegate the call * to the implementation. */ modifier ifAdmin() { if (msg.sender == _admin()) { _; } else { _fallback(); } } /** * @return The address of the proxy admin. */ function admin() external ifAdmin returns (address) { return _admin(); } /** * @return The address of the implementation. */ function implementation() external ifAdmin returns (address) { return _implementation(); } /** * @dev Changes the admin of the proxy. * Only the current admin can call this function. * @param newAdmin Address to transfer proxy administration to. */ function changeAdmin(address newAdmin) external ifAdmin { require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address"); emit AdminChanged(_admin(), newAdmin); _setAdmin(newAdmin); } /** * @dev Upgrade the backing implementation of the proxy. * Only the admin can call this function. * @param newImplementation Address of the new implementation. */ function upgradeTo(address newImplementation) external ifAdmin { _upgradeTo(newImplementation); } /** * @dev Upgrade the backing implementation of the proxy and call a function * on the new implementation. * This is useful to initialize the proxied contract. * @param newImplementation Address of the new implementation. * @param data Data to send as msg.data in the low level call. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. */ function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin { _upgradeTo(newImplementation); (bool success,) = newImplementation.delegatecall(data); require(success); } /** * @return The admin slot. */ function _admin() internal view returns (address adm) { bytes32 slot = ADMIN_SLOT; assembly { adm := sload(slot) } } /** * @dev Sets the address of the proxy admin. * @param newAdmin Address of the new proxy admin. */ function _setAdmin(address newAdmin) internal { bytes32 slot = ADMIN_SLOT; assembly { sstore(slot, newAdmin) } } /** * @dev Only fall back when the sender is not the admin. */ function _willFallback() internal { require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin"); super._willFallback(); } }
pragma solidity ^0.5.0; import './BaseUpgradeabilityProxy.sol'; /** * @title InitializableUpgradeabilityProxy * @dev Extends BaseUpgradeabilityProxy with an initializer for initializing * implementation and init data. */ contract InitializableUpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract initializer. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ function initialize(address _logic, bytes memory _data) public payable { require(_implementation() == address(0)); assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)); _setImplementation(_logic); if(_data.length > 0) { (bool success,) = _logic.delegatecall(_data); require(success); } } }
pragma solidity ^0.5.0; import './BaseUpgradeabilityProxy.sol'; /** * @title UpgradeabilityProxy * @dev Extends BaseUpgradeabilityProxy with a constructor for initializing * implementation and init data. */ contract UpgradeabilityProxy is BaseUpgradeabilityProxy { /** * @dev Contract constructor. * @param _logic Address of the initial implementation. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, bytes memory _data) public payable { assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1)); _setImplementation(_logic); if(_data.length > 0) { (bool success,) = _logic.delegatecall(_data); require(success); } } }
pragma solidity ^0.5.0; import './Proxy.sol'; import '../utils/Address.sol'; /** * @title BaseUpgradeabilityProxy * @dev This contract implements a proxy that allows to change the * implementation address to which it will delegate. * Such a change is called an implementation upgrade. */ contract BaseUpgradeabilityProxy is Proxy { /** * @dev Emitted when the implementation is upgraded. * @param implementation Address of the new implementation. */ event Upgraded(address indexed implementation); /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Returns the current implementation. * @return Address of the current implementation */ function _implementation() internal view returns (address impl) { bytes32 slot = IMPLEMENTATION_SLOT; assembly { impl := sload(slot) } } /** * @dev Upgrades the proxy to a new implementation. * @param newImplementation Address of the new implementation. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Sets the implementation address of the proxy. * @param newImplementation Address of the new implementation. */ function _setImplementation(address newImplementation) internal { require(OpenZeppelinUpgradesAddress.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address"); bytes32 slot = IMPLEMENTATION_SLOT; assembly { sstore(slot, newImplementation) } } }
pragma solidity ^0.5.0; /** * @title Proxy * @dev Implements delegation of calls to other contracts, with proper * forwarding of return values and bubbling of failures. * It defines a fallback function that delegates all calls to the address * returned by the abstract _implementation() internal function. */ contract Proxy { /** * @dev Fallback function. * Implemented entirely in `_fallback`. */ function () payable external { _fallback(); } /** * @return The Address of the implementation. */ function _implementation() internal view returns (address); /** * @dev Delegates execution to an implementation contract. * This is a low level function that doesn't return to its internal call site. * It will return to the external caller whatever the implementation returns. * @param implementation Address to delegate. */ function _delegate(address implementation) internal { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0, 0, calldatasize) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas, implementation, 0, calldatasize, 0, 0) // Copy the returned data. returndatacopy(0, 0, returndatasize) switch result // delegatecall returns 0 on error. case 0 { revert(0, returndatasize) } default { return(0, returndatasize) } } } /** * @dev Function that is run as the first thing in the fallback function. * Can be redefined in derived contracts to add functionality. * Redefinitions must call super._willFallback(). */ function _willFallback() internal { } /** * @dev fallback implementation. * Extracted to enable manual triggering. */ function _fallback() internal { _willFallback(); _delegate(_implementation()); } }
pragma solidity ^0.5.0; /** * Utility library of inline functions on addresses * * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/utils/Address.sol * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the * build/artifacts folder) as well as the vanilla Address implementation from an openzeppelin version. */ library OpenZeppelinUpgradesAddress { /** * Returns whether the target address is a contract * @dev This function will return false if invoked during the constructor of a contract, * as the code is not actually created until after the constructor finishes. * @param account address of the account to check * @return whether the target address is a contract */ function isContract(address account) internal view returns (bool) { uint256 size; // XXX Currently there is no better way to check if there is a contract in an address // than to check the size of the code at that address. // See https://ethereum.stackexchange.com/a/14016/36603 // for more details about how this works. // TODO Check this again before the Serenity release, because all addresses will be // contracts then. // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../GSN/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be aplied to your functions to restrict their use to * the owner. */ contract Ownable is Initializable, Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ function initialize(address sender) public initializer { _owner = sender; emit OwnershipTransferred(address(0), _owner); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner(), "Ownable: caller is not the owner"); _; } /** * @dev Returns true if the caller is the current owner. */ function isOwner() public view returns (bool) { return _msgSender() == _owner; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * > Note: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ contract Context is Initializable { // Empty internal constructor, to prevent people from mistakenly deploying // an instance of this contract, which should be used via inheritance. constructor () internal { } // solhint-disable-previous-line no-empty-blocks function _msgSender() internal view returns (address payable) { return msg.sender; } function _msgData() internal view returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../../GSN/Context.sol"; import "./IERC20.sol"; import "../../math/SafeMath.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20Mintable}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Initializable, Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for `sender`'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens. * * This is internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal { 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); } /** * @dev Destroys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance")); } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "./IERC20.sol"; /** * @dev Optional functions from the ERC20 standard. */ contract ERC20Detailed is Initializable, IERC20 { string private _name; string internal _symbol; uint8 private _decimals; /** * @dev Sets the values for `name`, `symbol`, and `decimals`. All three of * these values are immutable: they can only be set once during * construction. */ function initialize(string memory name, string memory symbol, uint8 decimals) public initializer { _name = name; _symbol = symbol; _decimals = decimals; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } uint256[50] private ______gap; }
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "../Governance/Claimable.sol"; /// @notice ERC20WithRate allows for a more dynamic fee model by storing a rate /// that tracks the number of the underlying asset's unit represented by a /// single ERC20 token. contract ERC20WithRate is Initializable, Ownable, ERC20 { using SafeMath for uint256; uint256 public constant _rateScale = 1e18; uint256 internal _rate; event LogRateChanged(uint256 indexed _rate); /* solium-disable-next-line no-empty-blocks */ function initialize(address _nextOwner, uint256 _initialRate) public initializer { Ownable.initialize(_nextOwner); _setRate(_initialRate); } function setExchangeRate(uint256 _nextRate) public onlyOwner { _setRate(_nextRate); } function exchangeRateCurrent() public view returns (uint256) { require(_rate != 0, "ERC20WithRate: rate has not been initialized"); return _rate; } function _setRate(uint256 _nextRate) internal { require(_nextRate > 0, "ERC20WithRate: rate must be greater than zero"); _rate = _nextRate; } function balanceOfUnderlying(address _account) public view returns (uint256) { return toUnderlying(balanceOf(_account)); } function toUnderlying(uint256 _amount) public view returns (uint256) { return _amount.mul(_rate).div(_rateScale); } function fromUnderlying(uint256 _amountUnderlying) public view returns (uint256) { return _amountUnderlying.mul(_rateScale).div(_rate); } }
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/ERC20Detailed.sol"; /// @notice Taken from the DAI token. contract ERC20WithPermit is Initializable, ERC20, ERC20Detailed { using SafeMath for uint256; mapping(address => uint256) public nonces; // If the token is redeployed, the version is increased to prevent a permit // signature being used on both token instances. string public version; // --- EIP712 niceties --- bytes32 public DOMAIN_SEPARATOR; // PERMIT_TYPEHASH is the value returned from // keccak256("Permit(address holder,address spender,uint256 nonce,uint256 expiry,bool allowed)") bytes32 public constant PERMIT_TYPEHASH = 0xea2aa0a1be11a07ed86d755c93467f4f82362b452371d1ba94d1715123511acb; function initialize( uint256 _chainId, string memory _version, string memory _name, string memory _symbol, uint8 _decimals ) public initializer { ERC20Detailed.initialize(_name, _symbol, _decimals); version = _version; DOMAIN_SEPARATOR = keccak256( abi.encode( keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ), keccak256(bytes(name())), keccak256(bytes(version)), _chainId, address(this) ) ); } // --- Approve by signature --- function permit( address holder, address spender, uint256 nonce, uint256 expiry, bool allowed, uint8 v, bytes32 r, bytes32 s ) external { bytes32 digest = keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR, keccak256( abi.encode( PERMIT_TYPEHASH, holder, spender, nonce, expiry, allowed ) ) ) ); require(holder != address(0), "ERC20WithRate: address must not be 0x0"); require( holder == ecrecover(digest, v, r, s), "ERC20WithRate: invalid signature" ); require( expiry == 0 || now <= expiry, "ERC20WithRate: permit has expired" ); require(nonce == nonces[holder]++, "ERC20WithRate: invalid nonce"); uint256 amount = allowed ? uint256(-1) : 0; _approve(holder, spender, amount); } }
pragma solidity ^0.5.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. Does not include * the optional functions; to access them see {ERC20Detailed}. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
pragma solidity ^0.5.0; import "./IERC20.sol"; import "../../math/SafeMath.sol"; import "../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ 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 { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length 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)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. // A Solidity high level call has three parts: // 1. The target address is checked to verify it contains contract code // 2. The call itself is made, and success asserted // 3. The return value is decoded, which in turn checks the size of the returned data. // solhint-disable-next-line max-line-length require(address(token).isContract(), "SafeERC20: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = address(token).call(data); require(success, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
pragma solidity ^0.5.5; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // According to EIP-1052, 0x0 is the value returned for not-yet created accounts // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned // for accounts without code, i.e. `keccak256('')` bytes32 codehash; bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470; // solhint-disable-next-line no-inline-assembly assembly { codehash := extcodehash(account) } return (codehash != accountHash && codehash != 0x0); } /** * @dev Converts an `address` into `address payable`. Note that this is * simply a type cast: the actual underlying value is not changed. * * _Available since v2.4.0._ */ function toPayable(address account) internal pure returns (address payable) { return address(uint160(account)); } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. * * _Available since v2.4.0._ */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-call-value (bool success, ) = recipient.call.value(amount)(""); require(success, "Address: unable to send value, recipient may have reverted"); } }
pragma solidity ^0.5.17; /** * @notice LinkedList is a library for a circular double linked list. */ library LinkedList { /* * @notice A permanent NULL node (0x0) in the circular double linked list. * NULL.next is the head, and NULL.previous is the tail. */ address public constant NULL = address(0); /** * @notice A node points to the node before it, and the node after it. If * node.previous = NULL, then the node is the head of the list. If * node.next = NULL, then the node is the tail of the list. */ struct Node { bool inList; address previous; address next; } /** * @notice LinkedList uses a mapping from address to nodes. Each address * uniquely identifies a node, and in this way they are used like pointers. */ struct List { mapping(address => Node) list; } /** * @notice Insert a new node before an existing node. * * @param self The list being used. * @param target The existing node in the list. * @param newNode The next node to insert before the target. */ function insertBefore( List storage self, address target, address newNode ) internal { require(newNode != address(0), "LinkedList: invalid address"); require(!isInList(self, newNode), "LinkedList: already in list"); require( isInList(self, target) || target == NULL, "LinkedList: not in list" ); // It is expected that this value is sometimes NULL. address prev = self.list[target].previous; self.list[newNode].next = target; self.list[newNode].previous = prev; self.list[target].previous = newNode; self.list[prev].next = newNode; self.list[newNode].inList = true; } /** * @notice Insert a new node after an existing node. * * @param self The list being used. * @param target The existing node in the list. * @param newNode The next node to insert after the target. */ function insertAfter( List storage self, address target, address newNode ) internal { require(newNode != address(0), "LinkedList: invalid address"); require(!isInList(self, newNode), "LinkedList: already in list"); require( isInList(self, target) || target == NULL, "LinkedList: not in list" ); // It is expected that this value is sometimes NULL. address n = self.list[target].next; self.list[newNode].previous = target; self.list[newNode].next = n; self.list[target].next = newNode; self.list[n].previous = newNode; self.list[newNode].inList = true; } /** * @notice Remove a node from the list, and fix the previous and next * pointers that are pointing to the removed node. Removing anode that is not * in the list will do nothing. * * @param self The list being using. * @param node The node in the list to be removed. */ function remove(List storage self, address node) internal { require(isInList(self, node), "LinkedList: not in list"); address p = self.list[node].previous; address n = self.list[node].next; self.list[p].next = n; self.list[n].previous = p; // Deleting the node should set this value to false, but we set it here for // explicitness. self.list[node].inList = false; delete self.list[node]; } /** * @notice Insert a node at the beginning of the list. * * @param self The list being used. * @param node The node to insert at the beginning of the list. */ function prepend(List storage self, address node) internal { // isInList(node) is checked in insertBefore insertBefore(self, begin(self), node); } /** * @notice Insert a node at the end of the list. * * @param self The list being used. * @param node The node to insert at the end of the list. */ function append(List storage self, address node) internal { // isInList(node) is checked in insertBefore insertAfter(self, end(self), node); } function swap( List storage self, address left, address right ) internal { // isInList(left) and isInList(right) are checked in remove address previousRight = self.list[right].previous; remove(self, right); insertAfter(self, left, right); remove(self, left); insertAfter(self, previousRight, left); } function isInList(List storage self, address node) internal view returns (bool) { return self.list[node].inList; } /** * @notice Get the node at the beginning of a double linked list. * * @param self The list being used. * * @return A address identifying the node at the beginning of the double * linked list. */ function begin(List storage self) internal view returns (address) { return self.list[NULL].next; } /** * @notice Get the node at the end of a double linked list. * * @param self The list being used. * * @return A address identifying the node at the end of the double linked * list. */ function end(List storage self) internal view returns (address) { return self.list[NULL].previous; } function next(List storage self, address node) internal view returns (address) { require(isInList(self, node), "LinkedList: not in list"); return self.list[node].next; } function previous(List storage self, address node) internal view returns (address) { require(isInList(self, node), "LinkedList: not in list"); return self.list[node].previous; } function elements( List storage self, address _start, uint256 _count ) internal view returns (address[] memory) { require(_count > 0, "LinkedList: invalid count"); require( isInList(self, _start) || _start == address(0), "LinkedList: not in list" ); address[] memory elems = new address[](_count); // Begin with the first node in the list uint256 n = 0; address nextItem = _start; if (nextItem == address(0)) { nextItem = begin(self); } while (n < _count) { if (nextItem == address(0)) { break; } elems[n] = nextItem; nextItem = next(self, nextItem); n += 1; } return elems; } }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "./ERC20.sol"; import "../../access/roles/MinterRole.sol"; /** * @dev Extension of {ERC20} that adds a set of accounts with the {MinterRole}, * which have permission to mint (create) new tokens as they see fit. * * At construction, the deployer of the contract is the only minter. */ contract ERC20Mintable is Initializable, ERC20, MinterRole { function initialize(address sender) public initializer { MinterRole.initialize(sender); } /** * @dev See {ERC20-_mint}. * * Requirements: * * - the caller must have the {MinterRole}. */ function mint(address account, uint256 amount) public onlyMinter returns (bool) { _mint(account, amount); return true; } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "./ERC20.sol"; import "../../lifecycle/Pausable.sol"; /** * @title Pausable token * @dev ERC20 with pausable transfers and allowances. * * Useful if you want to stop trades until the end of a crowdsale, or have * an emergency switch for freezing all token transfers in the event of a large * bug. */ contract ERC20Pausable is Initializable, ERC20, Pausable { function initialize(address sender) public initializer { Pausable.initialize(sender); } function transfer(address to, uint256 value) public whenNotPaused returns (bool) { return super.transfer(to, value); } function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) { return super.transferFrom(from, to, value); } function approve(address spender, uint256 value) public whenNotPaused returns (bool) { return super.approve(spender, value); } function increaseAllowance(address spender, uint256 addedValue) public whenNotPaused returns (bool) { return super.increaseAllowance(spender, addedValue); } function decreaseAllowance(address spender, uint256 subtractedValue) public whenNotPaused returns (bool) { return super.decreaseAllowance(spender, subtractedValue); } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../../GSN/Context.sol"; import "../Roles.sol"; contract MinterRole is Initializable, Context { using Roles for Roles.Role; event MinterAdded(address indexed account); event MinterRemoved(address indexed account); Roles.Role private _minters; function initialize(address sender) public initializer { if (!isMinter(sender)) { _addMinter(sender); } } modifier onlyMinter() { require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role"); _; } function isMinter(address account) public view returns (bool) { return _minters.has(account); } function addMinter(address account) public onlyMinter { _addMinter(account); } function renounceMinter() public { _removeMinter(_msgSender()); } function _addMinter(address account) internal { _minters.add(account); emit MinterAdded(account); } function _removeMinter(address account) internal { _minters.remove(account); emit MinterRemoved(account); } uint256[50] private ______gap; }
pragma solidity ^0.5.0; /** * @title Roles * @dev Library for managing addresses assigned to a Role. */ library Roles { struct Role { mapping (address => bool) bearer; } /** * @dev Give an account access to this role. */ function add(Role storage role, address account) internal { require(!has(role, account), "Roles: account already has role"); role.bearer[account] = true; } /** * @dev Remove an account's access to this role. */ function remove(Role storage role, address account) internal { require(has(role, account), "Roles: account does not have role"); role.bearer[account] = false; } /** * @dev Check if an account has this role. * @return bool */ function has(Role storage role, address account) internal view returns (bool) { require(account != address(0), "Roles: account is the zero address"); return role.bearer[account]; } }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../GSN/Context.sol"; import "../access/roles/PauserRole.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ contract Pausable is Initializable, Context, PauserRole { /** * @dev Emitted when the pause is triggered by a pauser (`account`). */ event Paused(address account); /** * @dev Emitted when the pause is lifted by a pauser (`account`). */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. Assigns the Pauser role * to the deployer. */ function initialize(address sender) public initializer { PauserRole.initialize(sender); _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. */ modifier whenNotPaused() { require(!_paused, "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. */ modifier whenPaused() { require(_paused, "Pausable: not paused"); _; } /** * @dev Called by a pauser to pause, triggers stopped state. */ function pause() public onlyPauser whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Called by a pauser to unpause, returns to normal state. */ function unpause() public onlyPauser whenPaused { _paused = false; emit Unpaused(_msgSender()); } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../../GSN/Context.sol"; import "../Roles.sol"; contract PauserRole is Initializable, Context { using Roles for Roles.Role; event PauserAdded(address indexed account); event PauserRemoved(address indexed account); Roles.Role private _pausers; function initialize(address sender) public initializer { if (!isPauser(sender)) { _addPauser(sender); } } modifier onlyPauser() { require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role"); _; } function isPauser(address account) public view returns (bool) { return _pausers.has(account); } function addPauser(address account) public onlyPauser { _addPauser(account); } function renouncePauser() public { _removePauser(_msgSender()); } function _addPauser(address account) internal { _pausers.add(account); emit PauserAdded(account); } function _removePauser(address account) internal { _pausers.remove(account); emit PauserRemoved(account); } uint256[50] private ______gap; }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "./IRelayRecipient.sol"; import "./IRelayHub.sol"; import "./Context.sol"; /** * @dev Base GSN recipient contract: includes the {IRelayRecipient} interface * and enables GSN support on all contracts in the inheritance tree. * * TIP: This contract is abstract. The functions {IRelayRecipient-acceptRelayedCall}, * {_preRelayedCall}, and {_postRelayedCall} are not implemented and must be * provided by derived contracts. See the * xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategies] for more * information on how to use the pre-built {GSNRecipientSignature} and * {GSNRecipientERC20Fee}, or how to write your own. */ contract GSNRecipient is Initializable, IRelayRecipient, Context { function initialize() public initializer { if (_relayHub == address(0)) { setDefaultRelayHub(); } } function setDefaultRelayHub() public { _upgradeRelayHub(0xD216153c06E857cD7f72665E0aF1d7D82172F494); } // Default RelayHub address, deployed on mainnet and all testnets at the same address address private _relayHub; uint256 constant private RELAYED_CALL_ACCEPTED = 0; uint256 constant private RELAYED_CALL_REJECTED = 11; // How much gas is forwarded to postRelayedCall uint256 constant internal POST_RELAYED_CALL_MAX_GAS = 100000; /** * @dev Emitted when a contract changes its {IRelayHub} contract to a new one. */ event RelayHubChanged(address indexed oldRelayHub, address indexed newRelayHub); /** * @dev Returns the address of the {IRelayHub} contract for this recipient. */ function getHubAddr() public view returns (address) { return _relayHub; } /** * @dev Switches to a new {IRelayHub} instance. This method is added for future-proofing: there's no reason to not * use the default instance. * * IMPORTANT: After upgrading, the {GSNRecipient} will no longer be able to receive relayed calls from the old * {IRelayHub} instance. Additionally, all funds should be previously withdrawn via {_withdrawDeposits}. */ function _upgradeRelayHub(address newRelayHub) internal { address currentRelayHub = _relayHub; require(newRelayHub != address(0), "GSNRecipient: new RelayHub is the zero address"); require(newRelayHub != currentRelayHub, "GSNRecipient: new RelayHub is the current one"); emit RelayHubChanged(currentRelayHub, newRelayHub); _relayHub = newRelayHub; } /** * @dev Returns the version string of the {IRelayHub} for which this recipient implementation was built. If * {_upgradeRelayHub} is used, the new {IRelayHub} instance should be compatible with this version. */ // This function is view for future-proofing, it may require reading from // storage in the future. function relayHubVersion() public view returns (string memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return "1.0.0"; } /** * @dev Withdraws the recipient's deposits in `RelayHub`. * * Derived contracts should expose this in an external interface with proper access control. */ function _withdrawDeposits(uint256 amount, address payable payee) internal { IRelayHub(_relayHub).withdraw(amount, payee); } // Overrides for Context's functions: when called from RelayHub, sender and // data require some pre-processing: the actual sender is stored at the end // of the call data, which in turns means it needs to be removed from it // when handling said data. /** * @dev Replacement for msg.sender. Returns the actual sender of a transaction: msg.sender for regular transactions, * and the end-user for GSN relayed calls (where msg.sender is actually `RelayHub`). * * IMPORTANT: Contracts derived from {GSNRecipient} should never use `msg.sender`, and use {_msgSender} instead. */ function _msgSender() internal view returns (address payable) { if (msg.sender != _relayHub) { return msg.sender; } else { return _getRelayedCallSender(); } } /** * @dev Replacement for msg.data. Returns the actual calldata of a transaction: msg.data for regular transactions, * and a reduced version for GSN relayed calls (where msg.data contains additional information). * * IMPORTANT: Contracts derived from {GSNRecipient} should never use `msg.data`, and use {_msgData} instead. */ function _msgData() internal view returns (bytes memory) { if (msg.sender != _relayHub) { return msg.data; } else { return _getRelayedCallData(); } } // Base implementations for pre and post relayedCall: only RelayHub can invoke them, and data is forwarded to the // internal hook. /** * @dev See `IRelayRecipient.preRelayedCall`. * * This function should not be overriden directly, use `_preRelayedCall` instead. * * * Requirements: * * - the caller must be the `RelayHub` contract. */ function preRelayedCall(bytes calldata context) external returns (bytes32) { require(msg.sender == getHubAddr(), "GSNRecipient: caller is not RelayHub"); return _preRelayedCall(context); } /** * @dev See `IRelayRecipient.preRelayedCall`. * * Called by `GSNRecipient.preRelayedCall`, which asserts the caller is the `RelayHub` contract. Derived contracts * must implement this function with any relayed-call preprocessing they may wish to do. * */ function _preRelayedCall(bytes memory context) internal returns (bytes32); /** * @dev See `IRelayRecipient.postRelayedCall`. * * This function should not be overriden directly, use `_postRelayedCall` instead. * * * Requirements: * * - the caller must be the `RelayHub` contract. */ function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external { require(msg.sender == getHubAddr(), "GSNRecipient: caller is not RelayHub"); _postRelayedCall(context, success, actualCharge, preRetVal); } /** * @dev See `IRelayRecipient.postRelayedCall`. * * Called by `GSNRecipient.postRelayedCall`, which asserts the caller is the `RelayHub` contract. Derived contracts * must implement this function with any relayed-call postprocessing they may wish to do. * */ function _postRelayedCall(bytes memory context, bool success, uint256 actualCharge, bytes32 preRetVal) internal; /** * @dev Return this in acceptRelayedCall to proceed with the execution of a relayed call. Note that this contract * will be charged a fee by RelayHub */ function _approveRelayedCall() internal pure returns (uint256, bytes memory) { return _approveRelayedCall(""); } /** * @dev See `GSNRecipient._approveRelayedCall`. * * This overload forwards `context` to _preRelayedCall and _postRelayedCall. */ function _approveRelayedCall(bytes memory context) internal pure returns (uint256, bytes memory) { return (RELAYED_CALL_ACCEPTED, context); } /** * @dev Return this in acceptRelayedCall to impede execution of a relayed call. No fees will be charged. */ function _rejectRelayedCall(uint256 errorCode) internal pure returns (uint256, bytes memory) { return (RELAYED_CALL_REJECTED + errorCode, ""); } /* * @dev Calculates how much RelayHub will charge a recipient for using `gas` at a `gasPrice`, given a relayer's * `serviceFee`. */ function _computeCharge(uint256 gas, uint256 gasPrice, uint256 serviceFee) internal pure returns (uint256) { // The fee is expressed as a percentage. E.g. a value of 40 stands for a 40% fee, so the recipient will be // charged for 1.4 times the spent amount. return (gas * gasPrice * (100 + serviceFee)) / 100; } function _getRelayedCallSender() private pure returns (address payable result) { // We need to read 20 bytes (an address) located at array index msg.data.length - 20. In memory, the array // is prefixed with a 32-byte length value, so we first add 32 to get the memory read index. However, doing // so would leave the address in the upper 20 bytes of the 32-byte word, which is inconvenient and would // require bit shifting. We therefore subtract 12 from the read index so the address lands on the lower 20 // bytes. This can always be done due to the 32-byte prefix. // The final memory read index is msg.data.length - 20 + 32 - 12 = msg.data.length. Using inline assembly is the // easiest/most-efficient way to perform this operation. // These fields are not accessible from assembly bytes memory array = msg.data; uint256 index = msg.data.length; // solhint-disable-next-line no-inline-assembly assembly { // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those. result := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff) } return result; } function _getRelayedCallData() private pure returns (bytes memory) { // RelayHub appends the sender address at the end of the calldata, so in order to retrieve the actual msg.data, // we must strip the last 20 bytes (length of an address type) from it. uint256 actualDataLength = msg.data.length - 20; bytes memory actualData = new bytes(actualDataLength); for (uint256 i = 0; i < actualDataLength; ++i) { actualData[i] = msg.data[i]; } return actualData; } }
pragma solidity ^0.5.0; /** * @dev Base interface for a contract that will be called via the GSN from {IRelayHub}. * * TIP: You don't need to write an implementation yourself! Inherit from {GSNRecipient} instead. */ interface IRelayRecipient { /** * @dev Returns the address of the {IRelayHub} instance this recipient interacts with. */ function getHubAddr() external view returns (address); /** * @dev Called by {IRelayHub} to validate if this recipient accepts being charged for a relayed call. Note that the * recipient will be charged regardless of the execution result of the relayed call (i.e. if it reverts or not). * * The relay request was originated by `from` and will be served by `relay`. `encodedFunction` is the relayed call * calldata, so its first four bytes are the function selector. The relayed call will be forwarded `gasLimit` gas, * and the transaction executed with a gas price of at least `gasPrice`. `relay`'s fee is `transactionFee`, and the * recipient will be charged at most `maxPossibleCharge` (in wei). `nonce` is the sender's (`from`) nonce for * replay attack protection in {IRelayHub}, and `approvalData` is a optional parameter that can be used to hold a signature * over all or some of the previous values. * * Returns a tuple, where the first value is used to indicate approval (0) or rejection (custom non-zero error code, * values 1 to 10 are reserved) and the second one is data to be passed to the other {IRelayRecipient} functions. * * {acceptRelayedCall} is called with 50k gas: if it runs out during execution, the request will be considered * rejected. A regular revert will also trigger a rejection. */ function acceptRelayedCall( address relay, address from, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata approvalData, uint256 maxPossibleCharge ) external view returns (uint256, bytes memory); /** * @dev Called by {IRelayHub} on approved relay call requests, before the relayed call is executed. This allows to e.g. * pre-charge the sender of the transaction. * * `context` is the second value returned in the tuple by {acceptRelayedCall}. * * Returns a value to be passed to {postRelayedCall}. * * {preRelayedCall} is called with 100k gas: if it runs out during exection or otherwise reverts, the relayed call * will not be executed, but the recipient will still be charged for the transaction's cost. */ function preRelayedCall(bytes calldata context) external returns (bytes32); /** * @dev Called by {IRelayHub} on approved relay call requests, after the relayed call is executed. This allows to e.g. * charge the user for the relayed call costs, return any overcharges from {preRelayedCall}, or perform * contract-specific bookkeeping. * * `context` is the second value returned in the tuple by {acceptRelayedCall}. `success` is the execution status of * the relayed call. `actualCharge` is an estimate of how much the recipient will be charged for the transaction, * not including any gas used by {postRelayedCall} itself. `preRetVal` is {preRelayedCall}'s return value. * * * {postRelayedCall} is called with 100k gas: if it runs out during execution or otherwise reverts, the relayed call * and the call to {preRelayedCall} will be reverted retroactively, but the recipient will still be charged for the * transaction's cost. */ function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external; }
pragma solidity ^0.5.0; /** * @dev Interface for `RelayHub`, the core contract of the GSN. Users should not need to interact with this contract * directly. * * See the https://github.com/OpenZeppelin/openzeppelin-gsn-helpers[OpenZeppelin GSN helpers] for more information on * how to deploy an instance of `RelayHub` on your local test network. */ interface IRelayHub { // Relay management /** * @dev Adds stake to a relay and sets its `unstakeDelay`. If the relay does not exist, it is created, and the caller * of this function becomes its owner. If the relay already exists, only the owner can call this function. A relay * cannot be its own owner. * * All Ether in this function call will be added to the relay's stake. * Its unstake delay will be assigned to `unstakeDelay`, but the new value must be greater or equal to the current one. * * Emits a {Staked} event. */ function stake(address relayaddr, uint256 unstakeDelay) external payable; /** * @dev Emitted when a relay's stake or unstakeDelay are increased */ event Staked(address indexed relay, uint256 stake, uint256 unstakeDelay); /** * @dev Registers the caller as a relay. * The relay must be staked for, and not be a contract (i.e. this function must be called directly from an EOA). * * This function can be called multiple times, emitting new {RelayAdded} events. Note that the received * `transactionFee` is not enforced by {relayCall}. * * Emits a {RelayAdded} event. */ function registerRelay(uint256 transactionFee, string calldata url) external; /** * @dev Emitted when a relay is registered or re-registerd. Looking at these events (and filtering out * {RelayRemoved} events) lets a client discover the list of available relays. */ event RelayAdded(address indexed relay, address indexed owner, uint256 transactionFee, uint256 stake, uint256 unstakeDelay, string url); /** * @dev Removes (deregisters) a relay. Unregistered (but staked for) relays can also be removed. * * Can only be called by the owner of the relay. After the relay's `unstakeDelay` has elapsed, {unstake} will be * callable. * * Emits a {RelayRemoved} event. */ function removeRelayByOwner(address relay) external; /** * @dev Emitted when a relay is removed (deregistered). `unstakeTime` is the time when unstake will be callable. */ event RelayRemoved(address indexed relay, uint256 unstakeTime); /** Deletes the relay from the system, and gives back its stake to the owner. * * Can only be called by the relay owner, after `unstakeDelay` has elapsed since {removeRelayByOwner} was called. * * Emits an {Unstaked} event. */ function unstake(address relay) external; /** * @dev Emitted when a relay is unstaked for, including the returned stake. */ event Unstaked(address indexed relay, uint256 stake); // States a relay can be in enum RelayState { Unknown, // The relay is unknown to the system: it has never been staked for Staked, // The relay has been staked for, but it is not yet active Registered, // The relay has registered itself, and is active (can relay calls) Removed // The relay has been removed by its owner and can no longer relay calls. It must wait for its unstakeDelay to elapse before it can unstake } /** * @dev Returns a relay's status. Note that relays can be deleted when unstaked or penalized, causing this function * to return an empty entry. */ function getRelay(address relay) external view returns (uint256 totalStake, uint256 unstakeDelay, uint256 unstakeTime, address payable owner, RelayState state); // Balance management /** * @dev Deposits Ether for a contract, so that it can receive (and pay for) relayed transactions. * * Unused balance can only be withdrawn by the contract itself, by calling {withdraw}. * * Emits a {Deposited} event. */ function depositFor(address target) external payable; /** * @dev Emitted when {depositFor} is called, including the amount and account that was funded. */ event Deposited(address indexed recipient, address indexed from, uint256 amount); /** * @dev Returns an account's deposits. These can be either a contracts's funds, or a relay owner's revenue. */ function balanceOf(address target) external view returns (uint256); /** * Withdraws from an account's balance, sending it back to it. Relay owners call this to retrieve their revenue, and * contracts can use it to reduce their funding. * * Emits a {Withdrawn} event. */ function withdraw(uint256 amount, address payable dest) external; /** * @dev Emitted when an account withdraws funds from `RelayHub`. */ event Withdrawn(address indexed account, address indexed dest, uint256 amount); // Relaying /** * @dev Checks if the `RelayHub` will accept a relayed operation. * Multiple things must be true for this to happen: * - all arguments must be signed for by the sender (`from`) * - the sender's nonce must be the current one * - the recipient must accept this transaction (via {acceptRelayedCall}) * * Returns a `PreconditionCheck` value (`OK` when the transaction can be relayed), or a recipient-specific error * code if it returns one in {acceptRelayedCall}. */ function canRelay( address relay, address from, address to, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata signature, bytes calldata approvalData ) external view returns (uint256 status, bytes memory recipientContext); // Preconditions for relaying, checked by canRelay and returned as the corresponding numeric values. enum PreconditionCheck { OK, // All checks passed, the call can be relayed WrongSignature, // The transaction to relay is not signed by requested sender WrongNonce, // The provided nonce has already been used by the sender AcceptRelayedCallReverted, // The recipient rejected this call via acceptRelayedCall InvalidRecipientStatusCode // The recipient returned an invalid (reserved) status code } /** * @dev Relays a transaction. * * For this to succeed, multiple conditions must be met: * - {canRelay} must `return PreconditionCheck.OK` * - the sender must be a registered relay * - the transaction's gas price must be larger or equal to the one that was requested by the sender * - the transaction must have enough gas to not run out of gas if all internal transactions (calls to the * recipient) use all gas available to them * - the recipient must have enough balance to pay the relay for the worst-case scenario (i.e. when all gas is * spent) * * If all conditions are met, the call will be relayed and the recipient charged. {preRelayedCall}, the encoded * function and {postRelayedCall} will be called in that order. * * Parameters: * - `from`: the client originating the request * - `to`: the target {IRelayRecipient} contract * - `encodedFunction`: the function call to relay, including data * - `transactionFee`: fee (%) the relay takes over actual gas cost * - `gasPrice`: gas price the client is willing to pay * - `gasLimit`: gas to forward when calling the encoded function * - `nonce`: client's nonce * - `signature`: client's signature over all previous params, plus the relay and RelayHub addresses * - `approvalData`: dapp-specific data forwared to {acceptRelayedCall}. This value is *not* verified by the * `RelayHub`, but it still can be used for e.g. a signature. * * Emits a {TransactionRelayed} event. */ function relayCall( address from, address to, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata signature, bytes calldata approvalData ) external; /** * @dev Emitted when an attempt to relay a call failed. * * This can happen due to incorrect {relayCall} arguments, or the recipient not accepting the relayed call. The * actual relayed call was not executed, and the recipient not charged. * * The `reason` parameter contains an error code: values 1-10 correspond to `PreconditionCheck` entries, and values * over 10 are custom recipient error codes returned from {acceptRelayedCall}. */ event CanRelayFailed(address indexed relay, address indexed from, address indexed to, bytes4 selector, uint256 reason); /** * @dev Emitted when a transaction is relayed. * Useful when monitoring a relay's operation and relayed calls to a contract * * Note that the actual encoded function might be reverted: this is indicated in the `status` parameter. * * `charge` is the Ether value deducted from the recipient's balance, paid to the relay's owner. */ event TransactionRelayed(address indexed relay, address indexed from, address indexed to, bytes4 selector, RelayCallStatus status, uint256 charge); // Reason error codes for the TransactionRelayed event enum RelayCallStatus { OK, // The transaction was successfully relayed and execution successful - never included in the event RelayedCallFailed, // The transaction was relayed, but the relayed call failed PreRelayedFailed, // The transaction was not relayed due to preRelatedCall reverting PostRelayedFailed, // The transaction was relayed and reverted due to postRelatedCall reverting RecipientBalanceChanged // The transaction was relayed and reverted due to the recipient's balance changing } /** * @dev Returns how much gas should be forwarded to a call to {relayCall}, in order to relay a transaction that will * spend up to `relayedCallStipend` gas. */ function requiredGas(uint256 relayedCallStipend) external view returns (uint256); /** * @dev Returns the maximum recipient charge, given the amount of gas forwarded, gas price and relay fee. */ function maxPossibleCharge(uint256 relayedCallStipend, uint256 gasPrice, uint256 transactionFee) external view returns (uint256); // Relay penalization. // Any account can penalize relays, removing them from the system immediately, and rewarding the // reporter with half of the relay's stake. The other half is burned so that, even if the relay penalizes itself, it // still loses half of its stake. /** * @dev Penalize a relay that signed two transactions using the same nonce (making only the first one valid) and * different data (gas price, gas limit, etc. may be different). * * The (unsigned) transaction data and signature for both transactions must be provided. */ function penalizeRepeatedNonce(bytes calldata unsignedTx1, bytes calldata signature1, bytes calldata unsignedTx2, bytes calldata signature2) external; /** * @dev Penalize a relay that sent a transaction that didn't target `RelayHub`'s {registerRelay} or {relayCall}. */ function penalizeIllegalTransaction(bytes calldata unsignedTx, bytes calldata signature) external; /** * @dev Emitted when a relay is penalized. */ event Penalized(address indexed relay, address sender, uint256 amount); /** * @dev Returns an account's nonce in `RelayHub`. */ function getNonce(address from) external view returns (uint256); }
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/upgrades/contracts/upgradeability/InitializableAdminUpgradeabilityProxy.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; import "../Governance/Claimable.sol"; import "../libraries/String.sol"; import "./RenERC20.sol"; import "./interfaces/IGateway.sol"; import "../libraries/CanReclaimTokens.sol"; import "./MintGatewayV2.sol"; import "../Governance/RenProxyAdmin.sol"; contract MintGatewayUpgrader is Ownable, CanReclaimTokens { RenProxyAdmin renProxyAdmin; MintGatewayLogicV2 newGatewayLogic; address previousAdminOwner; address newMintAuthority; constructor( RenProxyAdmin _renProxyAdmin, MintGatewayLogicV2 _newGatewayLogic, address _newMintAuthority ) public { Ownable.initialize(msg.sender); renProxyAdmin = _renProxyAdmin; newGatewayLogic = _newGatewayLogic; previousAdminOwner = renProxyAdmin.owner(); newMintAuthority = _newMintAuthority; } function upgrade(MintGatewayLogicV2 gatewayInstance, bytes32 selectorHash) public onlyOwner { uint256 minimumBurnAmount = gatewayInstance.minimumBurnAmount(); RenERC20LogicV1 token = gatewayInstance.token(); address mintAuthority = gatewayInstance.mintAuthority(); address feeRecipient = gatewayInstance.feeRecipient(); uint16 mintFee = gatewayInstance.mintFee(); uint16 burnFee = gatewayInstance.burnFee(); uint256 nextN = gatewayInstance.nextN(); address previousGatewayOwner = gatewayInstance.owner(); gatewayInstance.claimOwnership(); // Update implementation. renProxyAdmin.upgrade( AdminUpgradeabilityProxy( // Cast gateway instance to payable address address(uint160(address(gatewayInstance))) ), address(newGatewayLogic) ); // Update mint authorities and selector hash. address legacyMintAuthority = gatewayInstance.mintAuthority(); gatewayInstance.updateMintAuthority(newMintAuthority); gatewayInstance._legacy_updateMintAuthority(legacyMintAuthority); gatewayInstance.updateSelectorHash(selectorHash); require( gatewayInstance.minimumBurnAmount() == minimumBurnAmount, "Expected minimumBurnAmount to not change." ); require( gatewayInstance.token() == token, "Expected token to not change." ); require( gatewayInstance._legacy_mintAuthority() == mintAuthority, "Expected _legacy_mintAuthority to equal old mintAuthority." ); require( gatewayInstance.mintAuthority() == newMintAuthority, "Expected mintAuthority to equal new mintAuthority." ); require( gatewayInstance.feeRecipient() == feeRecipient, "Expected feeRecipient to not change." ); require( gatewayInstance.mintFee() == mintFee, "Expected mintFee to not change." ); require( gatewayInstance.burnFee() == burnFee, "Expected burnFee to not change." ); require( gatewayInstance.nextN() == nextN, "Expected nextN to not change." ); gatewayInstance._directTransferOwnership(previousGatewayOwner); } function done() public onlyOwner { renProxyAdmin.transferOwnership(previousAdminOwner); } }
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/upgradeability/ProxyAdmin.sol"; /** * @title RenProxyAdmin * @dev Proxies restrict the proxy's owner from calling functions from the * delegate contract logic. The ProxyAdmin contract allows single account to be * the governance address of both the proxy and the delegate contract logic. */ /* solium-disable-next-line no-empty-blocks */ contract RenProxyAdmin is ProxyAdmin { }
pragma solidity ^0.5.0; import "../ownership/Ownable.sol"; import "./AdminUpgradeabilityProxy.sol"; /** * @title ProxyAdmin * @dev This contract is the admin of a proxy, and is in charge * of upgrading it as well as transferring it to another admin. */ contract ProxyAdmin is OpenZeppelinUpgradesOwnable { /** * @dev Returns the current implementation of a proxy. * This is needed because only the proxy admin can query it. * @return The address of the current implementation of the proxy. */ function getProxyImplementation(AdminUpgradeabilityProxy proxy) public view returns (address) { // We need to manually run the static call since the getter cannot be flagged as view // bytes4(keccak256("implementation()")) == 0x5c60da1b (bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b"); require(success); return abi.decode(returndata, (address)); } /** * @dev Returns the admin of a proxy. Only the admin can query it. * @return The address of the current admin of the proxy. */ function getProxyAdmin(AdminUpgradeabilityProxy proxy) public view returns (address) { // We need to manually run the static call since the getter cannot be flagged as view // bytes4(keccak256("admin()")) == 0xf851a440 (bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440"); require(success); return abi.decode(returndata, (address)); } /** * @dev Changes the admin of a proxy. * @param proxy Proxy to change admin. * @param newAdmin Address to transfer proxy administration to. */ function changeProxyAdmin(AdminUpgradeabilityProxy proxy, address newAdmin) public onlyOwner { proxy.changeAdmin(newAdmin); } /** * @dev Upgrades a proxy to the newest implementation of a contract. * @param proxy Proxy to be upgraded. * @param implementation the address of the Implementation. */ function upgrade(AdminUpgradeabilityProxy proxy, address implementation) public onlyOwner { proxy.upgradeTo(implementation); } /** * @dev Upgrades a proxy to the newest implementation of a contract and forwards a function call to it. * This is useful to initialize the proxied contract. * @param proxy Proxy to be upgraded. * @param implementation Address of the Implementation. * @param data Data to send as msg.data in the low level call. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. */ function upgradeAndCall(AdminUpgradeabilityProxy proxy, address implementation, bytes memory data) payable public onlyOwner { proxy.upgradeToAndCall.value(msg.value)(implementation, data); } }
pragma solidity ^0.5.0; /** * @title Ownable * @dev The Ownable contract has an owner address, and provides basic authorization control * functions, this simplifies the implementation of "user permissions". * * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/ownership/Ownable.sol * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the * build/artifacts folder) as well as the vanilla Ownable implementation from an openzeppelin version. */ contract OpenZeppelinUpgradesOwnable { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev The Ownable constructor sets the original `owner` of the contract to the sender * account. */ constructor () internal { _owner = msg.sender; emit OwnershipTransferred(address(0), _owner); } /** * @return the address of the owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(isOwner()); _; } /** * @return true if `msg.sender` is the owner of the contract. */ function isOwner() public view returns (bool) { return msg.sender == _owner; } /** * @dev Allows the current owner to relinquish control of the contract. * @notice Renouncing to ownership will leave the contract without an owner. * It will not be possible to call the functions with the `onlyOwner` * modifier anymore. */ function renounceOwnership() public onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Allows the current owner to transfer control of the contract to a newOwner. * @param newOwner The address to transfer ownership to. */ function transferOwnership(address newOwner) public onlyOwner { _transferOwnership(newOwner); } /** * @dev Transfers control of the contract to a newOwner. * @param newOwner The address to transfer ownership to. */ function _transferOwnership(address newOwner) internal { require(newOwner != address(0)); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
pragma solidity ^0.5.0; import './BaseAdminUpgradeabilityProxy.sol'; /** * @title AdminUpgradeabilityProxy * @dev Extends from BaseAdminUpgradeabilityProxy with a constructor for * initializing the implementation, admin, and init data. */ contract AdminUpgradeabilityProxy is BaseAdminUpgradeabilityProxy, UpgradeabilityProxy { /** * Contract constructor. * @param _logic address of the initial implementation. * @param _admin Address of the proxy administrator. * @param _data Data to send as msg.data to the implementation to initialize the proxied contract. * It should include the signature and the parameters of the function to be called, as described in * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding. * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped. */ constructor(address _logic, address _admin, bytes memory _data) UpgradeabilityProxy(_logic, _data) public payable { assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)); _setAdmin(_admin); } }
pragma solidity ^0.5.17; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/cryptography/ECDSA.sol"; import "@openzeppelin/upgrades/contracts/upgradeability/InitializableAdminUpgradeabilityProxy.sol"; import "../Governance/Claimable.sol"; import "../libraries/String.sol"; import "./RenERC20.sol"; import "./interfaces/IGateway.sol"; import "../libraries/CanReclaimTokens.sol"; contract LockGatewayStateV1 { uint256 constant BIPS_DENOMINATOR = 10000; uint256 public minimumBurnAmount; /// @notice Each Gateway is tied to a specific RenERC20 token. RenERC20LogicV1 public token; /// @notice The mintAuthority is an address that can sign mint requests. address public mintAuthority; /// @dev feeRecipient is assumed to be an address (or a contract) that can /// accept erc20 payments it cannot be 0x0. /// @notice When tokens are mint or burnt, a portion of the tokens are /// forwarded to a fee recipient. address public feeRecipient; /// @notice The mint fee in bips. uint16 public lockFee; /// @notice The burn fee in bips. uint16 public releaseFee; /// @notice Each signature can only be seen once. mapping(bytes32 => bool) public status; // LogMint and LogBurn contain a unique `n` that identifies // the mint or burn event. uint256 public nextN = 0; } /// @notice Gateway handles verifying mint and burn requests. A mintAuthority /// approves new assets to be minted by providing a digital signature. An owner /// of an asset can request for it to be burnt. contract LockGatewayLogicV1 is Initializable, Claimable, CanReclaimTokens, // ILock, LockGatewayStateV1 { using SafeMath for uint256; event LogMintAuthorityUpdated(address indexed _newMintAuthority); event LogLock( bytes _to, bytes _p, uint256 _amount, uint256 indexed _n, bytes indexed _indexedTo ); event LogRelease( address indexed _to, uint256 _amount, uint256 indexed _n, bytes32 indexed _signedMessageHash ); /// @notice Only allow the Darknode Payment contract. modifier onlyOwnerOrMintAuthority() { require( msg.sender == mintAuthority || msg.sender == owner(), "Gateway: caller is not the owner or mint authority" ); _; } /// @param _token The RenERC20 this Gateway is responsible for. /// @param _feeRecipient The recipient of burning and minting fees. /// @param _mintAuthority The address of the key that can sign mint /// requests. /// @param _lockFee The amount subtracted each mint request and /// forwarded to the feeRecipient. In BIPS. /// @param _releaseFee The amount subtracted each burn request and /// forwarded to the feeRecipient. In BIPS. function initialize( RenERC20LogicV1 _token, address _feeRecipient, address _mintAuthority, uint16 _lockFee, uint16 _releaseFee, uint256 _minimumBurnAmount ) public initializer { Claimable.initialize(msg.sender); CanReclaimTokens.initialize(msg.sender); minimumBurnAmount = _minimumBurnAmount; token = _token; lockFee = _lockFee; releaseFee = _releaseFee; updateMintAuthority(_mintAuthority); updateFeeRecipient(_feeRecipient); } // Public functions //////////////////////////////////////////////////////// /// @notice Claims ownership of the token passed in to the constructor. /// `transferStoreOwnership` must have previously been called. /// Anyone can call this function. function claimTokenOwnership() public { token.claimOwnership(); } /// @notice Allow the owner to update the fee recipient. /// /// @param _nextMintAuthority The address to start paying fees to. function updateMintAuthority(address _nextMintAuthority) public onlyOwnerOrMintAuthority { // The mint authority should not be set to 0, which is the result // returned by ecrecover for an invalid signature. require( _nextMintAuthority != address(0), "Gateway: mintAuthority cannot be set to address zero" ); mintAuthority = _nextMintAuthority; emit LogMintAuthorityUpdated(mintAuthority); } /// @notice Allow the owner to update the fee recipient. /// /// @param _nextFeeRecipient The address to start paying fees to. function updateFeeRecipient(address _nextFeeRecipient) public onlyOwner { // 'mint' and 'burn' will fail if the feeRecipient is 0x0 require( _nextFeeRecipient != address(0x0), "Gateway: fee recipient cannot be 0x0" ); feeRecipient = _nextFeeRecipient; } /// @notice Allow the owner to update the 'mint' fee. /// /// @param _nextLockFee The new fee for locking. function updateLockFee(uint16 _nextLockFee) public onlyOwner { lockFee = _nextLockFee; } /// @notice Allow the owner to update the burn fee. /// /// @param _nextReleaseFee The new fee for releasing. function updateReleaseFee(uint16 _nextReleaseFee) public onlyOwner { releaseFee = _nextReleaseFee; } function lock( string memory _chain, bytes memory _to, bytes memory _payload, uint256 _amount ) public returns (uint256) { require(token.transferFrom(msg.sender, address(this), _amount)); uint256 fee = _amount.mul(lockFee).div(BIPS_DENOMINATOR); token.transfer(feeRecipient, fee); uint256 amountAfterFee = _amount.sub(fee); emit LogLock(_to, _payload, amountAfterFee, nextN, _to); nextN += 1; return amountAfterFee; } /// @notice release verifies a release approval signature from RenVM and /// sends tokens after taking a fee for the `_feeRecipient`. /// /// @param _pHash (payload hash) The hash of the payload associated with the /// release. /// @param _amount The amount of the token being released, in its smallest /// value. (e.g. satoshis for BTC). /// @param _nHash (nonce hash) The hash of the nonce, amount and pHash. /// @param _sig The signature of the hash of the following values: /// (pHash, amount, msg.sender, nHash), signed by the mintAuthority. function release( bytes32 _pHash, uint256 _amount, bytes32 _nHash, bytes memory _sig ) public returns (uint256) { // Verify signature bytes32 signedMessageHash = hashForSignature( _pHash, _amount, msg.sender, _nHash ); require( status[signedMessageHash] == false, "Gateway: nonce hash already spent" ); if (!verifySignature(signedMessageHash, _sig)) { // Return a detailed string containing the hash and recovered // signer. This is somewhat costly but is only run in the revert // branch. revert( String.add8( "Gateway: invalid signature. pHash: ", String.fromBytes32(_pHash), ", amount: ", String.fromUint(_amount), ", msg.sender: ", String.fromAddress(msg.sender), ", _nHash: ", String.fromBytes32(_nHash) ) ); } status[signedMessageHash] = true; uint256 fee = _amount.mul(releaseFee).div(BIPS_DENOMINATOR); uint256 amountAfterFee = _amount.sub(fee); // Mint amount minus the fee token.transfer(msg.sender, fee); // Mint the fee token.transfer(feeRecipient, amountAfterFee); emit LogRelease(msg.sender, amountAfterFee, nextN, signedMessageHash); nextN += 1; return amountAfterFee; } /// @notice verifySignature checks the the provided signature matches the provided /// parameters. function verifySignature(bytes32 _signedMessageHash, bytes memory _sig) public view returns (bool) { return mintAuthority == ECDSA.recover(_signedMessageHash, _sig); } /// @notice hashForSignature hashes the parameters so that they can be signed. function hashForSignature( bytes32 _pHash, uint256 _amount, address _to, bytes32 _nHash ) public view returns (bytes32) { return keccak256(abi.encode(_pHash, _amount, address(token), _to, _nHash)); } } /* solium-disable-next-line no-empty-blocks */ contract LockGatewayProxy is InitializableAdminUpgradeabilityProxy { }
pragma solidity ^0.5.17; import "../GatewayRegistry.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/Math.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; contract Vesting is Ownable { using SafeMath for uint256; GatewayRegistry public registry; uint256 private constant SECONDS_PER_MONTH = 365 days / 12; /// @notice Defines the fields required for a vesting schedule. struct VestingSchedule { // The start time (in seconds since Unix epoch) at which the vesting // period should begin. uint256 startTime; // The number of months for the vesting period. uint16 duration; // The total amount of Bitcoin apart of the vesting schedule. uint256 amount; // The number of months claimed by the user. uint256 monthsClaimed; // The total amount of Bitcoin claimed by the user. uint256 amountClaimed; } /// @notice Mapping of a beneficiary address to a vesting schedule. Each // beneficiary can have a maximum of 1 vesting schedule. mapping(address => VestingSchedule) public schedules; /// @notice The contract constructor. /// @param _registry The GatewayRegistry contract address. constructor(GatewayRegistry _registry) public { Ownable.initialize(msg.sender); registry = _registry; } /// @notice Allows the contract owner to add a vesting schedule for a /// beneficiary. /// @param _amount The amount of Bitcoin provided to the Darknodes in Sats. /// @param _nHash The hash of the nonce returned by the Darknodes. /// @param _sig The signature returned by the Darknodes. /// @param _beneficiary The address of the recipient entitled to claim the vested tokens. /// @param _startTime The start time (in seconds since Unix epoch) at which the vesting /// period should begin. /// @param _duration The number of months for the vesting period. function addVestingSchedule( // Payload address _beneficiary, uint256 _startTime, uint16 _duration, // Required uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external onlyOwner { require( schedules[_beneficiary].startTime == 0, "vesting schedule already exists" ); require(_amount > 0, "amount must be greater than 0"); require(_duration > 0, "duration must be at least 1 month"); // Construct the payload hash and mint new tokens using the Gateway // contract. This will verify the signature to ensure the Darknodes have // received the Bitcoin. bytes32 pHash = keccak256(abi.encode(_beneficiary, _startTime, _duration)); uint256 finalAmountScaled = registry.getGatewayBySymbol("BTC").mint( pHash, _amount, _nHash, _sig ); // Construct a vesting schedule and assign it to the beneficiary. VestingSchedule memory schedule = VestingSchedule({ startTime: _startTime == 0 ? now : _startTime, duration: _duration, amount: finalAmountScaled, monthsClaimed: 0, amountClaimed: 0 }); schedules[_beneficiary] = schedule; } /// @notice Allows a beneficiary to withdraw their vested Bitcoin. /// @param _to The Bitcoin address to which the beneficiary will receive /// their Bitcoin. function claim(bytes calldata _to) external { // Calculate the claimable amount for the caller of the function. uint256 monthsClaimable; uint256 amountClaimable; (monthsClaimable, amountClaimable) = calculateClaimable(msg.sender); require(amountClaimable > 0, "no amount claimable"); // Update the claimed details in the vesting schedule. VestingSchedule storage schedule = schedules[msg.sender]; schedule.monthsClaimed = schedule.monthsClaimed.add(monthsClaimable); schedule.amountClaimed = schedule.amountClaimed.add(amountClaimable); // Burn the tokens using the Gateway contract. This will burn the // tokens after taking a fee. The Darknodes will watch for this event to // transfer the user the Bitcoin. registry.getGatewayBySymbol("BTC").burn(_to, amountClaimable); } /// @notice Retrieves the claimable amount for a given beneficiary. /// @param _to The Ethereum address of the beneficiary. function calculateClaimable(address _to) public view returns (uint256, uint256) { VestingSchedule storage schedule = schedules[_to]; // Return if the vesting schedule does not exist or has not yet started. if (schedule.amount == 0 || now < schedule.startTime) { return (0, 0); } // Calculate the months elapsed since the start of the vesting period. uint256 elapsedTime = now.sub(schedule.startTime); uint256 elapsedMonths = elapsedTime.div(SECONDS_PER_MONTH); // Calculate the months elapsed and amount claimable since the last // claim attempt. uint256 monthsClaimable = Math.min(schedule.duration, elapsedMonths).sub( schedule.monthsClaimed ); uint256 amountClaimable = schedule.amount.mul(monthsClaimable).div(schedule.duration); return (monthsClaimable, amountClaimable); } }
pragma solidity ^0.5.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a >= b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow, so we distribute return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2); } }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/math/SafeMath.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/ownership/Ownable.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/IERC721Receiver.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC777/IERC777Recipient.sol"; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC777/IERC777.sol"; import "../interfaces/IGateway.sol"; import "../interfaces/IGatewayRegistry.sol"; import "./IERC1155/IERC1155.sol"; import "./IERC1155/IERC1155Receiver.sol"; contract GenericAdapter is Ownable, IERC721Receiver, IERC777Recipient, IERC1155Receiver { using SafeMath for uint256; IGatewayRegistry public registry; constructor(IGatewayRegistry _registry) public { Ownable.initialize(msg.sender); registry = _registry; } function directMint( // Payload string calldata _symbol, address _account, uint256 _submitterFee, // Required uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external { // Allow the account to submit without a fee. if (_account == msg.sender) { _submitterFee = 0; } // Calculate the payload hash for the first six parameters. bytes32 payloadHash = keccak256(abi.encode(_symbol, _account, _submitterFee)); // Call `mint` on the Gateway contract. uint256 amount = registry.getGatewayBySymbol(_symbol).mint( payloadHash, _amount, _nHash, _sig ); IERC20 token = registry.getTokenBySymbol(_symbol); token.transfer(_account, amount.sub(_submitterFee)); // Pay fee as last step. if (_submitterFee > 0) { token.transfer(msg.sender, _submitterFee); } } // Track the caller in case there's ERC721 address currentAccount; function genericCall( // Payload string calldata _symbol, address _account, address _contract, bytes calldata _contractParams, IERC20[] calldata _refundTokens, uint256 _submitterFee, // Required uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external { address previousAccount = currentAccount; currentAccount = _account; // Split up to work around stack-too-deep errors. // The function body is spread across the following three functions: // * _genericCallInner, // * _returnReceivedTokens, // * _mintAndCall _genericCallInner( _symbol, _account, _contract, _contractParams, _refundTokens, _submitterFee, _amount, _nHash, _sig ); // Reset `currentAccount`. currentAccount = previousAccount; } function _genericCallInner( // Payload string memory _symbol, address _account, address _contract, bytes memory _contractParams, IERC20[] memory _refundTokens, uint256 _submitterFee, // Required uint256 _amount, bytes32 _nHash, bytes memory _sig ) internal { // Allow the account to submit without a fee. if (_account == msg.sender) { _submitterFee = 0; } // Calculate the payload hash for the first six parameters. bytes32 payloadHash = keccak256( abi.encode( _symbol, _account, _contract, _contractParams, _refundTokens, _submitterFee ) ); _mintAndCall( payloadHash, _symbol, _contract, _contractParams, _submitterFee, _amount, _nHash, _sig ); _returnReceivedTokens(_symbol, _refundTokens, _submitterFee); } function _returnReceivedTokens( string memory _symbol, IERC20[] memory _refundTokens, uint256 _submitterFee ) internal { IERC20 token = registry.getTokenBySymbol(_symbol); // The user must specify which tokens may potentially be recieved during // the contract call. Note that if one of the matched refund tokens // match `token` and a fee is paid out later on, the transaction will // revert. for (uint256 i = 0; i < _refundTokens.length; i++) { IERC20 refundToken = IERC20(_refundTokens[i]); uint256 refundBalance = refundToken.balanceOf(address(this)); if (refundBalance > 0) { refundToken.transfer(currentAccount, refundBalance); } } // Return any remaining `token` balance. uint256 tokenBalance = token.balanceOf(address(this)); if (tokenBalance > _submitterFee) { token.transfer(currentAccount, tokenBalance.sub(_submitterFee)); } // Remain any remaining ETH balance. uint256 ethBalance = address(this).balance; if (ethBalance > 0) { (bool success, ) = currentAccount.call.value(ethBalance)(""); require(success); } // Pay fee as last step. if (_submitterFee > 0) { token.transfer(msg.sender, _submitterFee); } } function _mintAndCall( bytes32 payloadHash, string memory _symbol, address _contract, bytes memory _contractParams, uint256 _submitterFee, uint256 _amount, bytes32 _nHash, bytes memory _sig ) internal { // Call `mint` on the Gateway contract. uint256 amount = registry.getGatewayBySymbol(_symbol).mint( payloadHash, _amount, _nHash, _sig ); IERC20 token = registry.getTokenBySymbol(_symbol); // Approval the amount excluding the fee. uint256 oldApproval = token.allowance(address(this), _contract); token.approve(_contract, oldApproval.add(amount.sub(_submitterFee))); // Call contract with the contract parameters. arbitraryCall(_contract, _contractParams); // Revoke approval. token.approve(_contract, oldApproval); } function onERC721Received( address, address, uint256 tokenId, bytes memory data ) public returns (bytes4) { // Forward on to current account. IERC721(msg.sender).safeTransferFrom( address(this), currentAccount, tokenId, data ); return this.onERC721Received.selector; } function tokensReceived( address, address, address, uint256 amount, bytes memory userData, bytes memory ) public { IERC777(msg.sender).send(currentAccount, amount, userData); } function onERC1155Received( address, address, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4) { IERC1155(msg.sender).safeTransferFrom( address(this), currentAccount, id, value, data ); return this.onERC1155Received.selector; } function onERC1155BatchReceived( address, address, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4) { IERC1155(msg.sender).safeBatchTransferFrom( address(this), currentAccount, ids, values, data ); return this.onERC1155BatchReceived.selector; } // Allow the owner to recover tokens and collectibles stuck in the contract. // This contract is not meant to hold funds. function _recover(address _contract, bytes calldata _contractParams) external onlyOwner { arbitraryCall(_contract, _contractParams); } function arbitraryCall(address _contract, bytes memory _contractParams) internal { (bool success, bytes memory result) = _contract.call(_contractParams); if (!success) { // Check if the call result was too short to be a revert reason. if (result.length < 68) { revert( "GenericAdapter: contract call failed without revert reason" ); } // Return the call's revert reason. assembly { let ptr := mload(0x40) let size := returndatasize returndatacopy(ptr, 0, size) revert(ptr, size) } } } }
pragma solidity ^0.5.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ contract IERC721Receiver { /** * @notice Handle the receipt of an NFT * @dev The ERC721 smart contract calls this function on the recipient * after a {IERC721-safeTransferFrom}. This function MUST return the function selector, * otherwise the caller will revert the transaction. The selector to be * returned can be obtained as `this.onERC721Received.selector`. This * function MAY throw to revert and reject the transfer. * Note: the ERC721 contract address is always the message sender. * @param operator The address which called `safeTransferFrom` function * @param from The address which previously owned the token * @param tokenId The NFT identifier which is being transferred * @param data Additional data with no specified format * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` */ function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public returns (bytes4); }
pragma solidity ^0.5.0; import "@openzeppelin/upgrades/contracts/Initializable.sol"; import "../../introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ contract IERC721 is Initializable, IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of NFTs in `owner`'s account. */ function balanceOf(address owner) public view returns (uint256 balance); /** * @dev Returns the owner of the NFT specified by `tokenId`. */ function ownerOf(uint256 tokenId) public view returns (address owner); /** * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to * another (`to`). * * * * Requirements: * - `from`, `to` cannot be zero. * - `tokenId` must be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this * NFT by either {approve} or {setApprovalForAll}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public; /** * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to * another (`to`). * * Requirements: * - If the caller is not `from`, it must be approved to move this NFT by * either {approve} or {setApprovalForAll}. */ function transferFrom(address from, address to, uint256 tokenId) public; function approve(address to, uint256 tokenId) public; function getApproved(uint256 tokenId) public view returns (address operator); function setApprovalForAll(address operator, bool _approved) public; function isApprovedForAll(address owner, address operator) public view returns (bool); function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public; }
pragma solidity ^0.5.0; /** * @dev Interface of the ERC777TokensRecipient standard as defined in the EIP. * * Accounts can be notified of {IERC777} tokens being sent to them by having a * contract implement this interface (contract holders can be their own * implementer) and registering it on the * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 global registry]. * * See {IERC1820Registry} and {ERC1820Implementer}. */ interface IERC777Recipient { /** * @dev Called by an {IERC777} token contract whenever tokens are being * moved or created into a registered account (`to`). The type of operation * is conveyed by `from` being the zero address or not. * * This call occurs _after_ the token contract's state is updated, so * {IERC777-balanceOf}, etc., can be used to query the post-operation state. * * This function may revert to prevent the operation from being executed. */ function tokensReceived( address operator, address from, address to, uint256 amount, bytes calldata userData, bytes calldata operatorData ) external; }
pragma solidity ^0.5.0; /** * @dev Interface of the ERC777Token standard as defined in the EIP. * * This contract uses the * https://eips.ethereum.org/EIPS/eip-1820[ERC1820 registry standard] to let * token holders and recipients react to token movements by using setting implementers * for the associated interfaces in said registry. See {IERC1820Registry} and * {ERC1820Implementer}. */ interface IERC777 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() external view returns (string memory); /** * @dev Returns the smallest part of the token that is not divisible. This * means all token operations (creation, movement and destruction) must have * amounts that are a multiple of this number. * * For most token contracts, this value will equal 1. */ function granularity() external view returns (uint256); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by an account (`owner`). */ function balanceOf(address owner) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * If send or receive hooks are registered for the caller and `recipient`, * the corresponding functions will be called with `data` and empty * `operatorData`. See {IERC777Sender} and {IERC777Recipient}. * * Emits a {Sent} event. * * Requirements * * - the caller must have at least `amount` tokens. * - `recipient` cannot be the zero address. * - if `recipient` is a contract, it must implement the {IERC777Recipient} * interface. */ function send(address recipient, uint256 amount, bytes calldata data) external; /** * @dev Destroys `amount` tokens from the caller's account, reducing the * total supply. * * If a send hook is registered for the caller, the corresponding function * will be called with `data` and empty `operatorData`. See {IERC777Sender}. * * Emits a {Burned} event. * * Requirements * * - the caller must have at least `amount` tokens. */ function burn(uint256 amount, bytes calldata data) external; /** * @dev Returns true if an account is an operator of `tokenHolder`. * Operators can send and burn tokens on behalf of their owners. All * accounts are their own operator. * * See {operatorSend} and {operatorBurn}. */ function isOperatorFor(address operator, address tokenHolder) external view returns (bool); /** * @dev Make an account an operator of the caller. * * See {isOperatorFor}. * * Emits an {AuthorizedOperator} event. * * Requirements * * - `operator` cannot be calling address. */ function authorizeOperator(address operator) external; /** * @dev Make an account an operator of the caller. * * See {isOperatorFor} and {defaultOperators}. * * Emits a {RevokedOperator} event. * * Requirements * * - `operator` cannot be calling address. */ function revokeOperator(address operator) external; /** * @dev Returns the list of default operators. These accounts are operators * for all token holders, even if {authorizeOperator} was never called on * them. * * This list is immutable, but individual holders may revoke these via * {revokeOperator}, in which case {isOperatorFor} will return false. */ function defaultOperators() external view returns (address[] memory); /** * @dev Moves `amount` tokens from `sender` to `recipient`. The caller must * be an operator of `sender`. * * If send or receive hooks are registered for `sender` and `recipient`, * the corresponding functions will be called with `data` and * `operatorData`. See {IERC777Sender} and {IERC777Recipient}. * * Emits a {Sent} event. * * Requirements * * - `sender` cannot be the zero address. * - `sender` must have at least `amount` tokens. * - the caller must be an operator for `sender`. * - `recipient` cannot be the zero address. * - if `recipient` is a contract, it must implement the {IERC777Recipient} * interface. */ function operatorSend( address sender, address recipient, uint256 amount, bytes calldata data, bytes calldata operatorData ) external; /** * @dev Destoys `amount` tokens from `account`, reducing the total supply. * The caller must be an operator of `account`. * * If a send hook is registered for `account`, the corresponding function * will be called with `data` and `operatorData`. See {IERC777Sender}. * * Emits a {Burned} event. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. * - the caller must be an operator for `account`. */ function operatorBurn( address account, uint256 amount, bytes calldata data, bytes calldata operatorData ) external; event Sent( address indexed operator, address indexed from, address indexed to, uint256 amount, bytes data, bytes operatorData ); event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData); event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData); event AuthorizedOperator(address indexed operator, address indexed tokenHolder); event RevokedOperator(address indexed operator, address indexed tokenHolder); }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol"; import "./IGateway.sol"; /// @notice GatewayRegistry is a mapping from assets to their associated /// RenERC20 and Gateway contracts. interface IGatewayRegistry { /// @dev The symbol is included twice because strings have to be hashed /// first in order to be used as a log index/topic. event LogGatewayRegistered( string _symbol, string indexed _indexedSymbol, address indexed _tokenAddress, address indexed _gatewayAddress ); event LogGatewayDeregistered( string _symbol, string indexed _indexedSymbol, address indexed _tokenAddress, address indexed _gatewayAddress ); event LogGatewayUpdated( address indexed _tokenAddress, address indexed _currentGatewayAddress, address indexed _newGatewayAddress ); /// @dev To get all the registered gateways use count = 0. function getGateways(address _start, uint256 _count) external view returns (address[] memory); /// @dev To get all the registered RenERC20s use count = 0. function getRenTokens(address _start, uint256 _count) external view returns (address[] memory); /// @notice Returns the Gateway contract for the given RenERC20 /// address. /// /// @param _tokenAddress The address of the RenERC20 contract. function getGatewayByToken(address _tokenAddress) external view returns (IGateway); /// @notice Returns the Gateway contract for the given RenERC20 /// symbol. /// /// @param _tokenSymbol The symbol of the RenERC20 contract. function getGatewayBySymbol(string calldata _tokenSymbol) external view returns (IGateway); /// @notice Returns the RenERC20 address for the given token symbol. /// /// @param _tokenSymbol The symbol of the RenERC20 contract to /// lookup. function getTokenBySymbol(string calldata _tokenSymbol) external view returns (IERC20); }
// SPDX-License-Identifier: MIT pragma solidity ^0.5.17; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle( address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value ); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll( address indexed account, address indexed operator, bool approved ); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.5.17; /** * _Available since v3.1._ */ interface IERC1155Receiver { /** @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector). @param operator The address which initiated the transfer (i.e. msg.sender) @param from The address which previously owned the token @param id The ID of the token being transferred @param value The amount of tokens being transferred @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector). @param operator The address which initiated the batch transfer (i.e. msg.sender) @param from The address which previously owned the token @param ids An array containing ids of each token being transferred (order and length must match values array) @param values An array containing amounts of each token being transferred (order and length must match ids array) @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
pragma solidity ^0.5.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/GSN/GSNRecipient.sol"; import "../interfaces/IGateway.sol"; import "../interfaces/IGatewayRegistry.sol"; contract BasicAdapter is GSNRecipient { IGatewayRegistry registry; constructor(IGatewayRegistry _registry) public { GSNRecipient.initialize(); registry = _registry; } function mint( // Payload string calldata _symbol, address _recipient, // Required uint256 _amount, bytes32 _nHash, bytes calldata _sig ) external { bytes32 payloadHash = keccak256(abi.encode(_symbol, _recipient)); uint256 amount = registry.getGatewayBySymbol(_symbol).mint( payloadHash, _amount, _nHash, _sig ); registry.getTokenBySymbol(_symbol).transfer(_recipient, amount); } function burn( string calldata _symbol, bytes calldata _to, uint256 _amount ) external { require( registry.getTokenBySymbol(_symbol).transferFrom( _msgSender(), address(this), _amount ), "token transfer failed" ); registry.getGatewayBySymbol(_symbol).burn(_to, _amount); } // GSN functions function acceptRelayedCall( address relay, address from, bytes calldata encodedFunction, uint256 transactionFee, uint256 gasPrice, uint256 gasLimit, uint256 nonce, bytes calldata approvalData, uint256 maxPossibleCharge ) external view returns (uint256, bytes memory) { return _approveRelayedCall(); } // We won't do any pre or post processing, so leave _preRelayedCall and _postRelayedCall empty function _preRelayedCall(bytes memory context) internal returns (bytes32) {} function _postRelayedCall( bytes memory context, bool, uint256 actualCharge, bytes32 ) internal {} }
pragma solidity ^0.5.17; import "@openzeppelin/contracts-ethereum-package/contracts/token/ERC20/IERC20.sol"; import "./GenericAdapter.sol"; interface UniswapRouter { function WETH() external returns (address); function swapExactTokensForETH( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external returns (uint256[] memory amounts); } contract CallAndRefund { GenericAdapter public genericAdapter; UniswapRouter public uniswapRouter; IGatewayRegistry public registry; constructor( IGatewayRegistry _registry, GenericAdapter _genericAdapter, UniswapRouter _uniswapRouter ) public { registry = _registry; genericAdapter = _genericAdapter; uniswapRouter = _uniswapRouter; } modifier withGasRefund() { uint256 remainingGasStart = gasleft(); _; uint256 ethBalance = address(this).balance; uint256 remainingGasEnd = gasleft(); uint256 usedGas = remainingGasStart - remainingGasEnd; // Add intrinsic gas and transfer gas. Need to account for gas stipend as well. usedGas += 21000 + 9700; // Possibly need to check max gasprice and usedGas here to limit possibility for abuse. uint256 gasCost = usedGas * tx.gasprice; require(ethBalance >= gasCost, "GaslessWithUniswap: gas exceeds fee"); // Refund gas cost msg.sender.transfer(ethBalance); } // Allow this contract to receive ETH. function receive() external payable {} function convertAllToEth(IERC20 token) public payable { address[] memory path = new address[](2); path[0] = address(token); path[1] = uniswapRouter.WETH(); uint256 tokenBalance = token.balanceOf(address(this)); token.approve(address(uniswapRouter), tokenBalance); uniswapRouter.swapExactTokensForETH( tokenBalance, 0, path, address(this), block.timestamp ); } function callAndRefund( IERC20 _token, address _contract, bytes calldata _contractParams ) external withGasRefund { arbitraryCall(_contract, _contractParams); convertAllToEth(_token); } function arbitraryCall(address _contract, bytes memory _contractParams) internal { (bool success, bytes memory result) = _contract.call(_contractParams); if (!success) { // Check if the call result was too short to be a revert reason. if (result.length < 68) { revert( "GenericAdapter: contract call failed without revert reason" ); } // Return the call's revert reason. assembly { let ptr := mload(0x40) let size := returndatasize returndatacopy(ptr, 0, size) revert(ptr, size) } } } }
pragma solidity ^0.5.17; import "../Governance/Claimable.sol"; contract Claimer { Claimable child; constructor(Claimable _child) public { child = _child; } function transferStoreOwnership(address _newOwner) external { child.transferOwnership(_newOwner); } function claimStoreOwnership() external { child.claimOwnership(); } function claimTokenOwnership() public { child.claimOwnership(); } function transferTokenOwnership(address _newOwner) public { child.transferOwnership(address(_newOwner)); } }
pragma solidity ^0.5.17; import {String} from "../libraries/String.sol"; /// @dev StringTest exposes the internal functions of String.sol. contract StringTest { function fromUint(uint256 _i) public pure returns (string memory) { return String.fromUint(_i); } function fromBytes32(bytes32 _value) public pure returns (string memory) { return String.fromBytes32(_value); } function fromAddress(address _addr) public pure returns (string memory) { return String.fromAddress(_addr); } function add4( string memory a, string memory b, string memory c, string memory d ) public pure returns (string memory) { return String.add8(a, b, c, d, "", "", "", ""); } }
pragma solidity ^0.5.17; import "../libraries/LinkedList.sol"; /// @notice A token that exposes the LinkedList library for testing. contract LinkedListTest { using LinkedList for LinkedList.List; LinkedList.List private ll; function isInList(address node) public view returns (bool) { return ll.isInList(node); } function next(address node) public view returns (address) { return ll.next(node); } function previous(address node) public view returns (address) { return ll.previous(node); } function begin() public view returns (address) { return ll.begin(); } function end() public view returns (address) { return ll.end(); } function insertBefore(address target, address newNode) public { ll.insertBefore(target, newNode); } function insertAfter(address target, address newNode) public { ll.insertAfter(target, newNode); } function remove(address node) public { ll.remove(node); } function prepend(address newNode) public { ll.prepend(newNode); } function append(address newNode) public { ll.append(newNode); } function swap(address node1, address node2) public { ll.swap(node1, node2); } function elements(address _start, uint256 _count) public view returns (address[] memory) { return ll.elements(_start, _count); } }
pragma solidity ^0.5.17; contract Migrations { address public owner; uint256 public last_completed_migration; modifier restricted() { if (msg.sender == owner) { _; } } constructor() public { owner = msg.sender; } function setCompleted(uint256 completed) public restricted { last_completed_migration = completed; } function upgrade(address new_address) public restricted { Migrations upgraded = Migrations(new_address); upgraded.setCompleted(last_completed_migration); } }
pragma solidity ^0.5.17; contract ForceSend { function send(address payable recipient) public payable { selfdestruct(recipient); } }
{ "optimizer": { "enabled": false, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"payable":true,"stateMutability":"payable","type":"fallback"},{"constant":false,"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"initialize","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"payable":true,"stateMutability":"payable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604052600436106100705760003560e01c80638f2839701161004e5780638f283970146101bb578063cf7a1d771461020c578063d1f5789414610307578063f851a440146103e257610070565b80633659cfe61461007a5780634f1ef286146100cb5780635c60da1b14610164575b610078610439565b005b34801561008657600080fd5b506100c96004803603602081101561009d57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610453565b005b610162600480360360408110156100e157600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019064010000000081111561011e57600080fd5b82018360208201111561013057600080fd5b8035906020019184600183028401116401000000008311171561015257600080fd5b90919293919293905050506104a8565b005b34801561017057600080fd5b5061017961057e565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b3480156101c757600080fd5b5061020a600480360360208110156101de57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291905050506105d6565b005b6103056004803603606081101561022257600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019064010000000081111561027f57600080fd5b82018360208201111561029157600080fd5b803590602001918460018302840111640100000000831117156102b357600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f82011690508083019250505050505050919291929050505061074f565b005b6103e06004803603604081101561031d57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff1690602001909291908035906020019064010000000081111561035a57600080fd5b82018360208201111561036c57600080fd5b8035906020019184600183028401116401000000008311171561038e57600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600081840152601f19601f820116905080830192505050505050509192919290505050610811565b005b3480156103ee57600080fd5b506103f7610994565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6104416109ec565b61045161044c610a82565b610ab3565b565b61045b610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561049c5761049781610b0a565b6104a5565b6104a4610439565b5b50565b6104b0610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610570576104ec83610b0a565b60008373ffffffffffffffffffffffffffffffffffffffff168383604051808383808284378083019250505092505050600060405180830381855af49150503d8060008114610557576040519150601f19603f3d011682016040523d82523d6000602084013e61055c565b606091505b505090508061056a57600080fd5b50610579565b610578610439565b5b505050565b6000610588610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156105ca576105c3610a82565b90506105d3565b6105d2610439565b5b90565b6105de610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561074357600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415610697576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526036815260200180610c5d6036913960400191505060405180910390fd5b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6106c0610ad9565b82604051808373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019250505060405180910390a161073e81610b59565b61074c565b61074b610439565b5b50565b600073ffffffffffffffffffffffffffffffffffffffff1661076f610a82565b73ffffffffffffffffffffffffffffffffffffffff161461078f57600080fd5b6107998382610811565b600160405180807f656970313936372e70726f78792e61646d696e000000000000000000000000008152506013019050604051809103902060001c0360001b7fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610360001b1461080357fe5b61080c82610b59565b505050565b600073ffffffffffffffffffffffffffffffffffffffff16610831610a82565b73ffffffffffffffffffffffffffffffffffffffff161461085157600080fd5b600160405180807f656970313936372e70726f78792e696d706c656d656e746174696f6e00000000815250601c019050604051809103902060001c0360001b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b146108bb57fe5b6108c482610b88565b6000815111156109905760008273ffffffffffffffffffffffffffffffffffffffff16826040518082805190602001908083835b6020831061091b57805182526020820191506020810190506020830392506108f8565b6001836020036101000a038019825116818451168082178552505050505050905001915050600060405180830381855af49150503d806000811461097b576040519150601f19603f3d011682016040523d82523d6000602084013e610980565b606091505b505090508061098e57600080fd5b505b5050565b600061099e610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156109e0576109d9610ad9565b90506109e9565b6109e8610439565b5b90565b6109f4610ad9565b73ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610a78576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526032815260200180610c2b6032913960400191505060405180910390fd5b610a80610c15565b565b6000807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b9050805491505090565b3660008037600080366000845af43d6000803e8060008114610ad4573d6000f35b3d6000fd5b6000807fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610360001b9050805491505090565b610b1381610b88565b8073ffffffffffffffffffffffffffffffffffffffff167fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b60405160405180910390a250565b60007fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d610360001b90508181555050565b610b9181610c17565b610be6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252603b815260200180610c93603b913960400191505060405180910390fd5b60007f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc60001b90508181555050565b565b600080823b90506000811191505091905056fe43616e6e6f742063616c6c2066616c6c6261636b2066756e6374696f6e2066726f6d207468652070726f78792061646d696e43616e6e6f74206368616e6765207468652061646d696e206f6620612070726f787920746f20746865207a65726f206164647265737343616e6e6f742073657420612070726f787920696d706c656d656e746174696f6e20746f2061206e6f6e2d636f6e74726163742061646472657373a265627a7a72315820dfb0a1c3182334ba263d38c7fef1b99cf154a8ca5b35b3189bef1a40dd03b7c664736f6c63430005110032
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.