EVM Gas: 7500 Gwei
EVM Smart Contract
Root Balance
Contract
Contract Source Code Verified (Exact Match)
Source code verification does not imply that the contract is safe to interact with.
Contract NameWyvernStatic
Compiler Version0.7.5+commit.eb77ed08
Optimization EnabledDisabled
Other Settingsdefault evmVersion
File 1 of 19 - WyvernStatic.sol
/*
<< Wyvern Static >>
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "./static/StaticERC20.sol";
import "./static/StaticERC721.sol";
import "./static/StaticUtil.sol";
/**
* @title WyvernStatic
* @author Wyvern Protocol Developers
*/
contract WyvernStatic is StaticERC20, StaticERC721, StaticUtil {
string public constant name = "Wyvern Static";
constructor(address atomicizerAddress) public {
atomicizer = atomicizerAddress;
}
function test() public pure {}
}
File 2 of 19 - ArrayUtils.sol
/*
<< ArrayUtils >>
Various functions for manipulating arrays in Solidity.
This library is completely inlined and does not need to be deployed or linked.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
/**
* @title ArrayUtils
* @author Wyvern Protocol Developers
*/
library ArrayUtils {
/**
* Replace bytes in an array with bytes in another array, guarded by a bitmask
* Efficiency of this function is a bit unpredictable because of the EVM's word-specific model (arrays under 32 bytes will be slower)
* Modifies the provided byte array parameter in place
*
* @dev Mask must be the size of the byte array. A nonzero byte means the byte array can be changed.
* @param array The original array
* @param desired The target array
* @param mask The mask specifying which bits can be changed
*/
function guardedArrayReplace(
bytes memory array,
bytes memory desired,
bytes memory mask
File 3 of 19 - StaticCaller.sol
/*
<< Static Caller >>
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
/**
* @title StaticCaller
* @author Wyvern Protocol Developers
*/
contract StaticCaller {
function staticCall(address target, bytes memory data)
internal
view
returns (bool result)
{
assembly {
// https://ethereum.stackexchange.com/questions/101436/understanding-parameters-of-the-staticcall-opcode-in-solidity-inline-assembly
// readonly external calls
// staticcall(g, a, in, insize, out, outsize)
result := staticcall(
gas(),
target,
add(data, 0x20),
mload(data),
mload(0x40),
0
)
}
return result;
File 4 of 19 - StaticUtil.sol
/*
StaticUtil - static call utility contract
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "../lib/StaticCaller.sol";
import "../lib/ArrayUtils.sol";
import "../registry/AuthenticatedProxy.sol";
contract StaticUtil is StaticCaller {
address public atomicizer;
function any(
bytes memory,
address[7] memory,
AuthenticatedProxy.HowToCall[2] memory,
uint256[6] memory,
bytes memory,
bytes memory
) public pure returns (uint256) {
/*
Accept any call.
Useful e.g. for matching-by-transaction, where you authorize the counter-call by sending the transaction and don't need to re-check it.
Return fill "1".
*/
return 1;
}
// function anySingle(bytes memory, address[7] memory, AuthenticatedProxy.HowToCall, uint[6] memory, bytes memory)
File 5 of 19 - StaticERC20.sol
/*
StaticERC20 - static calls for ERC20 trades
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../lib/ArrayUtils.sol";
import "../registry/AuthenticatedProxy.sol";
contract StaticERC20 {
function transferERC20Exact(
bytes memory extra,
address[7] memory addresses,
AuthenticatedProxy.HowToCall howToCall,
uint256[6] memory,
bytes memory data
) public pure {
// Decode extradata
(address token, uint256 amount) = abi.decode(extra, (address, uint256));
// Call target = token to give
require(addresses[2] == token);
// Call type = call
require(howToCall == AuthenticatedProxy.HowToCall.Call);
// Assert calldata
require(
ArrayUtils.arrayEq(
data,
abi.encodeWithSignature(
File 6 of 19 - StaticERC721.sol
/*
StaticERC721 - static calls for ERC721 trades
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "openzeppelin-solidity/contracts/math/SafeMath.sol";
import "../lib/ArrayUtils.sol";
import "../registry/AuthenticatedProxy.sol";
contract StaticERC721 {
function transferERC721Exact(
bytes memory extra,
address[7] memory addresses,
AuthenticatedProxy.HowToCall howToCall,
uint256[6] memory,
bytes memory data
) public pure {
// Decode extradata
(address token, uint256 tokenId) = abi.decode(
extra,
(address, uint256)
);
// Call target = token to give
require(addresses[2] == token);
// Call type = call
require(howToCall == AuthenticatedProxy.HowToCall.Call);
// Assert calldata
require(
File 7 of 19 - Proxy.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
/**
* @title Proxy
* @dev Gives the possibility to delegate any call to a foreign implementation.
*/
abstract contract Proxy {
/**
* @dev Tells the address of the implementation where every call will be delegated.
* @return address of the implementation to which it will be delegated
*/
function implementation() public view virtual returns (address);
/**
* @dev Tells the type of proxy (EIP 897)
* @return proxyTypeId Type of proxy, 2 for upgradeable proxy
*/
function proxyType() public pure virtual returns (uint256 proxyTypeId);
/**
* @dev Fallback function allowing to perform a delegatecall to the given implementation.
* This function will return whatever the implementation call returns
*/
fallback() external payable {
address _impl = implementation();
require(_impl != address(0), "Proxy implementation required");
assembly {
let ptr := mload(0x40)
calldatacopy(ptr, 0, calldatasize())
let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0)
let size := returndatasize()
File 8 of 19 - ProxyRegistry.sol
/*
Proxy registry; keeps a mapping of AuthenticatedProxy contracts and mapping of contracts authorized to access them.
Abstracted away from the Exchange (a) to reduce Exchange attack surface and (b) so that the Exchange contract can be upgraded without users needing to transfer assets to new proxies.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "openzeppelin-solidity/contracts/access/Ownable.sol";
import "./OwnableDelegateProxy.sol";
import "./ProxyRegistryInterface.sol";
/**
* @title ProxyRegistry
* @author Wyvern Protocol Developers
*/
contract ProxyRegistry is Ownable, ProxyRegistryInterface {
/* DelegateProxy implementation contract. Must be initialized. */
address public override delegateProxyImplementation;
/* Authenticated proxies by user. */
mapping(address => OwnableDelegateProxy) public override proxies;
/* Contracts pending access. */
mapping(address => uint256) public pending;
/* Contracts allowed to call those proxies. */
mapping(address => bool) public contracts;
File 9 of 19 - TokenRecipient.sol
/*
Token recipient. Modified very slightly from the example on http://ethereum.org/dao (just to index log parameters).
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "openzeppelin-solidity/contracts/token/ERC20/ERC20.sol";
/**
* @title TokenRecipient
* @author Wyvern Protocol Developers
*/
contract TokenRecipient {
event ReceivedEther(address indexed sender, uint256 amount);
event ReceivedTokens(
address indexed from,
uint256 value,
address indexed token,
bytes extraData
);
/**
* @dev Receive tokens and generate a log event
* @param from Address from which to transfer tokens
* @param value Amount of tokens to transfer
* @param token Address of token
* @param extraData Additional data to log
*/
function receiveApproval(
address from,
File 10 of 19 - AuthenticatedProxy.sol
/*
Proxy contract to hold access to assets on behalf of a user (e.g. ERC20 approve) and execute calls under particular conditions.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "./ProxyRegistry.sol";
import "./TokenRecipient.sol";
import "./proxy/OwnedUpgradeabilityStorage.sol";
/**
* @title AuthenticatedProxy
* @author Wyvern Protocol Developers
*/
contract AuthenticatedProxy is TokenRecipient, OwnedUpgradeabilityStorage {
/* Whether initialized. */
bool initialized = false;
/* Address which owns this proxy. */
address public user;
/* Associated registry with contract authentication information. */
ProxyRegistry public registry;
/* Whether access has been revoked. */
bool public revoked;
/* Delegate call could be used to atomically transfer multiple assets owned by the proxy contract with one order. */
enum HowToCall {
Call,
File 11 of 19 - OwnableDelegateProxy.sol
/*
OwnableDelegateProxy
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "./proxy/OwnedUpgradeabilityProxy.sol";
/**
* @title OwnableDelegateProxy
* @author Wyvern Protocol Developers
*/
contract OwnableDelegateProxy is OwnedUpgradeabilityProxy {
constructor(
address owner,
address initialImplementation,
bytes memory data
) public {
setUpgradeabilityOwner(owner);
_upgradeTo(initialImplementation);
(bool success, ) = initialImplementation.delegatecall(data);
require(success, "OwnableDelegateProxy failed implementation");
}
}
File 12 of 19 - ProxyRegistryInterface.sol
/*
Proxy registry interface.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "./OwnableDelegateProxy.sol";
/**
* @title ProxyRegistryInterface
* @author Wyvern Protocol Developers
*/
interface ProxyRegistryInterface {
function delegateProxyImplementation() external returns (address);
function proxies(address owner) external returns (OwnableDelegateProxy);
}
File 13 of 19 - SafeMath.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
*
* _Available since v3.4._
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
File 14 of 19 - Context.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/*
* @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.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
}
}
File 15 of 19 - Ownable.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../utils/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.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
/**
* @dev Returns the address of the current owner.
File 16 of 19 - OwnedUpgradeabilityProxy.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
import "./Proxy.sol";
import "./OwnedUpgradeabilityStorage.sol";
/**
* @title OwnedUpgradeabilityProxy
* @dev This contract combines an upgradeability proxy with basic authorization control functionalities
*/
contract OwnedUpgradeabilityProxy is Proxy, OwnedUpgradeabilityStorage {
/**
* @dev Event to show ownership has been transferred
* @param previousOwner representing the address of the previous owner
* @param newOwner representing the address of the new owner
*/
event ProxyOwnershipTransferred(address previousOwner, address newOwner);
/**
* @dev This event will be emitted every time the implementation gets upgraded
* @param implementation representing the address of the upgraded implementation
*/
event Upgraded(address indexed implementation);
/**
* @dev Tells the address of the current implementation
* @return address of the current implementation
*/
function implementation() public view override returns (address) {
return _implementation;
}
/**
File 17 of 19 - ERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
import "../../utils/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 {ERC20PresetMinterPauser}.
*
* 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 Context, IERC20 {
File 18 of 19 - IERC20.sol
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
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.
File 19 of 19 - OwnedUpgradeabilityStorage.sol
// SPDX-License-Identifier: MIT
pragma solidity 0.7.5;
/**
* @title OwnedUpgradeabilityStorage
* @dev This contract keeps track of the upgradeability owner
*/
contract OwnedUpgradeabilityStorage {
// Current implementation
address internal _implementation;
// Owner of the contract
address private _upgradeabilityOwner;
/**
* @dev Tells the address of the owner
* @return the address of the owner
*/
function upgradeabilityOwner() public view returns (address) {
return _upgradeabilityOwner;
}
/**
* @dev Sets the address of the owner
*/
function setUpgradeabilityOwner(address newUpgradeabilityOwner) internal {
_upgradeabilityOwner = newUpgradeabilityOwner;
}
}
ABI
[
{
"inputs": [
{
"internalType": "address",
"name": "atomicizerAddress",
"type": "address"
}
],
"stateMutability": "nonpayable",
"type": "constructor"
},
{
"inputs": [
{
"internalType": "bytes",
"name": "extra",
"type": "bytes"
},
{
"internalType": "address[7]",
"name": "addresses",
"type": "address[7]"
},
{
"internalType": "enum AuthenticatedProxy.HowToCall[2]",
"name": "howToCalls",
"type": "uint8[2]"
},
{
"internalType": "uint256[6]",
"name": "uints",
"type": "uint256[6]"
Rootscan is a Block Explorer tailored for The Root Network, an innovative decentralized network.
Privacy Policy