Contract Overview
My Name Tag:
Not Available, login to update
Txn Hash |
Method
|
Block
|
From
|
To
|
Value | [Txn Fee] | |||
---|---|---|---|---|---|---|---|---|---|
0x49ee0c0f76757dbae4d0c0d6efa27d5251d0f7bc0d86c54a1e36d3028b8800ed | 0x60806040 | 16875069 | 565 days 18 hrs ago | 0xb0dd96118594903bacb2746eb228550c10b2b1da | IN | Create: MemoryLogic | 0 MATIC | 0.000298665029 |
[ Download CSV Export ]
Contract Name:
MemoryLogic
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ 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) { unchecked { 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._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @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) { return a + b; } /** * @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 a - b; } /** * @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) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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 a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards 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). * * 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, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * 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, string memory errorMessage) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } }
//SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IMemory { function getUint(uint256) external view returns (uint256); function setUint(uint256 id, uint256 value) external; function getAToken(address asset) external view returns (address); function setAToken(address asset, address _aToken) external; function getCrToken(address asset) external view returns (address); function setCrToken(address asset, address _crToken) external; }
//SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @title RegistryInterface Interface */ interface IRegistry { function logic(address logicAddr) external view returns (bool); function implementation(bytes32 key) external view returns (address); function notAllowed(address erc20) external view returns (bool); function deployWallet() external returns (address); function wallets(address user) external view returns (address); function getFee() external view returns (uint256); function feeRecipient() external view returns (address); function memoryAddr() external view returns (address); function distributionContract(address token) external view returns (address); }
//SPDX-License-Identifier: MIT pragma solidity ^0.8.0; interface IWallet { event LogMint(address indexed erc20, uint256 tokenAmt); event LogRedeem(address indexed erc20, uint256 tokenAmt); event LogBorrow(address indexed erc20, uint256 tokenAmt); event LogPayback(address indexed erc20, uint256 tokenAmt); event LogDeposit(address indexed erc20, uint256 tokenAmt); event LogWithdraw(address indexed erc20, uint256 tokenAmt); event LogSwap(address indexed src, address indexed dest, uint256 amount); event LogLiquidityAdd( address indexed tokenA, address indexed tokenB, uint256 amountA, uint256 amountB ); event LogLiquidityRemove( address indexed tokenA, address indexed tokenB, uint256 amountA, uint256 amountB ); event VaultDeposit(address indexed erc20, uint256 tokenAmt); event VaultWithdraw(address indexed erc20, uint256 tokenAmt); event VaultClaim(address indexed erc20, uint256 tokenAmt); event DelegateAdded(address delegate); event DelegateRemoved(address delegate); function executeMetaTransaction(bytes memory sign, bytes memory data) external; function execute(address[] calldata targets, bytes[] calldata datas) external payable; function owner() external view returns (address); function registry() external view returns (address); function DELEGATE_ROLE() external view returns (bytes32); function hasRole(bytes32, address) external view returns (bool); }
//SPDX-License-Identifier: MIT pragma solidity 0.8.4; import "../interfaces/IMemory.sol"; import "../interfaces/IRegistry.sol"; import "../interfaces/IWallet.sol"; contract Helpers { /** * @dev Return Memory Variable Address */ function getMemoryAddr() public view returns (address) { return IRegistry(IWallet(address(this)).registry()).memoryAddr(); } /** * @dev Get Uint value from Memory Contract. */ function getUint(uint256 id) internal view returns (uint256) { return IMemory(getMemoryAddr()).getUint(id); } /** * @dev Set Uint value in Memory Contract. */ function setUint(uint256 id, uint256 val) internal { IMemory(getMemoryAddr()).setUint(id, val); } /** * @dev Get aToken address from Memory Contract. */ function getAToken(address asset) internal view returns (address) { return IMemory(getMemoryAddr()).getAToken(asset); } /** * @dev Get crToken address from Memory Contract. */ function getCrToken(address asset) internal view returns (address) { return IMemory(getMemoryAddr()).getCrToken(asset); } }
//SPDX-License-Identifier: MIT pragma solidity 0.8.4; import "./Helpers.sol"; import "@openzeppelin/contracts/utils/math/SafeMath.sol"; /** * @title Perform arithmetic actions over stored memory values */ contract MemoryLogic is Helpers { using SafeMath for uint256; /** * @dev get vault distribution factory address */ function addValues(uint256[] memory ids, uint256 initialVal) external payable { uint256 total = initialVal; for (uint256 i = 0; i < ids.length; i++) { total = total.add(getUint(ids[i])); } setUint(1, total); // store in first position } }
{ "evmVersion": "istanbul", "libraries": {}, "metadata": { "bytecodeHash": "ipfs", "useLiteralContent": true }, "optimizer": { "enabled": true, "runs": 200 }, "remappings": [], "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256","name":"initialVal","type":"uint256"}],"name":"addValues","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"getMemoryAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Age | Block | Fee Address | BC Fee Address | Voting Power | Jailed | Incoming |
---|
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.