Datasets:

Zellic
/

smart-contract-fiesta

	{
	"language": "Solidity",
	"settings": {
	"evmVersion": "london",
	"libraries": {},
	"metadata": {
	"bytecodeHash": "ipfs",
	"useLiteralContent": true
	},
	"optimizer": {
	"enabled": true,
	"runs": 200
	},
	"remappings": [],
	"outputSelection": {
	"*": {
	"*": [
	"evm.bytecode",
	"evm.deployedBytecode",
	"devdoc",
	"userdoc",
	"metadata",
	"abi"
	]
	}
	}
	},
	"sources": {
	"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/*\n @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n \n The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n \n For example:\n \n [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n * function initialize() initializer public {\n * __ERC20_init(\"MyToken\", \"MTK\");\n * }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n * function initializeV2() reinitializer(2) public {\n * __ERC20Permit_init(\"MyToken\");\n * }\n * }\n * ```\n \n TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n \n CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n \n [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n \n An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n \n [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n * _disableInitializers();\n * }\n * ```\n * ====\n /\nabstract contract Initializable {\n /\n @dev Indicates that the contract has been initialized.\n * @custom:oz-retyped-from bool\n /\n uint8 private _initialized;\n\n /\n @dev Indicates that the contract is in the process of being initialized.\n /\n bool private _initializing;\n\n /\n @dev Triggered when the contract has been initialized or reinitialized.\n /\n event Initialized(uint8 version);\n\n /\n @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\n /\n modifier initializer() {\n bool isTopLevelCall = !_initializing;\n require(\n (isTopLevelCall && _initialized < 1) \|\| (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n \"Initializable: contract is already initialized\"\n );\n _initialized = 1;\n if (isTopLevelCall) {\n _initializing = true;\n }\n _;\n if (isTopLevelCall) {\n _initializing = false;\n emit Initialized(1);\n }\n }\n\n /\n @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n * used to initialize parent contracts.\n \n `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\n * initialization step. This is essential to configure modules that are added through upgrades and that require\n * initialization.\n \n Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n * a contract, executing them in the right order is up to the developer or operator.\n /\n modifier reinitializer(uint8 version) {\n require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n _initialized = version;\n _initializing = true;\n _;\n _initializing = false;\n emit Initialized(version);\n }\n\n /\n @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\n /\n modifier onlyInitializing() {\n require(_initializing, \"Initializable: contract is not initializing\");\n _;\n }\n\n /\n @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n * through proxies.\n */\n function _disableInitializers() internal virtual {\n require(!_initializing, \"Initializable: contract is initializing\");\n if (_initialized < type(uint8).max) {\n _initialized = type(uint8).max;\n emit Initialized(type(uint8).max);\n }\n }\n}\n"
	},
	"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/*\n @dev Collection of functions related to the address type\n /\nlibrary AddressUpgradeable {\n /\n @dev Returns true if `account` is a contract.\n \n [IMPORTANT]\n * ====\n * It is unsafe to assume that an address for which this function returns\n * false is an externally-owned account (EOA) and not a contract.\n \n Among others, `isContract` will return false for the following\n * types of addresses:\n \n - an externally-owned account\n * - a contract in construction\n * - an address where a contract will be created\n * - an address where a contract lived, but was destroyed\n * ====\n \n [IMPORTANT]\n * ====\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\n \n Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n * constructor.\n * ====\n /\n function isContract(address account) internal view returns (bool) {\n // This method relies on extcodesize/address.code.length, which returns 0\n // for contracts in construction, since the code is only stored at the end\n // of the constructor execution.\n\n return account.code.length > 0;\n }\n\n /\n @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n * `recipient`, forwarding all available gas and reverting on errors.\n \n https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\n * imposed by `transfer`, making them unable to receive funds via\n * `transfer`. {sendValue} removes this limitation.\n \n https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n \n IMPORTANT: because control is transferred to `recipient`, care must be\n * taken to not create reentrancy vulnerabilities. Consider using\n * {ReentrancyGuard} or the\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n /\n function sendValue(address payable recipient, uint256 amount) internal {\n require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n (bool success, ) = recipient.call{value: amount}(\"\");\n require(success, \"Address: unable to send value, recipient may have reverted\");\n }\n\n /\n @dev Performs a Solidity function call using a low level `call`. A\n * plain `call` is an unsafe replacement for a function call: use this\n * function instead.\n \n If `target` reverts with a revert reason, it is bubbled up by this\n * function (like regular Solidity function calls).\n \n Returns the raw returned data. To convert to the expected return value,\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n \n Requirements:\n \n - `target` must be a contract.\n * - calling `target` with `data` must not revert.\n \n _Available since v3.1._\n /\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n return functionCall(target, data, \"Address: low-level call failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n * `errorMessage` as a fallback revert reason when `target` reverts.\n \n _Available since v3.1._\n /\n function functionCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, 0, errorMessage);\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but also transferring `value` wei to `target`.\n \n Requirements:\n \n - the calling contract must have an ETH balance of at least `value`.\n * - the called Solidity function must be `payable`.\n \n _Available since v3.1._\n /\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value\n ) internal returns (bytes memory) {\n return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n * with `errorMessage` as a fallback revert reason when `target` reverts.\n \n _Available since v3.1._\n /\n function functionCallWithValue(\n address target,\n bytes memory data,\n uint256 value,\n string memory errorMessage\n ) internal returns (bytes memory) {\n require(address(this).balance >= value, \"Address: insufficient balance for call\");\n require(isContract(target), \"Address: call to non-contract\");\n\n (bool success, bytes memory returndata) = target.call{value: value}(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n * but performing a static call.\n \n _Available since v3.3._\n /\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n return functionStaticCall(target, data, \"Address: low-level static call failed\");\n }\n\n /\n @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n * but performing a static call.\n \n _Available since v3.3._\n /\n function functionStaticCall(\n address target,\n bytes memory data,\n string memory errorMessage\n ) internal view returns (bytes memory) {\n require(isContract(target), \"Address: static call to non-contract\");\n\n (bool success, bytes memory returndata) = target.staticcall(data);\n return verifyCallResult(success, returndata, errorMessage);\n }\n\n /\n @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n * revert reason using the provided one.\n \n _Available since v4.3._\n */\n function verifyCallResult(\n bool success,\n bytes memory returndata,\n string memory errorMessage\n ) internal pure returns (bytes memory) {\n if (success) {\n return returndata;\n } else {\n // Look for revert reason and bubble it up if present\n if (returndata.length > 0) {\n // The easiest way to bubble the revert reason is using memory via assembly\n /// @solidity memory-safe-assembly\n assembly {\n let returndata_size := mload(returndata)\n revert(add(32, returndata), returndata_size)\n }\n } else {\n revert(errorMessage);\n }\n }\n }\n}\n"
	},
	"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.0;\n\n/*\n @dev Interface of the ERC20 standard as defined in the EIP.\n /\ninterface IERC20 {\n /\n @dev Emitted when `value` tokens are moved from one account (`from`) to\n * another (`to`).\n \n Note that `value` may be zero.\n /\n event Transfer(address indexed from, address indexed to, uint256 value);\n\n /\n @dev Emitted when the allowance of a `spender` for an `owner` is set by\n * a call to {approve}. `value` is the new allowance.\n /\n event Approval(address indexed owner, address indexed spender, uint256 value);\n\n /\n @dev Returns the amount of tokens in existence.\n /\n function totalSupply() external view returns (uint256);\n\n /\n @dev Returns the amount of tokens owned by `account`.\n /\n function balanceOf(address account) external view returns (uint256);\n\n /\n @dev Moves `amount` tokens from the caller's account to `to`.\n \n Returns a boolean value indicating whether the operation succeeded.\n \n Emits a {Transfer} event.\n /\n function transfer(address to, uint256 amount) external returns (bool);\n\n /\n @dev Returns the remaining number of tokens that `spender` will be\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\n * zero by default.\n \n This value changes when {approve} or {transferFrom} are called.\n /\n function allowance(address owner, address spender) external view returns (uint256);\n\n /\n @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n \n Returns a boolean value indicating whether the operation succeeded.\n \n IMPORTANT: Beware that changing an allowance with this method brings the risk\n * that someone may use both the old and the new allowance by unfortunate\n * transaction ordering. One possible solution to mitigate this race\n * condition is to first reduce the spender's allowance to 0 and set the\n * desired value afterwards:\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n \n Emits an {Approval} event.\n /\n function approve(address spender, uint256 amount) external returns (bool);\n\n /\n @dev Moves `amount` tokens from `from` to `to` using the\n * allowance mechanism. `amount` is then deducted from the caller's\n * allowance.\n \n Returns a boolean value indicating whether the operation succeeded.\n \n Emits a {Transfer} event.\n */\n function transferFrom(\n address from,\n address to,\n uint256 amount\n ) external returns (bool);\n}\n"
	},
	"@openzeppelin/contracts/utils/Counters.sol": {
	"content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)\n\npragma solidity ^0.8.0;\n\n/*\n @title Counters\n * @author Matt Condon (@shrugs)\n * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number\n * of elements in a mapping, issuing ERC721 ids, or counting request ids.\n \n Include with `using Counters for Counters.Counter;`\n */\nlibrary Counters {\n struct Counter {\n // This variable should never be directly accessed by users of the library: interactions must be restricted to\n // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add\n // this feature: see https://github.com/ethereum/solidity/issues/4637\n uint256 _value; // default: 0\n }\n\n function current(Counter storage counter) internal view returns (uint256) {\n return counter._value;\n }\n\n function increment(Counter storage counter) internal {\n unchecked {\n counter._value += 1;\n }\n }\n\n function decrement(Counter storage counter) internal {\n uint256 value = counter._value;\n require(value > 0, \"Counter: decrement overflow\");\n unchecked {\n counter._value = value - 1;\n }\n }\n\n function reset(Counter storage counter) internal {\n counter._value = 0;\n }\n}\n"
	},
	"contracts/VestingERC20BudgetApproval.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity 0.8.7;\n\nimport \"./base/CommonBudgetApproval.sol\";\nimport \"./lib/BytesLib.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\n\nimport \"./interface/IBudgetApprovalExecutee.sol\";\n\ncontract VestingERC20BudgetApproval is CommonBudgetApproval {\n using BytesLib for bytes;\n\n string public constant override name = \"Vesting ERC20 Budget Approval\";\n\n event ExecuteVestingERC20Transaction(\n uint256 indexed id,\n address indexed executor,\n address indexed toAddress,\n address token,\n uint256 amount\n );\n\n // Terminology:\n //\n // \|<-- cycle 1 --> <-- cycle 2 --> <-- cycle 3 --> <-- cycle 4 -->\n // \|<------ cliff ------>\n // \|\n // \|<-- Init Token Amount\n // \|<-- Budget Start Time\n // \|<----------------------- (vesting period) -------------------->\n //\n // Total Period = Cycle Period * Cycle Count\n // Total Amount = Init Amount + Cycle Amount * Cycle Count\n\n // Token to be vested (should be ERC20)\n address public token;\n\n // The beneficial address\n address public toAddress;\n\n // Period of Cliff\n uint256 public cliffPeriod;\n\n // Period per cycle\n uint256 public cyclePeriod;\n\n // Number of periods\n uint256 public cycleCount;\n\n // Vesting Amount in each cycle\n uint256 public cycleTokenAmount;\n\n // Init Token Amount before Vesting\n uint256 public initTokenAmount;\n\n // Amount of tokens released\n uint256 private releasedTokenAmount;\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n\n function initialize(\n InitializeParams calldata params,\n address _token,\n address _toAddress,\n uint256 _cliffPeriod,\n uint256 _cyclePeriod,\n uint256 _cycleCount,\n uint256 _cycleTokenAmount,\n uint256 _initTokenAmount\n ) external initializer {\n __BudgetApproval_init(params);\n\n token = _token;\n toAddress = _toAddress;\n cliffPeriod = _cliffPeriod;\n cyclePeriod = _cyclePeriod;\n cycleCount = _cycleCount;\n cycleTokenAmount = _cycleTokenAmount;\n initTokenAmount = _initTokenAmount;\n releasedTokenAmount = 0;\n\n if (cycleCount > 0) {\n require(\n cycleTokenAmount > 0 && cyclePeriod > 0,\n \"Cycle token amount and Cycle period must be larager than 0\"\n );\n }\n\n require(\n cyclePeriod * cycleCount >= cliffPeriod,\n \"Vesting period must be long than Cliff Period\"\n );\n require(totalAmount() > 0, \"Vesting amount must be larger than 0\");\n }\n\n function executeParams() external pure override returns (string[] memory) {\n // TODO\n string[] memory arr = new string[](1);\n arr[0] = \"uint256 amount\";\n return arr;\n }\n\n function _execute(uint256 transactionId, bytes memory data)\n internal\n override\n {\n uint256 amount = abi.decode(data, (uint256));\n bytes memory executeData = abi.encodeWithSelector(\n IERC20.transfer.selector,\n toAddress,\n amount\n );\n uint256 _releasedTokenAmount = releasedTokenAmount;\n\n IBudgetApprovalExecutee(executee()).executeByBudgetApproval(\n token,\n executeData,\n 0\n );\n\n // Check if cliff period passed\n require(isCliffPassed(), \"Cliff Period not passed\");\n\n // Check current releasable amount\n require(\n amount <= currentReleasableAmount(),\n \"Exceeded current releasable token amount\"\n );\n\n releasedTokenAmount = _releasedTokenAmount + amount;\n\n emit ExecuteVestingERC20Transaction(\n transactionId,\n msg.sender,\n toAddress,\n token,\n amount\n );\n }\n\n /*\n @dev Returns the remaining token amount of the overall vesting\n /\n function remainingAmount() public view returns (uint256) {\n return totalAmount() - releasedAmount();\n }\n\n /\n @dev Returns the total amount of tokens that will be released over the entire vesting period.\n /\n function totalAmount() public view returns (uint256) {\n return initTokenAmount + cycleTokenAmount cycleCount;\n }\n\n /*\n @dev Returns the amount of tokens that has been released to the beneficial address.\n /\n function releasedAmount() public view returns (uint256) {\n return releasedTokenAmount;\n }\n\n /\n @dev Returns whether the cliff period has passed\n /\n function isCliffPassed() public view returns (bool) {\n return block.timestamp > startTime() + cliffPeriod;\n }\n\n /\n @dev Returns the current releasable token amount of the vesting\n /\n function currentReleasableAmount() public view returns (uint256) {\n if (!isCliffPassed()) {\n return 0;\n }\n\n if (cyclePeriod == 0) {\n return initTokenAmount - releasedTokenAmount;\n }\n\n uint256 cyclePassed = (block.timestamp - startTime()) / cyclePeriod;\n if (cyclePassed > cycleCount) {\n cyclePassed = cycleCount;\n }\n return\n initTokenAmount +\n cyclePassed \n cycleTokenAmount -\n releasedTokenAmount;\n }\n}\n"
	},
	"contracts/base/CommonBudgetApproval.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity 0.8.7;\n\nimport \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport \"@openzeppelin/contracts/utils/Counters.sol\";\n\nimport \"../lib/BytesLib.sol\";\n\nimport \"../interface/ITeam.sol\";\nimport \"../interface/IBudgetApprovalExecutee.sol\";\n\nabstract contract CommonBudgetApproval is Initializable {\n\n using Counters for Counters.Counter;\n using BytesLib for bytes;\n\n enum Status {\n Pending,\n Approved,\n Completed,\n Cancelled\n }\n\n struct Transaction {\n uint256 id;\n bytes[] data;\n Status status;\n uint32 deadline;\n bool isExist;\n uint256 approvedCount;\n mapping(address => bool) approved;\n }\n\n event CreateTransaction(\n uint256 indexed id,\n bytes[] data,\n uint256 deadline,\n Status status,\n string comment,\n address creator\n );\n event ApproveTransaction(\n uint256 indexed id,\n address approver,\n string comment\n );\n event ExecuteTransaction(\n uint256 indexed id,\n bytes[] data,\n address _executor\n );\n event RevokeTransaction(uint256 indexed id);\n event AllowAddress(address target);\n event AllowToken(address token);\n event AllowAmount(uint256 amount);\n event SetApprover(address approver);\n\n Counters.Counter private _transactionIds;\n\n mapping(uint256 => Transaction) public transactions;\n\n address private _executor;\n uint256 private _executorTeamId;\n address private _executee; // Must be BudgetApprovalExecutee\n\n mapping(address => bool) private _approversMapping;\n uint256 private _approverTeamId;\n uint256 private _minApproval;\n\n string private _text;\n string private _transactionType;\n\n bool private _allowUnlimitedUsageCount;\n uint256 private _usageCount;\n\n uint256 private _startTime;\n uint256 private _endTime;\n\n address private _team;\n\n struct InitializeParams {\n address executor;\n uint256 executorTeamId;\n address[] approvers;\n uint256 approverTeamId;\n uint256 minApproval;\n string text;\n string transactionType;\n uint256 startTime;\n uint256 endTime;\n bool allowUnlimitedUsageCount;\n uint256 usageCount;\n address team; // TODO: Get team from IBudgetApprovalExecutee\n }\n\n modifier onlyExecutee() {\n require(msg.sender == executee(), \"Executee not whitelisted in budget\");\n _;\n }\n\n modifier matchStatus(uint256 id, Status status) {\n require(\n transactions[id].status == status,\n \"Transaction status invalid\"\n );\n _;\n }\n\n modifier checkTime(uint256 id) {\n require(\n block.timestamp <= transactions[id].deadline,\n \"Transaction expired\"\n );\n require(\n block.timestamp >= startTime(),\n \"Budget usage period not started\"\n );\n\n uint256 __endtime = endTime();\n if (__endtime != 0) {\n require(\n block.timestamp < __endtime,\n \"Budget usage period has ended\"\n );\n }\n _;\n }\n\n modifier onlyApprover() {\n require(_isApprover(msg.sender), \"Approver not whitelisted in budget\");\n _;\n }\n\n modifier onlyExecutor() {\n require(_isExecutor(msg.sender), \"Executor not whitelisted in budget\");\n _;\n }\n\n /// @custom:oz-upgrades-unsafe-allow constructor\n constructor() {\n _disableInitializers();\n }\n\n function executor() public view returns (address) {\n return _executor;\n }\n\n function _isExecutor(address eoa) internal view virtual returns (bool) {\n return eoa == executor() \|\|\n ITeam(team()).balanceOf(eoa, executorTeamId()) > 0;\n }\n\n function _isApprover(address eoa) internal view virtual returns (bool) {\n return approversMapping(eoa) \|\|\n ITeam(team()).balanceOf(eoa, approverTeamId()) > 0;\n }\n\n function executorTeamId() public view returns (uint256) {\n return _executorTeamId;\n }\n\n function executee() public view returns (address) {\n return _executee;\n }\n\n function approversMapping(address eoa) public view returns (bool) {\n return _approversMapping[eoa];\n }\n\n function approverTeamId() public view returns (uint256) {\n return _approverTeamId;\n }\n\n function minApproval() public view returns (uint256) {\n return _minApproval;\n }\n\n function text() public view returns (string memory) {\n return _text;\n }\n\n function transactionType() public view returns (string memory) {\n return _transactionType;\n }\n\n function allowUnlimitedUsageCount() public view returns (bool) {\n return _allowUnlimitedUsageCount;\n }\n\n function usageCount() public view returns (uint256) {\n return _usageCount;\n }\n\n function startTime() public view returns (uint256) {\n return _startTime;\n }\n\n function endTime() public view returns (uint256) {\n return _endTime;\n }\n\n function team() public view returns (address) {\n return _team;\n }\n\n function __BudgetApproval_init(InitializeParams calldata params)\n internal\n onlyInitializing\n {\n require(\n params.approverTeamId > 0 \|\|\n (params.minApproval <= params.approvers.length),\n \"Invalid approver list\"\n );\n\n _executee = msg.sender;\n _executor = params.executor;\n _text = params.text;\n _transactionType = params.transactionType;\n\n _minApproval = params.minApproval;\n _startTime = params.startTime;\n _endTime = params.endTime;\n\n _allowUnlimitedUsageCount = params.allowUnlimitedUsageCount;\n _usageCount = params.usageCount;\n\n _team = params.team;\n _executorTeamId = params.executorTeamId;\n _approverTeamId = params.approverTeamId;\n\n for (uint256 i = 0; i < params.approvers.length; i++) {\n _approversMapping[params.approvers[i]] = true;\n emit SetApprover(params.approvers[i]);\n }\n }\n\n function afterInitialized() external virtual onlyExecutee {}\n\n function executeTransaction(uint256 id)\n public\n virtual\n matchStatus(id, Status.Approved)\n checkTime(id)\n onlyExecutor\n payable\n {\n bool unlimited = allowUnlimitedUsageCount();\n uint256 count = usageCount();\n bytes[] memory data = transactions[id].data;\n\n for (uint256 i = 0; i < data.length; i++) {\n require(unlimited \|\| count > 0, \"Exceeded budget usage limit\");\n if (!unlimited) {\n count--;\n }\n _execute(id, data[i]);\n }\n\n _usageCount = count;\n transactions[id].status = Status.Completed;\n emit ExecuteTransaction(id, data, msg.sender);\n }\n\n function createTransaction(\n bytes[] memory _data,\n uint32 _deadline,\n bool _isExecute,\n string calldata comment\n ) external virtual onlyExecutor payable returns (uint256) {\n _transactionIds.increment();\n uint256 id = _transactionIds.current();\n\n // workaround when have mapping in Struct\n Transaction storage newTransaction = transactions[id];\n newTransaction.id = id;\n newTransaction.data = _data;\n newTransaction.deadline = _deadline;\n newTransaction.isExist = true;\n\n if (minApproval() == 0) {\n transactions[id].status = Status.Approved;\n } else {\n transactions[id].status = Status.Pending;\n }\n\n emit CreateTransaction(\n id,\n _data,\n _deadline,\n newTransaction.status,\n comment,\n msg.sender\n );\n\n if (_isExecute) {\n executeTransaction(id);\n }\n return id;\n }\n\n function approveTransaction(uint256 id, string calldata comment)\n external\n virtual\n onlyApprover\n {\n require(_transactionIds.current() >= id, \"Invaild TransactionId\");\n\n Status _transactionStatus = transactions[id].status;\n uint256 _transactionApprovedCount = transactions[id].approvedCount + 1;\n\n require(\n _transactionStatus == Status.Pending \|\|\n _transactionStatus == Status.Approved,\n \"Unexpected transaction status\"\n );\n require(\n !transactions[id].approved[msg.sender],\n \"Transaction has been approved before\"\n );\n\n transactions[id].approved[msg.sender] = true;\n transactions[id].approvedCount = _transactionApprovedCount;\n\n if (_transactionApprovedCount >= minApproval()) {\n transactions[id].status = Status.Approved;\n }\n\n emit ApproveTransaction(id, msg.sender, comment);\n }\n\n function revokeTransaction(uint256 id) external virtual onlyExecutor {\n require(_transactionIds.current() >= id, \"Invaild TransactionId\");\n require(\n transactions[id].status != Status.Completed,\n \"Transaction has been completed before\"\n );\n transactions[id].status = Status.Cancelled;\n\n emit RevokeTransaction(id);\n }\n\n function _execute(uint256, bytes memory) internal virtual;\n\n function executeParams() external pure virtual returns (string[] memory);\n\n function name() external virtual returns (string memory);\n}\n"
	},
	"contracts/interface/IBudgetApprovalExecutee.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\n\npragma solidity 0.8.7;\n\ninterface IBudgetApprovalExecutee {\n function executeByBudgetApproval(address, bytes memory, uint256) external returns (bytes memory);\n function createBudgetApprovals(address[] calldata, bytes[] calldata) external;\n function team() external view returns (address);\n}"
	},
	"contracts/interface/ITeam.sol": {
	"content": "// SPDX-License-Identifier: GPL-3.0\n// !! THIS FILE WAS AUTOGENERATED BY abi-to-sol v0.5.3. SEE SOURCE BELOW. !!\npragma solidity 0.8.7;\n\ninterface ITeam {\n event AddMembers(uint256 tokenId, address[] members);\n event AddTeam(\n uint256 tokenId,\n address creator,\n address minter,\n string name,\n string description\n );\n event AdminChanged(address previousAdmin, address newAdmin);\n event ApprovalForAll(\n address indexed account,\n address indexed operator,\n bool approved\n );\n event BeaconUpgraded(address indexed beacon);\n event EditInfo(string name, string description, uint256 tokenId);\n event Initialized(uint8 version);\n event OwnershipTransferred(\n address indexed previousOwner,\n address indexed newOwner\n );\n event RemoveMembers(uint256 tokenId, address[] members);\n event TransferBatch(\n address indexed operator,\n address indexed from,\n address indexed to,\n uint256[] ids,\n uint256[] values\n );\n event TransferSingle(\n address indexed operator,\n address indexed from,\n address indexed to,\n uint256 id,\n uint256 value\n );\n event URI(string value, uint256 indexed id);\n event Upgraded(address indexed implementation);\n\n function addMembers(address[] memory members, uint256 tokenId) external;\n\n function addTeam(\n string memory name,\n address minter,\n address[] memory members,\n string memory description\n ) external returns (uint256);\n\n function balanceOf(address account, uint256 id)\n external\n view\n returns (uint256);\n\n function balanceOfBatch(address[] memory accounts, uint256[] memory ids)\n external\n view\n returns (uint256[] memory);\n\n function creatorOf(uint256) external view returns (address);\n\n function descriptionOf(uint256) external view returns (string memory);\n\n function initialize() external;\n\n function isApprovedForAll(address account, address operator)\n external\n view\n returns (bool);\n\n function minterOf(uint256) external view returns (address);\n\n function nameOf(uint256) external view returns (string memory);\n\n function owner() external view returns (address);\n\n function proxiableUUID() external view returns (bytes32);\n\n function removeMembers(address[] memory members, uint256 tokenId) external;\n\n function renounceOwnership() external;\n\n function safeBatchTransferFrom(\n address from,\n address to,\n uint256[] memory ids,\n uint256[] memory amounts,\n bytes memory data\n ) external;\n\n function safeTransferFrom(\n address from,\n address to,\n uint256 id,\n uint256 amount,\n bytes memory data\n ) external;\n\n function setApprovalForAll(address operator, bool approved) external;\n\n function setInfo(\n string memory name,\n string memory description,\n uint256 tokenId\n ) external;\n\n function supportsInterface(bytes4 interfaceId) external view returns (bool);\n\n function transferOwnership(address newOwner) external;\n\n function upgradeTo(address newImplementation) external;\n\n function upgradeToAndCall(address newImplementation, bytes memory data)\n external\n payable;\n\n function uri(uint256 _id) external view returns (string memory);\n}\n\n// THIS FILE WAS AUTOGENERATED FROM THE FOLLOWING ABI JSON:\n/\n[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"members\",\"type\":\"address[]\"}],\"name\":\"AddMembers\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"creator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"AddTeam\",\"type\":\"event\"},{\"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\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"EditInfo\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"members\",\"type\":\"address[]\"}],\"name\":\"RemoveMembers\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"ids\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"values\",\"type\":\"uint256[]\"}],\"name\":\"TransferBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"TransferSingle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"value\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"URI\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"members\",\"type\":\"address[]\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"addMembers\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"members\",\"type\":\"address[]\"},{\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"}],\"name\":\"addTeam\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"accounts\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"ids\",\"type\":\"uint256[]\"}],\"name\":\"balanceOfBatch\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"creatorOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"descriptionOf\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"minterOf\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"nameOf\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"members\",\"type\":\"address[]\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"removeMembers\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"ids\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeBatchTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"id\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"description\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"tokenId\",\"type\":\"uint256\"}],\"name\":\"setInfo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_id\",\"type\":\"uint256\"}],\"name\":\"uri\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]\n/\n"
	},
	"contracts/lib/BytesLib.sol": {
	"content": "// SPDX-License-Identifier: Unlicense\n/\n @title Solidity Bytes Arrays Utils\n * @author Gonçalo Sá <goncalo.sa@consensys.net>\n \n @dev Bytes tightly packed arrays utility library for ethereum contracts written in Solidity.\n * The library lets you concatenate, slice and type cast bytes arrays both in memory and storage.\n */\npragma solidity 0.8.7;\n\n\nlibrary BytesLib {\n function concat(\n bytes memory _preBytes,\n bytes memory _postBytes\n )\n internal\n pure\n returns (bytes memory)\n {\n bytes memory tempBytes;\n\n assembly {\n // Get a location of some free memory and store it in tempBytes as\n // Solidity does for memory variables.\n tempBytes := mload(0x40)\n\n // Store the length of the first bytes array at the beginning of\n // the memory for tempBytes.\n let length := mload(_preBytes)\n mstore(tempBytes, length)\n\n // Maintain a memory counter for the current write location in the\n // temp bytes array by adding the 32 bytes for the array length to\n // the starting location.\n let mc := add(tempBytes, 0x20)\n // Stop copying when the memory counter reaches the length of the\n // first bytes array.\n let end := add(mc, length)\n\n for {\n // Initialize a copy counter to the start of the _preBytes data,\n // 32 bytes into its memory.\n let cc := add(_preBytes, 0x20)\n } lt(mc, end) {\n // Increase both counters by 32 bytes each iteration.\n mc := add(mc, 0x20)\n cc := add(cc, 0x20)\n } {\n // Write the _preBytes data into the tempBytes memory 32 bytes\n // at a time.\n mstore(mc, mload(cc))\n }\n\n // Add the length of _postBytes to the current length of tempBytes\n // and store it as the new length in the first 32 bytes of the\n // tempBytes memory.\n length := mload(_postBytes)\n mstore(tempBytes, add(length, mload(tempBytes)))\n\n // Move the memory counter back from a multiple of 0x20 to the\n // actual end of the _preBytes data.\n mc := end\n // Stop copying when the memory counter reaches the new combined\n // length of the arrays.\n end := add(mc, length)\n\n for {\n let cc := add(_postBytes, 0x20)\n } lt(mc, end) {\n mc := add(mc, 0x20)\n cc := add(cc, 0x20)\n } {\n mstore(mc, mload(cc))\n }\n\n // Update the free-memory pointer by padding our last write location\n // to 32 bytes: add 31 bytes to the end of tempBytes to move to the\n // next 32 byte block, then round down to the nearest multiple of\n // 32. If the sum of the length of the two arrays is zero then add\n // one before rounding down to leave a blank 32 bytes (the length block with 0).\n mstore(0x40, and(\n add(add(end, iszero(add(length, mload(_preBytes)))), 31),\n not(31) // Round down to the nearest 32 bytes.\n ))\n }\n\n return tempBytes;\n }\n\n function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {\n assembly {\n // Read the first 32 bytes of _preBytes storage, which is the length\n // of the array. (We don't need to use the offset into the slot\n // because arrays use the entire slot.)\n let fslot := sload(_preBytes.slot)\n // Arrays of 31 bytes or less have an even value in their slot,\n // while longer arrays have an odd value. The actual length is\n // the slot divided by two for odd values, and the lowest order\n // byte divided by two for even values.\n // If the slot is even, bitwise and the slot with 255 and divide by\n // two to get the length. If the slot is odd, bitwise and the slot\n // with -1 and divide by two.\n let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n let mlength := mload(_postBytes)\n let newlength := add(slength, mlength)\n // slength can contain both the length and contents of the array\n // if length < 32 bytes so let's prepare for that\n // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n switch add(lt(slength, 32), lt(newlength, 32))\n case 2 {\n // Since the new array still fits in the slot, we just need to\n // update the contents of the slot.\n // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length\n sstore(\n _preBytes.slot,\n // all the modifications to the slot are inside this\n // next block\n add(\n // we can just add to the slot contents because the\n // bytes we want to change are the LSBs\n fslot,\n add(\n mul(\n div(\n // load the bytes from memory\n mload(add(_postBytes, 0x20)),\n // zero all bytes to the right\n exp(0x100, sub(32, mlength))\n ),\n // and now shift left the number of bytes to\n // leave space for the length in the slot\n exp(0x100, sub(32, newlength))\n ),\n // increase length by the double of the memory\n // bytes length\n mul(mlength, 2)\n )\n )\n )\n }\n case 1 {\n // The stored value fits in the slot, but the combined value\n // will exceed it.\n // get the keccak hash to get the contents of the array\n mstore(0x0, _preBytes.slot)\n let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n // save new length\n sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n // The contents of the _postBytes array start 32 bytes into\n // the structure. Our first read should obtain the `submod`\n // bytes that can fit into the unused space in the last word\n // of the stored array. To get this, we read 32 bytes starting\n // from `submod`, so the data we read overlaps with the array\n // contents by `submod` bytes. Masking the lowest-order\n // `submod` bytes allows us to add that value directly to the\n // stored value.\n\n let submod := sub(32, slength)\n let mc := add(_postBytes, submod)\n let end := add(_postBytes, mlength)\n let mask := sub(exp(0x100, submod), 1)\n\n sstore(\n sc,\n add(\n and(\n fslot,\n 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00\n ),\n and(mload(mc), mask)\n )\n )\n\n for {\n mc := add(mc, 0x20)\n sc := add(sc, 1)\n } lt(mc, end) {\n sc := add(sc, 1)\n mc := add(mc, 0x20)\n } {\n sstore(sc, mload(mc))\n }\n\n mask := exp(0x100, sub(mc, end))\n\n sstore(sc, mul(div(mload(mc), mask), mask))\n }\n default {\n // get the keccak hash to get the contents of the array\n mstore(0x0, _preBytes.slot)\n // Start copying to the last used word of the stored array.\n let sc := add(keccak256(0x0, 0x20), div(slength, 32))\n\n // save new length\n sstore(_preBytes.slot, add(mul(newlength, 2), 1))\n\n // Copy over the first `submod` bytes of the new data as in\n // case 1 above.\n let slengthmod := mod(slength, 32)\n let mlengthmod := mod(mlength, 32)\n let submod := sub(32, slengthmod)\n let mc := add(_postBytes, submod)\n let end := add(_postBytes, mlength)\n let mask := sub(exp(0x100, submod), 1)\n\n sstore(sc, add(sload(sc), and(mload(mc), mask)))\n\n for {\n sc := add(sc, 1)\n mc := add(mc, 0x20)\n } lt(mc, end) {\n sc := add(sc, 1)\n mc := add(mc, 0x20)\n } {\n sstore(sc, mload(mc))\n }\n\n mask := exp(0x100, sub(mc, end))\n\n sstore(sc, mul(div(mload(mc), mask), mask))\n }\n }\n }\n\n function slice(\n bytes memory _bytes,\n uint256 _start,\n uint256 _length\n )\n internal\n pure\n returns (bytes memory)\n {\n require(_length + 31 >= _length, \"slice_overflow\");\n require(_bytes.length >= _start + _length, \"slice_outOfBounds\");\n\n bytes memory tempBytes;\n\n assembly {\n switch iszero(_length)\n case 0 {\n // Get a location of some free memory and store it in tempBytes as\n // Solidity does for memory variables.\n tempBytes := mload(0x40)\n\n // The first word of the slice result is potentially a partial\n // word read from the original array. To read it, we calculate\n // the length of that partial word and start copying that many\n // bytes into the array. The first word we copy will start with\n // data we don't care about, but the last `lengthmod` bytes will\n // land at the beginning of the contents of the new array. When\n // we're done copying, we overwrite the full first word with\n // the actual length of the slice.\n let lengthmod := and(_length, 31)\n\n // The multiplication in the next line is necessary\n // because when slicing multiples of 32 bytes (lengthmod == 0)\n // the following copy loop was copying the origin's length\n // and then ending prematurely not copying everything it should.\n let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))\n let end := add(mc, _length)\n\n for {\n // The multiplication in the next line has the same exact purpose\n // as the one above.\n let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)\n } lt(mc, end) {\n mc := add(mc, 0x20)\n cc := add(cc, 0x20)\n } {\n mstore(mc, mload(cc))\n }\n\n mstore(tempBytes, _length)\n\n //update free-memory pointer\n //allocating the array padded to 32 bytes like the compiler does now\n mstore(0x40, and(add(mc, 31), not(31)))\n }\n //if we want a zero-length slice let's just return a zero-length array\n default {\n tempBytes := mload(0x40)\n //zero out the 32 bytes slice we are about to return\n //we need to do it because Solidity does not garbage collect\n mstore(tempBytes, 0)\n\n mstore(0x40, add(tempBytes, 0x20))\n }\n }\n\n return tempBytes;\n }\n\n function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {\n require(_bytes.length >= _start + 20, \"toAddress_outOfBounds\");\n address tempAddress;\n\n assembly {\n tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)\n }\n\n return tempAddress;\n }\n\n function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {\n require(_bytes.length >= _start + 1 , \"toUint8_outOfBounds\");\n uint8 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x1), _start))\n }\n\n return tempUint;\n }\n\n function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {\n require(_bytes.length >= _start + 2, \"toUint16_outOfBounds\");\n uint16 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x2), _start))\n }\n\n return tempUint;\n }\n\n function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {\n require(_bytes.length >= _start + 4, \"toUint32_outOfBounds\");\n uint32 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x4), _start))\n }\n\n return tempUint;\n }\n\n function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {\n require(_bytes.length >= _start + 8, \"toUint64_outOfBounds\");\n uint64 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x8), _start))\n }\n\n return tempUint;\n }\n\n function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {\n require(_bytes.length >= _start + 12, \"toUint96_outOfBounds\");\n uint96 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0xc), _start))\n }\n\n return tempUint;\n }\n\n function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {\n require(_bytes.length >= _start + 16, \"toUint128_outOfBounds\");\n uint128 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x10), _start))\n }\n\n return tempUint;\n }\n\n function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {\n require(_bytes.length >= _start + 32, \"toUint256_outOfBounds\");\n uint256 tempUint;\n\n assembly {\n tempUint := mload(add(add(_bytes, 0x20), _start))\n }\n\n return tempUint;\n }\n\n function toBytes4(bytes memory _bytes, uint256 _start) internal pure returns (bytes4) {\n require(_bytes.length >= _start + 4, \"toBytes4_outOfBounds\");\n bytes4 tempBytes4;\n\n assembly {\n tempBytes4 := mload(add(add(_bytes, 0x20), _start))\n }\n\n return tempBytes4;\n }\n\n function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {\n require(_bytes.length >= _start + 32, \"toBytes32_outOfBounds\");\n bytes32 tempBytes32;\n\n assembly {\n tempBytes32 := mload(add(add(_bytes, 0x20), _start))\n }\n\n return tempBytes32;\n }\n\n function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {\n bool success = true;\n\n assembly {\n let length := mload(_preBytes)\n\n // if lengths don't match the arrays are not equal\n switch eq(length, mload(_postBytes))\n case 1 {\n // cb is a circuit breaker in the for loop since there's\n // no said feature for inline assembly loops\n // cb = 1 - don't breaker\n // cb = 0 - break\n let cb := 1\n\n let mc := add(_preBytes, 0x20)\n let end := add(mc, length)\n\n for {\n let cc := add(_postBytes, 0x20)\n // the next line is the loop condition:\n // while(uint256(mc < end) + cb == 2)\n } eq(add(lt(mc, end), cb), 2) {\n mc := add(mc, 0x20)\n cc := add(cc, 0x20)\n } {\n // if any of these checks fails then arrays are not equal\n if iszero(eq(mload(mc), mload(cc))) {\n // unsuccess:\n success := 0\n cb := 0\n }\n }\n }\n default {\n // unsuccess:\n success := 0\n }\n }\n\n return success;\n }\n\n function equalStorage(\n bytes storage _preBytes,\n bytes memory _postBytes\n )\n internal\n view\n returns (bool)\n {\n bool success = true;\n\n assembly {\n // we know _preBytes_offset is 0\n let fslot := sload(_preBytes.slot)\n // Decode the length of the stored array like in concatStorage().\n let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)\n let mlength := mload(_postBytes)\n\n // if lengths don't match the arrays are not equal\n switch eq(slength, mlength)\n case 1 {\n // slength can contain both the length and contents of the array\n // if length < 32 bytes so let's prepare for that\n // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage\n if iszero(iszero(slength)) {\n switch lt(slength, 32)\n case 1 {\n // blank the last byte which is the length\n fslot := mul(div(fslot, 0x100), 0x100)\n\n if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {\n // unsuccess:\n success := 0\n }\n }\n default {\n // cb is a circuit breaker in the for loop since there's\n // no said feature for inline assembly loops\n // cb = 1 - don't breaker\n // cb = 0 - break\n let cb := 1\n\n // get the keccak hash to get the contents of the array\n mstore(0x0, _preBytes.slot)\n let sc := keccak256(0x0, 0x20)\n\n let mc := add(_postBytes, 0x20)\n let end := add(mc, mlength)\n\n // the next line is the loop condition:\n // while(uint256(mc < end) + cb == 2)\n for {} eq(add(lt(mc, end), cb), 2) {\n sc := add(sc, 1)\n mc := add(mc, 0x20)\n } {\n if iszero(eq(sload(sc), mload(mc))) {\n // unsuccess:\n success := 0\n cb := 0\n }\n }\n }\n }\n }\n default {\n // unsuccess:\n success := 0\n }\n }\n\n return success;\n }\n}"
	}
	}
	}