├── README.md ├── lib ├── artifacts │ ├── Address_metadata.json │ ├── SafeMath_metadata.json │ ├── SafeBEP20_metadata.json │ ├── build-info │ │ ├── a63328eef3854675749e80a26b137777.json │ │ ├── e1112b2fe3470f1f5da603fd9fafa6d3.json │ │ ├── 628ca0936cdc78542bf6ad1960f9b7f0.json │ │ └── 2dd65a92c987e0a1e13d3d7591fd2243.json │ ├── SafeBEP20.json │ ├── SafeMath.json │ ├── Address.json │ ├── IBEP20.json │ └── IBEP20_metadata.json ├── IBEP20.sol ├── SafeBEP20.sol ├── SafeMath.sol └── Address.sol └── BStakeSystem.sol /README.md: -------------------------------------------------------------------------------- 1 | # BSC_Contract_Maxim_stake_reward created by james 2 | 3 | BSC staking and reward. 4 | 5 | if you invite uesrs, you will receive 20% of staking amount of your friend. -------------------------------------------------------------------------------- /lib/artifacts/Address_metadata.json: -------------------------------------------------------------------------------- 1 | { 2 | "compiler": { 3 | "version": "0.8.14+commit.80d49f37" 4 | }, 5 | "language": "Solidity", 6 | "output": { 7 | "abi": [], 8 | "devdoc": { 9 | "details": "Collection of functions related to the address type", 10 | "kind": "dev", 11 | "methods": {}, 12 | "version": 1 13 | }, 14 | "userdoc": { 15 | "kind": "user", 16 | "methods": {}, 17 | "version": 1 18 | } 19 | }, 20 | "settings": { 21 | "compilationTarget": { 22 | "Maxim/lib/Address.sol": "Address" 23 | }, 24 | "evmVersion": "london", 25 | "libraries": {}, 26 | "metadata": { 27 | "bytecodeHash": "ipfs" 28 | }, 29 | "optimizer": { 30 | "enabled": false, 31 | "runs": 200 32 | }, 33 | "remappings": [] 34 | }, 35 | "sources": { 36 | "Maxim/lib/Address.sol": { 37 | "keccak256": "0xd430c69966dd69b65fc487cb8b76dc796a3a9acee90910990f6787c646393671", 38 | "license": "MIT", 39 | "urls": [ 40 | "bzz-raw://ae1b8caff628d78f37052533eb038576a876089f82a141d2fb3aa28b4c730e9a", 41 | "dweb:/ipfs/QmatB7MZQ1uypNt3jCJH33HjJXjvN9HoS868VjAm9N2Byo" 42 | ] 43 | } 44 | }, 45 | "version": 1 46 | } -------------------------------------------------------------------------------- /lib/artifacts/SafeMath_metadata.json: -------------------------------------------------------------------------------- 1 | { 2 | "compiler": { 3 | "version": "0.8.14+commit.80d49f37" 4 | }, 5 | "language": "Solidity", 6 | "output": { 7 | "abi": [], 8 | "devdoc": { 9 | "details": "Wrappers over Solidity's arithmetic operations. NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler now has built in overflow checking.", 10 | "kind": "dev", 11 | "methods": {}, 12 | "version": 1 13 | }, 14 | "userdoc": { 15 | "kind": "user", 16 | "methods": {}, 17 | "version": 1 18 | } 19 | }, 20 | "settings": { 21 | "compilationTarget": { 22 | "Maxim/lib/SafeMath.sol": "SafeMath" 23 | }, 24 | "evmVersion": "london", 25 | "libraries": {}, 26 | "metadata": { 27 | "bytecodeHash": "ipfs" 28 | }, 29 | "optimizer": { 30 | "enabled": false, 31 | "runs": 200 32 | }, 33 | "remappings": [] 34 | }, 35 | "sources": { 36 | "Maxim/lib/SafeMath.sol": { 37 | "keccak256": "0xdc9b51d94a1db880c1f2e722af561c28c41100eea201b1ae5e77eb7c4250e389", 38 | "license": "MIT", 39 | "urls": [ 40 | "bzz-raw://0b69f7fb378dcfd4aff8ba0547a575485d2d4bb567381e3bf8c593b63272ffc0", 41 | "dweb:/ipfs/QmaEo28ZDAnpDvpQRRt7Qc8bF5QgJAnTEE4TxYnJS8YmnN" 42 | ] 43 | } 44 | }, 45 | "version": 1 46 | } -------------------------------------------------------------------------------- /lib/artifacts/SafeBEP20_metadata.json: -------------------------------------------------------------------------------- 1 | { 2 | "compiler": { 3 | "version": "0.8.14+commit.80d49f37" 4 | }, 5 | "language": "Solidity", 6 | "output": { 7 | "abi": [], 8 | "devdoc": { 9 | "details": "Wrappers around BEP20 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 SafeBEP20 for IBEP20;` statement to your contract, which allows you to call the safe operations as `token.safeTransfer(...)`, etc.", 10 | "kind": "dev", 11 | "methods": {}, 12 | "title": "SafeBEP20", 13 | "version": 1 14 | }, 15 | "userdoc": { 16 | "kind": "user", 17 | "methods": {}, 18 | "version": 1 19 | } 20 | }, 21 | "settings": { 22 | "compilationTarget": { 23 | "Maxim/lib/SafeBEP20.sol": "SafeBEP20" 24 | }, 25 | "evmVersion": "london", 26 | "libraries": {}, 27 | "metadata": { 28 | "bytecodeHash": "ipfs" 29 | }, 30 | "optimizer": { 31 | "enabled": false, 32 | "runs": 200 33 | }, 34 | "remappings": [] 35 | }, 36 | "sources": { 37 | "Maxim/lib/Address.sol": { 38 | "keccak256": "0xd430c69966dd69b65fc487cb8b76dc796a3a9acee90910990f6787c646393671", 39 | "license": "MIT", 40 | "urls": [ 41 | "bzz-raw://ae1b8caff628d78f37052533eb038576a876089f82a141d2fb3aa28b4c730e9a", 42 | "dweb:/ipfs/QmatB7MZQ1uypNt3jCJH33HjJXjvN9HoS868VjAm9N2Byo" 43 | ] 44 | }, 45 | "Maxim/lib/IBEP20.sol": { 46 | "keccak256": "0x8cac4738a0b00bd1b06b333eb423e0d77a9d70f86576cbab3a4ca01b8773ebf3", 47 | "license": "GPL-3.0-or-later", 48 | "urls": [ 49 | "bzz-raw://35d0231ddf8926dd89b14fcfe2a6ae1c0821ab38178653dc6083e019b2fb6ee9", 50 | "dweb:/ipfs/QmSh1aEz5BLvsr6Zt8qjV2ZA9EfSUXTGX3PJ49aVgxoSPT" 51 | ] 52 | }, 53 | "Maxim/lib/SafeBEP20.sol": { 54 | "keccak256": "0x2cec3c890138f843ede6c88f9f8c7b9474837714dac9f4fe7add01374fb7740b", 55 | "license": "MIT", 56 | "urls": [ 57 | "bzz-raw://c3dd61205d6c69b52241c46202116849ac4d54f70845eb8f73b88bb22835d129", 58 | "dweb:/ipfs/QmYjHcnbYvd3qwMFSo2K1GdVQBHaQBjrsabotTyqh4jKFY" 59 | ] 60 | }, 61 | "Maxim/lib/SafeMath.sol": { 62 | "keccak256": "0xdc9b51d94a1db880c1f2e722af561c28c41100eea201b1ae5e77eb7c4250e389", 63 | "license": "MIT", 64 | "urls": [ 65 | "bzz-raw://0b69f7fb378dcfd4aff8ba0547a575485d2d4bb567381e3bf8c593b63272ffc0", 66 | "dweb:/ipfs/QmaEo28ZDAnpDvpQRRt7Qc8bF5QgJAnTEE4TxYnJS8YmnN" 67 | ] 68 | } 69 | }, 70 | "version": 1 71 | } -------------------------------------------------------------------------------- /lib/artifacts/build-info/a63328eef3854675749e80a26b137777.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "a63328eef3854675749e80a26b137777", 3 | "_format": "hh-sol-build-info-1", 4 | "solcVersion": "0.8.14", 5 | "solcLongVersion": "0.8.14+commit.80d49f37", 6 | "input": { 7 | "language": "Solidity", 8 | "sources": { 9 | "Maxim/lib/SafeMath.sol": { 10 | "content": "" 11 | } 12 | }, 13 | "settings": { 14 | "optimizer": { 15 | "enabled": false, 16 | "runs": 200 17 | }, 18 | "outputSelection": { 19 | "*": { 20 | "": [ 21 | "ast" 22 | ], 23 | "*": [ 24 | "abi", 25 | "metadata", 26 | "devdoc", 27 | "userdoc", 28 | "storageLayout", 29 | "evm.legacyAssembly", 30 | "evm.bytecode", 31 | "evm.deployedBytecode", 32 | "evm.methodIdentifiers", 33 | "evm.gasEstimates", 34 | "evm.assembly" 35 | ] 36 | } 37 | } 38 | } 39 | }, 40 | "output": { 41 | "errors": [ 42 | { 43 | "component": "general", 44 | "errorCode": "1878", 45 | "formattedMessage": "Warning: SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.\n--> Maxim/lib/SafeMath.sol\n\n", 46 | "message": "SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.", 47 | "severity": "warning", 48 | "sourceLocation": { 49 | "end": -1, 50 | "file": "Maxim/lib/SafeMath.sol", 51 | "start": -1 52 | }, 53 | "type": "Warning" 54 | }, 55 | { 56 | "component": "general", 57 | "errorCode": "3420", 58 | "formattedMessage": "Warning: Source file does not specify required compiler version! Consider adding \"pragma solidity ^0.8.14;\"\n--> Maxim/lib/SafeMath.sol\n\n", 59 | "message": "Source file does not specify required compiler version! Consider adding \"pragma solidity ^0.8.14;\"", 60 | "severity": "warning", 61 | "sourceLocation": { 62 | "end": -1, 63 | "file": "Maxim/lib/SafeMath.sol", 64 | "start": -1 65 | }, 66 | "type": "Warning" 67 | } 68 | ], 69 | "sources": { 70 | "Maxim/lib/SafeMath.sol": { 71 | "ast": { 72 | "absolutePath": "Maxim/lib/SafeMath.sol", 73 | "exportedSymbols": {}, 74 | "id": 1, 75 | "nodeType": "SourceUnit", 76 | "nodes": [], 77 | "src": "0:0:0" 78 | }, 79 | "id": 0 80 | } 81 | } 82 | } 83 | } -------------------------------------------------------------------------------- /lib/artifacts/build-info/e1112b2fe3470f1f5da603fd9fafa6d3.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "e1112b2fe3470f1f5da603fd9fafa6d3", 3 | "_format": "hh-sol-build-info-1", 4 | "solcVersion": "0.6.12", 5 | "solcLongVersion": "0.6.12+commit.27d51765", 6 | "input": { 7 | "language": "Solidity", 8 | "sources": { 9 | "Maxim/lib/Address.sol": { 10 | "content": "" 11 | } 12 | }, 13 | "settings": { 14 | "optimizer": { 15 | "enabled": false, 16 | "runs": 200 17 | }, 18 | "outputSelection": { 19 | "*": { 20 | "": [ 21 | "ast" 22 | ], 23 | "*": [ 24 | "abi", 25 | "metadata", 26 | "devdoc", 27 | "userdoc", 28 | "storageLayout", 29 | "evm.legacyAssembly", 30 | "evm.bytecode", 31 | "evm.deployedBytecode", 32 | "evm.methodIdentifiers", 33 | "evm.gasEstimates", 34 | "evm.assembly" 35 | ] 36 | } 37 | } 38 | } 39 | }, 40 | "output": { 41 | "errors": [ 42 | { 43 | "component": "general", 44 | "errorCode": "1878", 45 | "formattedMessage": "Maxim/lib/Address.sol: Warning: SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.\n", 46 | "message": "SPDX license identifier not provided in source file. Before publishing, consider adding a comment containing \"SPDX-License-Identifier: \" to each source file. Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. Please see https://spdx.org for more information.", 47 | "severity": "warning", 48 | "sourceLocation": { 49 | "end": -1, 50 | "file": "Maxim/lib/Address.sol", 51 | "start": -1 52 | }, 53 | "type": "Warning" 54 | }, 55 | { 56 | "component": "general", 57 | "errorCode": "3420", 58 | "formattedMessage": "Maxim/lib/Address.sol: Warning: Source file does not specify required compiler version! Consider adding \"pragma solidity ^0.6.12;\"\n", 59 | "message": "Source file does not specify required compiler version! Consider adding \"pragma solidity ^0.6.12;\"", 60 | "severity": "warning", 61 | "sourceLocation": { 62 | "end": -1, 63 | "file": "Maxim/lib/Address.sol", 64 | "start": -1 65 | }, 66 | "type": "Warning" 67 | } 68 | ], 69 | "sources": { 70 | "Maxim/lib/Address.sol": { 71 | "ast": { 72 | "absolutePath": "Maxim/lib/Address.sol", 73 | "exportedSymbols": {}, 74 | "id": 1, 75 | "license": null, 76 | "nodeType": "SourceUnit", 77 | "nodes": [], 78 | "src": "0:0:0" 79 | }, 80 | "id": 0 81 | } 82 | } 83 | } 84 | } -------------------------------------------------------------------------------- /lib/artifacts/SafeBEP20.json: -------------------------------------------------------------------------------- 1 | { 2 | "deploy": { 3 | "VM:-": { 4 | "linkReferences": {}, 5 | "autoDeployLib": true 6 | }, 7 | "main:1": { 8 | "linkReferences": {}, 9 | "autoDeployLib": true 10 | }, 11 | "ropsten:3": { 12 | "linkReferences": {}, 13 | "autoDeployLib": true 14 | }, 15 | "rinkeby:4": { 16 | "linkReferences": {}, 17 | "autoDeployLib": true 18 | }, 19 | "kovan:42": { 20 | "linkReferences": {}, 21 | "autoDeployLib": true 22 | }, 23 | "görli:5": { 24 | "linkReferences": {}, 25 | "autoDeployLib": true 26 | }, 27 | "Custom": { 28 | "linkReferences": {}, 29 | "autoDeployLib": true 30 | } 31 | }, 32 | "data": { 33 | "bytecode": { 34 | "functionDebugData": {}, 35 | "generatedSources": [], 36 | "linkReferences": {}, 37 | "object": "60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212201383de62cf5a25145cc6942b5467d131b77a512f9ee805de51f25a4c5d99469464736f6c634300080e0033", 38 | "opcodes": "PUSH1 0x56 PUSH1 0x50 PUSH1 0xB DUP3 DUP3 DUP3 CODECOPY DUP1 MLOAD PUSH1 0x0 BYTE PUSH1 0x73 EQ PUSH1 0x43 JUMPI PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x0 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST ADDRESS PUSH1 0x0 MSTORE PUSH1 0x73 DUP2 MSTORE8 DUP3 DUP2 RETURN INVALID PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SGT DUP4 0xDE PUSH3 0xCF5A25 EQ 0x5C 0xC6 SWAP5 0x2B SLOAD PUSH8 0xD131B77A512F9EE8 SDIV 0xDE MLOAD CALLCODE GAS 0x4C 0x5D SWAP10 CHAINID SWAP5 PUSH5 0x736F6C6343 STOP ADDMOD 0xE STOP CALLER ", 39 | "sourceMap": "606:3553:2:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" 40 | }, 41 | "deployedBytecode": { 42 | "functionDebugData": {}, 43 | "generatedSources": [], 44 | "immutableReferences": {}, 45 | "linkReferences": {}, 46 | "object": "73000000000000000000000000000000000000000030146080604052600080fdfea26469706673582212201383de62cf5a25145cc6942b5467d131b77a512f9ee805de51f25a4c5d99469464736f6c634300080e0033", 47 | "opcodes": "PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 SGT DUP4 0xDE PUSH3 0xCF5A25 EQ 0x5C 0xC6 SWAP5 0x2B SLOAD PUSH8 0xD131B77A512F9EE8 SDIV 0xDE MLOAD CALLCODE GAS 0x4C 0x5D SWAP10 CHAINID SWAP5 PUSH5 0x736F6C6343 STOP ADDMOD 0xE STOP CALLER ", 48 | "sourceMap": "606:3553:2:-:0;;;;;;;;" 49 | }, 50 | "gasEstimates": { 51 | "creation": { 52 | "codeDepositCost": "17200", 53 | "executionCost": "97", 54 | "totalCost": "17297" 55 | }, 56 | "internal": { 57 | "_callOptionalReturn(contract IBEP20,bytes memory)": "infinite", 58 | "safeApprove(contract IBEP20,address,uint256)": "infinite", 59 | "safeDecreaseAllowance(contract IBEP20,address,uint256)": "infinite", 60 | "safeIncreaseAllowance(contract IBEP20,address,uint256)": "infinite", 61 | "safeTransfer(contract IBEP20,address,uint256)": "infinite", 62 | "safeTransferFrom(contract IBEP20,address,address,uint256)": "infinite" 63 | } 64 | }, 65 | "methodIdentifiers": {} 66 | }, 67 | "abi": [] 68 | } -------------------------------------------------------------------------------- /lib/artifacts/SafeMath.json: -------------------------------------------------------------------------------- 1 | { 2 | "deploy": { 3 | "VM:-": { 4 | "linkReferences": {}, 5 | "autoDeployLib": true 6 | }, 7 | "main:1": { 8 | "linkReferences": {}, 9 | "autoDeployLib": true 10 | }, 11 | "ropsten:3": { 12 | "linkReferences": {}, 13 | "autoDeployLib": true 14 | }, 15 | "rinkeby:4": { 16 | "linkReferences": {}, 17 | "autoDeployLib": true 18 | }, 19 | "kovan:42": { 20 | "linkReferences": {}, 21 | "autoDeployLib": true 22 | }, 23 | "görli:5": { 24 | "linkReferences": {}, 25 | "autoDeployLib": true 26 | }, 27 | "Custom": { 28 | "linkReferences": {}, 29 | "autoDeployLib": true 30 | } 31 | }, 32 | "data": { 33 | "bytecode": { 34 | "functionDebugData": {}, 35 | "generatedSources": [], 36 | "linkReferences": {}, 37 | "object": "60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220fb6e517fb7c1befe519418bc785880f0e1c38a528d1daa90d736361e89d1660d64736f6c634300080e0033", 38 | "opcodes": "PUSH1 0x56 PUSH1 0x50 PUSH1 0xB DUP3 DUP3 DUP3 CODECOPY DUP1 MLOAD PUSH1 0x0 BYTE PUSH1 0x73 EQ PUSH1 0x43 JUMPI PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x0 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST ADDRESS PUSH1 0x0 MSTORE PUSH1 0x73 DUP2 MSTORE8 DUP3 DUP2 RETURN INVALID PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xFB PUSH15 0x517FB7C1BEFE519418BC785880F0E1 0xC3 DUP11 MSTORE DUP14 SAR 0xAA SWAP1 0xD7 CALLDATASIZE CALLDATASIZE 0x1E DUP10 0xD1 PUSH7 0xD64736F6C6343 STOP ADDMOD 0xE STOP CALLER ", 39 | "sourceMap": "497:6511:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" 40 | }, 41 | "deployedBytecode": { 42 | "functionDebugData": {}, 43 | "generatedSources": [], 44 | "immutableReferences": {}, 45 | "linkReferences": {}, 46 | "object": "73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220fb6e517fb7c1befe519418bc785880f0e1c38a528d1daa90d736361e89d1660d64736f6c634300080e0033", 47 | "opcodes": "PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xFB PUSH15 0x517FB7C1BEFE519418BC785880F0E1 0xC3 DUP11 MSTORE DUP14 SAR 0xAA SWAP1 0xD7 CALLDATASIZE CALLDATASIZE 0x1E DUP10 0xD1 PUSH7 0xD64736F6C6343 STOP ADDMOD 0xE STOP CALLER ", 48 | "sourceMap": "497:6511:0:-:0;;;;;;;;" 49 | }, 50 | "gasEstimates": { 51 | "creation": { 52 | "codeDepositCost": "17200", 53 | "executionCost": "97", 54 | "totalCost": "17297" 55 | }, 56 | "internal": { 57 | "add(uint256,uint256)": "infinite", 58 | "div(uint256,uint256)": "infinite", 59 | "div(uint256,uint256,string memory)": "infinite", 60 | "mod(uint256,uint256)": "infinite", 61 | "mod(uint256,uint256,string memory)": "infinite", 62 | "mul(uint256,uint256)": "infinite", 63 | "sub(uint256,uint256)": "infinite", 64 | "sub(uint256,uint256,string memory)": "infinite", 65 | "tryAdd(uint256,uint256)": "infinite", 66 | "tryDiv(uint256,uint256)": "infinite", 67 | "tryMod(uint256,uint256)": "infinite", 68 | "tryMul(uint256,uint256)": "infinite", 69 | "trySub(uint256,uint256)": "infinite" 70 | } 71 | }, 72 | "methodIdentifiers": {} 73 | }, 74 | "abi": [] 75 | } -------------------------------------------------------------------------------- /lib/artifacts/Address.json: -------------------------------------------------------------------------------- 1 | { 2 | "deploy": { 3 | "VM:-": { 4 | "linkReferences": {}, 5 | "autoDeployLib": true 6 | }, 7 | "main:1": { 8 | "linkReferences": {}, 9 | "autoDeployLib": true 10 | }, 11 | "ropsten:3": { 12 | "linkReferences": {}, 13 | "autoDeployLib": true 14 | }, 15 | "rinkeby:4": { 16 | "linkReferences": {}, 17 | "autoDeployLib": true 18 | }, 19 | "kovan:42": { 20 | "linkReferences": {}, 21 | "autoDeployLib": true 22 | }, 23 | "görli:5": { 24 | "linkReferences": {}, 25 | "autoDeployLib": true 26 | }, 27 | "Custom": { 28 | "linkReferences": {}, 29 | "autoDeployLib": true 30 | } 31 | }, 32 | "data": { 33 | "bytecode": { 34 | "functionDebugData": {}, 35 | "generatedSources": [], 36 | "linkReferences": {}, 37 | "object": "60566050600b82828239805160001a6073146043577f4e487b7100000000000000000000000000000000000000000000000000000000600052600060045260246000fd5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b65a68a2c831ff5c93a051b4d8a8087c5998347770ec2b9d9ea889132e6da2b864736f6c634300080e0033", 38 | "opcodes": "PUSH1 0x56 PUSH1 0x50 PUSH1 0xB DUP3 DUP3 DUP3 CODECOPY DUP1 MLOAD PUSH1 0x0 BYTE PUSH1 0x73 EQ PUSH1 0x43 JUMPI PUSH32 0x4E487B7100000000000000000000000000000000000000000000000000000000 PUSH1 0x0 MSTORE PUSH1 0x0 PUSH1 0x4 MSTORE PUSH1 0x24 PUSH1 0x0 REVERT JUMPDEST ADDRESS PUSH1 0x0 MSTORE PUSH1 0x73 DUP2 MSTORE8 DUP3 DUP2 RETURN INVALID PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xB6 GAS PUSH9 0xA2C831FF5C93A051B4 0xD8 0xA8 ADDMOD PUSH29 0x5998347770EC2B9D9EA889132E6DA2B864736F6C634300080E00330000 ", 39 | "sourceMap": "202:8274:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;" 40 | }, 41 | "deployedBytecode": { 42 | "functionDebugData": {}, 43 | "generatedSources": [], 44 | "immutableReferences": {}, 45 | "linkReferences": {}, 46 | "object": "73000000000000000000000000000000000000000030146080604052600080fdfea2646970667358221220b65a68a2c831ff5c93a051b4d8a8087c5998347770ec2b9d9ea889132e6da2b864736f6c634300080e0033", 47 | "opcodes": "PUSH20 0x0 ADDRESS EQ PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x0 DUP1 REVERT INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 0xB6 GAS PUSH9 0xA2C831FF5C93A051B4 0xD8 0xA8 ADDMOD PUSH29 0x5998347770EC2B9D9EA889132E6DA2B864736F6C634300080E00330000 ", 48 | "sourceMap": "202:8274:0:-:0;;;;;;;;" 49 | }, 50 | "gasEstimates": { 51 | "creation": { 52 | "codeDepositCost": "17200", 53 | "executionCost": "97", 54 | "totalCost": "17297" 55 | }, 56 | "internal": { 57 | "functionCall(address,bytes memory)": "infinite", 58 | "functionCall(address,bytes memory,string memory)": "infinite", 59 | "functionCallWithValue(address,bytes memory,uint256)": "infinite", 60 | "functionCallWithValue(address,bytes memory,uint256,string memory)": "infinite", 61 | "functionDelegateCall(address,bytes memory)": "infinite", 62 | "functionDelegateCall(address,bytes memory,string memory)": "infinite", 63 | "functionStaticCall(address,bytes memory)": "infinite", 64 | "functionStaticCall(address,bytes memory,string memory)": "infinite", 65 | "isContract(address)": "infinite", 66 | "sendValue(address payable,uint256)": "infinite", 67 | "verifyCallResult(bool,bytes memory,string memory)": "infinite" 68 | } 69 | }, 70 | "methodIdentifiers": {} 71 | }, 72 | "abi": [] 73 | } -------------------------------------------------------------------------------- /lib/IBEP20.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: GPL-3.0-or-later 2 | 3 | pragma solidity ^0.8.4; 4 | 5 | interface IBEP20 { 6 | /** 7 | * @dev Returns the amount of tokens in existence. 8 | */ 9 | function totalSupply() external view returns (uint256); 10 | 11 | /** 12 | * @dev Returns the token decimals. 13 | */ 14 | function decimals() external view returns (uint8); 15 | 16 | /** 17 | * @dev Returns the token symbol. 18 | */ 19 | function symbol() external view returns (string memory); 20 | 21 | /** 22 | * @dev Returns the token name. 23 | */ 24 | function name() external view returns (string memory); 25 | 26 | /** 27 | * @dev Returns the bep token owner. 28 | */ 29 | function getOwner() external view returns (address); 30 | 31 | /** 32 | * @dev Returns the amount of tokens owned by `account`. 33 | */ 34 | function balanceOf(address account) external view returns (uint256); 35 | 36 | /** 37 | * @dev Moves `amount` tokens from the caller's account to `recipient`. 38 | * 39 | * Returns a boolean value indicating whether the operation succeeded. 40 | * 41 | * Emits a {Transfer} event. 42 | */ 43 | function transfer(address recipient, uint256 amount) external returns (bool); 44 | 45 | /** 46 | * @dev Returns the remaining number of tokens that `spender` will be 47 | * allowed to spend on behalf of `owner` through {transferFrom}. This is 48 | * zero by default. 49 | * 50 | * This value changes when {approve} or {transferFrom} are called. 51 | */ 52 | function allowance(address _owner, address spender) external view returns (uint256); 53 | 54 | /** 55 | * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. 56 | * 57 | * Returns a boolean value indicating whether the operation succeeded. 58 | * 59 | * IMPORTANT: Beware that changing an allowance with this method brings the risk 60 | * that someone may use both the old and the new allowance by unfortunate 61 | * transaction ordering. One possible solution to mitigate this race 62 | * condition is to first reduce the spender's allowance to 0 and set the 63 | * desired value afterwards: 64 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 65 | * 66 | * Emits an {Approval} event. 67 | */ 68 | function approve(address spender, uint256 amount) external returns (bool); 69 | 70 | /** 71 | * @dev Moves `amount` tokens from `sender` to `recipient` using the 72 | * allowance mechanism. `amount` is then deducted from the caller's 73 | * allowance. 74 | * 75 | * Returns a boolean value indicating whether the operation succeeded. 76 | * 77 | * Emits a {Transfer} event. 78 | */ 79 | function transferFrom( 80 | address sender, 81 | address recipient, 82 | uint256 amount 83 | ) external returns (bool); 84 | 85 | /** 86 | * @dev Emitted when `value` tokens are moved from one account (`from`) to 87 | * another (`to`). 88 | * 89 | * Note that `value` may be zero. 90 | */ 91 | event Transfer(address indexed from, address indexed to, uint256 value); 92 | 93 | /** 94 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by 95 | * a call to {approve}. `value` is the new allowance. 96 | */ 97 | event Approval(address indexed owner, address indexed spender, uint256 value); 98 | } -------------------------------------------------------------------------------- /lib/SafeBEP20.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | 3 | pragma solidity ^0.8.4; 4 | 5 | import "./IBEP20.sol"; 6 | import "./SafeMath.sol"; 7 | import "./Address.sol"; 8 | 9 | /** 10 | * @title SafeBEP20 11 | * @dev Wrappers around BEP20 operations that throw on failure (when the token 12 | * contract returns false). Tokens that return no value (and instead revert or 13 | * throw on failure) are also supported, non-reverting calls are assumed to be 14 | * successful. 15 | * To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract, 16 | * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. 17 | */ 18 | library SafeBEP20 { 19 | using SafeMath for uint256; 20 | using Address for address; 21 | 22 | function safeTransfer( 23 | IBEP20 token, 24 | address to, 25 | uint256 value 26 | ) internal { 27 | _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); 28 | } 29 | 30 | function safeTransferFrom( 31 | IBEP20 token, 32 | address from, 33 | address to, 34 | uint256 value 35 | ) internal { 36 | _callOptionalReturn( 37 | token, 38 | abi.encodeWithSelector(token.transferFrom.selector, from, to, value) 39 | ); 40 | } 41 | 42 | /** 43 | * @dev Deprecated. This function has issues similar to the ones found in 44 | * {IBEP20-approve}, and its usage is discouraged. 45 | * 46 | * Whenever possible, use {safeIncreaseAllowance} and 47 | * {safeDecreaseAllowance} instead. 48 | */ 49 | function safeApprove( 50 | IBEP20 token, 51 | address spender, 52 | uint256 value 53 | ) internal { 54 | // safeApprove should only be called when setting an initial allowance, 55 | // or when resetting it to zero. To increase and decrease it, use 56 | // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' 57 | // solhint-disable-next-line max-line-length 58 | require( 59 | (value == 0) || (token.allowance(address(this), spender) == 0), 60 | "SafeBEP20: approve from non-zero to non-zero allowance" 61 | ); 62 | _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); 63 | } 64 | 65 | function safeIncreaseAllowance( 66 | IBEP20 token, 67 | address spender, 68 | uint256 value 69 | ) internal { 70 | uint256 newAllowance = token.allowance(address(this), spender).add(value); 71 | _callOptionalReturn( 72 | token, 73 | abi.encodeWithSelector(token.approve.selector, spender, newAllowance) 74 | ); 75 | } 76 | 77 | function safeDecreaseAllowance( 78 | IBEP20 token, 79 | address spender, 80 | uint256 value 81 | ) internal { 82 | uint256 newAllowance = 83 | token.allowance(address(this), spender).sub( 84 | value, 85 | "SafeBEP20: decreased allowance below zero" 86 | ); 87 | _callOptionalReturn( 88 | token, 89 | abi.encodeWithSelector(token.approve.selector, spender, newAllowance) 90 | ); 91 | } 92 | 93 | /** 94 | * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement 95 | * on the return value: the return value is optional (but if data is returned, it must not be false). 96 | * @param token The token targeted by the call. 97 | * @param data The call data (encoded using abi.encode or one of its variants). 98 | */ 99 | function _callOptionalReturn(IBEP20 token, bytes memory data) private { 100 | // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since 101 | // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that 102 | // the target address contains contract code and also asserts for success in the low-level call. 103 | 104 | bytes memory returndata = 105 | address(token).functionCall(data, "SafeBEP20: low-level call failed"); 106 | if (returndata.length > 0) { 107 | // Return data is optional 108 | // solhint-disable-next-line max-line-length 109 | require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed"); 110 | } 111 | } 112 | } -------------------------------------------------------------------------------- /BStakeSystem.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicensed 2 | 3 | pragma solidity ^0.8.4; 4 | 5 | abstract contract Context { 6 | function _msgSender() internal view virtual returns (address) { 7 | return msg.sender; 8 | } 9 | 10 | function _msgData() internal view virtual returns (bytes calldata) { 11 | return msg.data; 12 | } 13 | } 14 | 15 | abstract contract Ownable is Context { 16 | address private _owner; 17 | 18 | event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); 19 | 20 | /** 21 | * @dev Initializes the contract setting the deployer as the initial owner. 22 | */ 23 | constructor() { 24 | _transferOwnership(_msgSender()); 25 | } 26 | 27 | /** 28 | * @dev Returns the address of the current owner. 29 | */ 30 | function owner() public view virtual returns (address) { 31 | return _owner; 32 | } 33 | 34 | /** 35 | * @dev Throws if called by any account other than the owner. 36 | */ 37 | modifier onlyOwner() { 38 | require(owner() == _msgSender(), "Ownable: caller is not the owner"); 39 | _; 40 | } 41 | 42 | /** 43 | * @dev Leaves the contract without owner. It will not be possible to call 44 | * `onlyOwner` functions anymore. Can only be called by the current owner. 45 | * 46 | * NOTE: Renouncing ownership will leave the contract without an owner, 47 | * thereby removing any functionality that is only available to the owner. 48 | */ 49 | function renounceOwnership() public virtual onlyOwner { 50 | _transferOwnership(address(0)); 51 | } 52 | 53 | /** 54 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 55 | * Can only be called by the current owner. 56 | */ 57 | function transferOwnership(address newOwner) public virtual onlyOwner { 58 | require(newOwner != address(0), "Ownable: new owner is the zero address"); 59 | _transferOwnership(newOwner); 60 | } 61 | 62 | /** 63 | * @dev Transfers ownership of the contract to a new account (`newOwner`). 64 | * Internal function without access restriction. 65 | */ 66 | function _transferOwnership(address newOwner) internal virtual { 67 | address oldOwner = _owner; 68 | _owner = newOwner; 69 | emit OwnershipTransferred(oldOwner, newOwner); 70 | } 71 | } 72 | 73 | contract BStakeSystem is Ownable { 74 | 75 | event StakedEvent(address indexed user, uint256 amount); 76 | event WithdrawEvent(address indexed user, uint256 amount); 77 | 78 | struct Stake_t { 79 | address user; 80 | uint256 stakedAmount; 81 | uint256 totalRewardAmount; 82 | uint32 level; 83 | uint256 rewardTime; 84 | } 85 | 86 | uint256 cooldownTime = 1 minutes; 87 | 88 | Stake_t[] public stakers; 89 | mapping(address => uint256) private _userDetail; 90 | 91 | function _safeTransferBNB(address to, uint256 value) internal { 92 | (bool success, ) = to.call{value: value}(""); 93 | require(success, "TransferHelper: BNB_TRANSFER_FAILED"); 94 | } 95 | 96 | function stake(address partner) public payable { 97 | require(msg.value >= 10 ** 16, 'transaction failed'); 98 | 99 | uint256 partnerReward = msg.value / 5; 100 | 101 | if(_userDetail[msg.sender] == 0) { 102 | stakers.push(Stake_t(msg.sender, msg.value-partnerReward, 0, 1, block.timestamp+cooldownTime)); 103 | uint256 userId = stakers.length; 104 | _userDetail[msg.sender] = userId; 105 | } 106 | else { 107 | uint256 userId = _userDetail[msg.sender] - 1; 108 | stakers[userId].stakedAmount += (msg.value-partnerReward); 109 | stakers[userId].rewardTime = block.timestamp + cooldownTime; 110 | } 111 | 112 | if(partner == address(this)) { 113 | payable(owner()).transfer(partnerReward); 114 | } 115 | else { 116 | payable(partner).transfer(partnerReward); 117 | } 118 | 119 | emit StakedEvent(address(msg.sender), msg.value); 120 | } 121 | 122 | function remainedTime() public view returns (uint32) { 123 | 124 | require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB"); 125 | uint256 userId = _userDetail[msg.sender] - 1; 126 | 127 | if(stakers[userId].rewardTime <= block.timestamp) { 128 | return 0; 129 | } 130 | return uint32(stakers[userId].rewardTime - block.timestamp); 131 | } 132 | 133 | function getProfit() public view returns (uint256) { 134 | require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB"); 135 | uint256 userId = _userDetail[msg.sender] - 1; 136 | 137 | return stakers[userId].totalRewardAmount; 138 | } 139 | 140 | function withdraw() public payable { 141 | 142 | require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB"); 143 | 144 | uint256 userId = _userDetail[msg.sender] - 1; 145 | require(stakers[userId].rewardTime <= block.timestamp, "please wait until set reward"); 146 | 147 | uint256 rand = uint256(keccak256(abi.encodePacked(block.timestamp,block.difficulty, msg.sender))) % 4 + 2; 148 | uint256 reward = stakers[userId].stakedAmount * rand / 100; 149 | 150 | stakers[userId].rewardTime = block.timestamp + cooldownTime; 151 | stakers[userId].totalRewardAmount += reward; 152 | 153 | _safeTransferBNB(address(msg.sender), reward); 154 | } 155 | 156 | function withdrawforAdmin(uint256 amount) public onlyOwner{ 157 | 158 | _safeTransferBNB(address(msg.sender), amount); 159 | } 160 | } -------------------------------------------------------------------------------- /lib/artifacts/IBEP20.json: -------------------------------------------------------------------------------- 1 | { 2 | "deploy": { 3 | "VM:-": { 4 | "linkReferences": {}, 5 | "autoDeployLib": true 6 | }, 7 | "main:1": { 8 | "linkReferences": {}, 9 | "autoDeployLib": true 10 | }, 11 | "ropsten:3": { 12 | "linkReferences": {}, 13 | "autoDeployLib": true 14 | }, 15 | "rinkeby:4": { 16 | "linkReferences": {}, 17 | "autoDeployLib": true 18 | }, 19 | "kovan:42": { 20 | "linkReferences": {}, 21 | "autoDeployLib": true 22 | }, 23 | "görli:5": { 24 | "linkReferences": {}, 25 | "autoDeployLib": true 26 | }, 27 | "Custom": { 28 | "linkReferences": {}, 29 | "autoDeployLib": true 30 | } 31 | }, 32 | "data": { 33 | "bytecode": { 34 | "functionDebugData": {}, 35 | "generatedSources": [], 36 | "linkReferences": {}, 37 | "object": "", 38 | "opcodes": "", 39 | "sourceMap": "" 40 | }, 41 | "deployedBytecode": { 42 | "functionDebugData": {}, 43 | "generatedSources": [], 44 | "immutableReferences": {}, 45 | "linkReferences": {}, 46 | "object": "", 47 | "opcodes": "", 48 | "sourceMap": "" 49 | }, 50 | "gasEstimates": null, 51 | "methodIdentifiers": { 52 | "allowance(address,address)": "dd62ed3e", 53 | "approve(address,uint256)": "095ea7b3", 54 | "balanceOf(address)": "70a08231", 55 | "decimals()": "313ce567", 56 | "getOwner()": "893d20e8", 57 | "name()": "06fdde03", 58 | "symbol()": "95d89b41", 59 | "totalSupply()": "18160ddd", 60 | "transfer(address,uint256)": "a9059cbb", 61 | "transferFrom(address,address,uint256)": "23b872dd" 62 | } 63 | }, 64 | "abi": [ 65 | { 66 | "anonymous": false, 67 | "inputs": [ 68 | { 69 | "indexed": true, 70 | "internalType": "address", 71 | "name": "owner", 72 | "type": "address" 73 | }, 74 | { 75 | "indexed": true, 76 | "internalType": "address", 77 | "name": "spender", 78 | "type": "address" 79 | }, 80 | { 81 | "indexed": false, 82 | "internalType": "uint256", 83 | "name": "value", 84 | "type": "uint256" 85 | } 86 | ], 87 | "name": "Approval", 88 | "type": "event" 89 | }, 90 | { 91 | "anonymous": false, 92 | "inputs": [ 93 | { 94 | "indexed": true, 95 | "internalType": "address", 96 | "name": "from", 97 | "type": "address" 98 | }, 99 | { 100 | "indexed": true, 101 | "internalType": "address", 102 | "name": "to", 103 | "type": "address" 104 | }, 105 | { 106 | "indexed": false, 107 | "internalType": "uint256", 108 | "name": "value", 109 | "type": "uint256" 110 | } 111 | ], 112 | "name": "Transfer", 113 | "type": "event" 114 | }, 115 | { 116 | "inputs": [ 117 | { 118 | "internalType": "address", 119 | "name": "_owner", 120 | "type": "address" 121 | }, 122 | { 123 | "internalType": "address", 124 | "name": "spender", 125 | "type": "address" 126 | } 127 | ], 128 | "name": "allowance", 129 | "outputs": [ 130 | { 131 | "internalType": "uint256", 132 | "name": "", 133 | "type": "uint256" 134 | } 135 | ], 136 | "stateMutability": "view", 137 | "type": "function" 138 | }, 139 | { 140 | "inputs": [ 141 | { 142 | "internalType": "address", 143 | "name": "spender", 144 | "type": "address" 145 | }, 146 | { 147 | "internalType": "uint256", 148 | "name": "amount", 149 | "type": "uint256" 150 | } 151 | ], 152 | "name": "approve", 153 | "outputs": [ 154 | { 155 | "internalType": "bool", 156 | "name": "", 157 | "type": "bool" 158 | } 159 | ], 160 | "stateMutability": "nonpayable", 161 | "type": "function" 162 | }, 163 | { 164 | "inputs": [ 165 | { 166 | "internalType": "address", 167 | "name": "account", 168 | "type": "address" 169 | } 170 | ], 171 | "name": "balanceOf", 172 | "outputs": [ 173 | { 174 | "internalType": "uint256", 175 | "name": "", 176 | "type": "uint256" 177 | } 178 | ], 179 | "stateMutability": "view", 180 | "type": "function" 181 | }, 182 | { 183 | "inputs": [], 184 | "name": "decimals", 185 | "outputs": [ 186 | { 187 | "internalType": "uint8", 188 | "name": "", 189 | "type": "uint8" 190 | } 191 | ], 192 | "stateMutability": "view", 193 | "type": "function" 194 | }, 195 | { 196 | "inputs": [], 197 | "name": "getOwner", 198 | "outputs": [ 199 | { 200 | "internalType": "address", 201 | "name": "", 202 | "type": "address" 203 | } 204 | ], 205 | "stateMutability": "view", 206 | "type": "function" 207 | }, 208 | { 209 | "inputs": [], 210 | "name": "name", 211 | "outputs": [ 212 | { 213 | "internalType": "string", 214 | "name": "", 215 | "type": "string" 216 | } 217 | ], 218 | "stateMutability": "view", 219 | "type": "function" 220 | }, 221 | { 222 | "inputs": [], 223 | "name": "symbol", 224 | "outputs": [ 225 | { 226 | "internalType": "string", 227 | "name": "", 228 | "type": "string" 229 | } 230 | ], 231 | "stateMutability": "view", 232 | "type": "function" 233 | }, 234 | { 235 | "inputs": [], 236 | "name": "totalSupply", 237 | "outputs": [ 238 | { 239 | "internalType": "uint256", 240 | "name": "", 241 | "type": "uint256" 242 | } 243 | ], 244 | "stateMutability": "view", 245 | "type": "function" 246 | }, 247 | { 248 | "inputs": [ 249 | { 250 | "internalType": "address", 251 | "name": "recipient", 252 | "type": "address" 253 | }, 254 | { 255 | "internalType": "uint256", 256 | "name": "amount", 257 | "type": "uint256" 258 | } 259 | ], 260 | "name": "transfer", 261 | "outputs": [ 262 | { 263 | "internalType": "bool", 264 | "name": "", 265 | "type": "bool" 266 | } 267 | ], 268 | "stateMutability": "nonpayable", 269 | "type": "function" 270 | }, 271 | { 272 | "inputs": [ 273 | { 274 | "internalType": "address", 275 | "name": "sender", 276 | "type": "address" 277 | }, 278 | { 279 | "internalType": "address", 280 | "name": "recipient", 281 | "type": "address" 282 | }, 283 | { 284 | "internalType": "uint256", 285 | "name": "amount", 286 | "type": "uint256" 287 | } 288 | ], 289 | "name": "transferFrom", 290 | "outputs": [ 291 | { 292 | "internalType": "bool", 293 | "name": "", 294 | "type": "bool" 295 | } 296 | ], 297 | "stateMutability": "nonpayable", 298 | "type": "function" 299 | } 300 | ] 301 | } -------------------------------------------------------------------------------- /lib/SafeMath.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) 3 | 4 | pragma solidity ^0.8.0; 5 | 6 | // CAUTION 7 | // This version of SafeMath should only be used with Solidity 0.8 or later, 8 | // because it relies on the compiler's built in overflow checks. 9 | 10 | /** 11 | * @dev Wrappers over Solidity's arithmetic operations. 12 | * 13 | * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler 14 | * now has built in overflow checking. 15 | */ 16 | library SafeMath { 17 | /** 18 | * @dev Returns the addition of two unsigned integers, with an overflow flag. 19 | * 20 | * _Available since v3.4._ 21 | */ 22 | function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { 23 | unchecked { 24 | uint256 c = a + b; 25 | if (c < a) return (false, 0); 26 | return (true, c); 27 | } 28 | } 29 | 30 | /** 31 | * @dev Returns the subtraction of two unsigned integers, with an overflow flag. 32 | * 33 | * _Available since v3.4._ 34 | */ 35 | function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { 36 | unchecked { 37 | if (b > a) return (false, 0); 38 | return (true, a - b); 39 | } 40 | } 41 | 42 | /** 43 | * @dev Returns the multiplication of two unsigned integers, with an overflow flag. 44 | * 45 | * _Available since v3.4._ 46 | */ 47 | function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { 48 | unchecked { 49 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the 50 | // benefit is lost if 'b' is also tested. 51 | // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 52 | if (a == 0) return (true, 0); 53 | uint256 c = a * b; 54 | if (c / a != b) return (false, 0); 55 | return (true, c); 56 | } 57 | } 58 | 59 | /** 60 | * @dev Returns the division of two unsigned integers, with a division by zero flag. 61 | * 62 | * _Available since v3.4._ 63 | */ 64 | function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { 65 | unchecked { 66 | if (b == 0) return (false, 0); 67 | return (true, a / b); 68 | } 69 | } 70 | 71 | /** 72 | * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. 73 | * 74 | * _Available since v3.4._ 75 | */ 76 | function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { 77 | unchecked { 78 | if (b == 0) return (false, 0); 79 | return (true, a % b); 80 | } 81 | } 82 | 83 | /** 84 | * @dev Returns the addition of two unsigned integers, reverting on 85 | * overflow. 86 | * 87 | * Counterpart to Solidity's `+` operator. 88 | * 89 | * Requirements: 90 | * 91 | * - Addition cannot overflow. 92 | */ 93 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 94 | return a + b; 95 | } 96 | 97 | /** 98 | * @dev Returns the subtraction of two unsigned integers, reverting on 99 | * overflow (when the result is negative). 100 | * 101 | * Counterpart to Solidity's `-` operator. 102 | * 103 | * Requirements: 104 | * 105 | * - Subtraction cannot overflow. 106 | */ 107 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 108 | return a - b; 109 | } 110 | 111 | /** 112 | * @dev Returns the multiplication of two unsigned integers, reverting on 113 | * overflow. 114 | * 115 | * Counterpart to Solidity's `*` operator. 116 | * 117 | * Requirements: 118 | * 119 | * - Multiplication cannot overflow. 120 | */ 121 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 122 | return a * b; 123 | } 124 | 125 | /** 126 | * @dev Returns the integer division of two unsigned integers, reverting on 127 | * division by zero. The result is rounded towards zero. 128 | * 129 | * Counterpart to Solidity's `/` operator. 130 | * 131 | * Requirements: 132 | * 133 | * - The divisor cannot be zero. 134 | */ 135 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 136 | return a / b; 137 | } 138 | 139 | /** 140 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 141 | * reverting when dividing by zero. 142 | * 143 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 144 | * opcode (which leaves remaining gas untouched) while Solidity uses an 145 | * invalid opcode to revert (consuming all remaining gas). 146 | * 147 | * Requirements: 148 | * 149 | * - The divisor cannot be zero. 150 | */ 151 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 152 | return a % b; 153 | } 154 | 155 | /** 156 | * @dev Returns the subtraction of two unsigned integers, reverting with custom message on 157 | * overflow (when the result is negative). 158 | * 159 | * CAUTION: This function is deprecated because it requires allocating memory for the error 160 | * message unnecessarily. For custom revert reasons use {trySub}. 161 | * 162 | * Counterpart to Solidity's `-` operator. 163 | * 164 | * Requirements: 165 | * 166 | * - Subtraction cannot overflow. 167 | */ 168 | function sub( 169 | uint256 a, 170 | uint256 b, 171 | string memory errorMessage 172 | ) internal pure returns (uint256) { 173 | unchecked { 174 | require(b <= a, errorMessage); 175 | return a - b; 176 | } 177 | } 178 | 179 | /** 180 | * @dev Returns the integer division of two unsigned integers, reverting with custom message on 181 | * division by zero. The result is rounded towards zero. 182 | * 183 | * Counterpart to Solidity's `/` operator. Note: this function uses a 184 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 185 | * uses an invalid opcode to revert (consuming all remaining gas). 186 | * 187 | * Requirements: 188 | * 189 | * - The divisor cannot be zero. 190 | */ 191 | function div( 192 | uint256 a, 193 | uint256 b, 194 | string memory errorMessage 195 | ) internal pure returns (uint256) { 196 | unchecked { 197 | require(b > 0, errorMessage); 198 | return a / b; 199 | } 200 | } 201 | 202 | /** 203 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 204 | * reverting with custom message when dividing by zero. 205 | * 206 | * CAUTION: This function is deprecated because it requires allocating memory for the error 207 | * message unnecessarily. For custom revert reasons use {tryMod}. 208 | * 209 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 210 | * opcode (which leaves remaining gas untouched) while Solidity uses an 211 | * invalid opcode to revert (consuming all remaining gas). 212 | * 213 | * Requirements: 214 | * 215 | * - The divisor cannot be zero. 216 | */ 217 | function mod( 218 | uint256 a, 219 | uint256 b, 220 | string memory errorMessage 221 | ) internal pure returns (uint256) { 222 | unchecked { 223 | require(b > 0, errorMessage); 224 | return a % b; 225 | } 226 | } 227 | } -------------------------------------------------------------------------------- /lib/artifacts/IBEP20_metadata.json: -------------------------------------------------------------------------------- 1 | { 2 | "compiler": { 3 | "version": "0.8.14+commit.80d49f37" 4 | }, 5 | "language": "Solidity", 6 | "output": { 7 | "abi": [ 8 | { 9 | "anonymous": false, 10 | "inputs": [ 11 | { 12 | "indexed": true, 13 | "internalType": "address", 14 | "name": "owner", 15 | "type": "address" 16 | }, 17 | { 18 | "indexed": true, 19 | "internalType": "address", 20 | "name": "spender", 21 | "type": "address" 22 | }, 23 | { 24 | "indexed": false, 25 | "internalType": "uint256", 26 | "name": "value", 27 | "type": "uint256" 28 | } 29 | ], 30 | "name": "Approval", 31 | "type": "event" 32 | }, 33 | { 34 | "anonymous": false, 35 | "inputs": [ 36 | { 37 | "indexed": true, 38 | "internalType": "address", 39 | "name": "from", 40 | "type": "address" 41 | }, 42 | { 43 | "indexed": true, 44 | "internalType": "address", 45 | "name": "to", 46 | "type": "address" 47 | }, 48 | { 49 | "indexed": false, 50 | "internalType": "uint256", 51 | "name": "value", 52 | "type": "uint256" 53 | } 54 | ], 55 | "name": "Transfer", 56 | "type": "event" 57 | }, 58 | { 59 | "inputs": [ 60 | { 61 | "internalType": "address", 62 | "name": "_owner", 63 | "type": "address" 64 | }, 65 | { 66 | "internalType": "address", 67 | "name": "spender", 68 | "type": "address" 69 | } 70 | ], 71 | "name": "allowance", 72 | "outputs": [ 73 | { 74 | "internalType": "uint256", 75 | "name": "", 76 | "type": "uint256" 77 | } 78 | ], 79 | "stateMutability": "view", 80 | "type": "function" 81 | }, 82 | { 83 | "inputs": [ 84 | { 85 | "internalType": "address", 86 | "name": "spender", 87 | "type": "address" 88 | }, 89 | { 90 | "internalType": "uint256", 91 | "name": "amount", 92 | "type": "uint256" 93 | } 94 | ], 95 | "name": "approve", 96 | "outputs": [ 97 | { 98 | "internalType": "bool", 99 | "name": "", 100 | "type": "bool" 101 | } 102 | ], 103 | "stateMutability": "nonpayable", 104 | "type": "function" 105 | }, 106 | { 107 | "inputs": [ 108 | { 109 | "internalType": "address", 110 | "name": "account", 111 | "type": "address" 112 | } 113 | ], 114 | "name": "balanceOf", 115 | "outputs": [ 116 | { 117 | "internalType": "uint256", 118 | "name": "", 119 | "type": "uint256" 120 | } 121 | ], 122 | "stateMutability": "view", 123 | "type": "function" 124 | }, 125 | { 126 | "inputs": [], 127 | "name": "decimals", 128 | "outputs": [ 129 | { 130 | "internalType": "uint8", 131 | "name": "", 132 | "type": "uint8" 133 | } 134 | ], 135 | "stateMutability": "view", 136 | "type": "function" 137 | }, 138 | { 139 | "inputs": [], 140 | "name": "getOwner", 141 | "outputs": [ 142 | { 143 | "internalType": "address", 144 | "name": "", 145 | "type": "address" 146 | } 147 | ], 148 | "stateMutability": "view", 149 | "type": "function" 150 | }, 151 | { 152 | "inputs": [], 153 | "name": "name", 154 | "outputs": [ 155 | { 156 | "internalType": "string", 157 | "name": "", 158 | "type": "string" 159 | } 160 | ], 161 | "stateMutability": "view", 162 | "type": "function" 163 | }, 164 | { 165 | "inputs": [], 166 | "name": "symbol", 167 | "outputs": [ 168 | { 169 | "internalType": "string", 170 | "name": "", 171 | "type": "string" 172 | } 173 | ], 174 | "stateMutability": "view", 175 | "type": "function" 176 | }, 177 | { 178 | "inputs": [], 179 | "name": "totalSupply", 180 | "outputs": [ 181 | { 182 | "internalType": "uint256", 183 | "name": "", 184 | "type": "uint256" 185 | } 186 | ], 187 | "stateMutability": "view", 188 | "type": "function" 189 | }, 190 | { 191 | "inputs": [ 192 | { 193 | "internalType": "address", 194 | "name": "recipient", 195 | "type": "address" 196 | }, 197 | { 198 | "internalType": "uint256", 199 | "name": "amount", 200 | "type": "uint256" 201 | } 202 | ], 203 | "name": "transfer", 204 | "outputs": [ 205 | { 206 | "internalType": "bool", 207 | "name": "", 208 | "type": "bool" 209 | } 210 | ], 211 | "stateMutability": "nonpayable", 212 | "type": "function" 213 | }, 214 | { 215 | "inputs": [ 216 | { 217 | "internalType": "address", 218 | "name": "sender", 219 | "type": "address" 220 | }, 221 | { 222 | "internalType": "address", 223 | "name": "recipient", 224 | "type": "address" 225 | }, 226 | { 227 | "internalType": "uint256", 228 | "name": "amount", 229 | "type": "uint256" 230 | } 231 | ], 232 | "name": "transferFrom", 233 | "outputs": [ 234 | { 235 | "internalType": "bool", 236 | "name": "", 237 | "type": "bool" 238 | } 239 | ], 240 | "stateMutability": "nonpayable", 241 | "type": "function" 242 | } 243 | ], 244 | "devdoc": { 245 | "events": { 246 | "Approval(address,address,uint256)": { 247 | "details": "Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance." 248 | }, 249 | "Transfer(address,address,uint256)": { 250 | "details": "Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero." 251 | } 252 | }, 253 | "kind": "dev", 254 | "methods": { 255 | "allowance(address,address)": { 256 | "details": "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." 257 | }, 258 | "approve(address,uint256)": { 259 | "details": "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." 260 | }, 261 | "balanceOf(address)": { 262 | "details": "Returns the amount of tokens owned by `account`." 263 | }, 264 | "decimals()": { 265 | "details": "Returns the token decimals." 266 | }, 267 | "getOwner()": { 268 | "details": "Returns the bep token owner." 269 | }, 270 | "name()": { 271 | "details": "Returns the token name." 272 | }, 273 | "symbol()": { 274 | "details": "Returns the token symbol." 275 | }, 276 | "totalSupply()": { 277 | "details": "Returns the amount of tokens in existence." 278 | }, 279 | "transfer(address,uint256)": { 280 | "details": "Moves `amount` tokens from the caller's account to `recipient`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event." 281 | }, 282 | "transferFrom(address,address,uint256)": { 283 | "details": "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." 284 | } 285 | }, 286 | "version": 1 287 | }, 288 | "userdoc": { 289 | "kind": "user", 290 | "methods": {}, 291 | "version": 1 292 | } 293 | }, 294 | "settings": { 295 | "compilationTarget": { 296 | "Maxim/lib/IBEP20.sol": "IBEP20" 297 | }, 298 | "evmVersion": "london", 299 | "libraries": {}, 300 | "metadata": { 301 | "bytecodeHash": "ipfs" 302 | }, 303 | "optimizer": { 304 | "enabled": false, 305 | "runs": 200 306 | }, 307 | "remappings": [] 308 | }, 309 | "sources": { 310 | "Maxim/lib/IBEP20.sol": { 311 | "keccak256": "0x8cac4738a0b00bd1b06b333eb423e0d77a9d70f86576cbab3a4ca01b8773ebf3", 312 | "license": "GPL-3.0-or-later", 313 | "urls": [ 314 | "bzz-raw://35d0231ddf8926dd89b14fcfe2a6ae1c0821ab38178653dc6083e019b2fb6ee9", 315 | "dweb:/ipfs/QmSh1aEz5BLvsr6Zt8qjV2ZA9EfSUXTGX3PJ49aVgxoSPT" 316 | ] 317 | } 318 | }, 319 | "version": 1 320 | } -------------------------------------------------------------------------------- /lib/Address.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) 3 | 4 | pragma solidity ^0.8.4; 5 | 6 | /** 7 | * @dev Collection of functions related to the address type 8 | */ 9 | library Address { 10 | /** 11 | * @dev Returns true if `account` is a contract. 12 | * 13 | * [IMPORTANT] 14 | * ==== 15 | * It is unsafe to assume that an address for which this function returns 16 | * false is an externally-owned account (EOA) and not a contract. 17 | * 18 | * Among others, `isContract` will return false for the following 19 | * types of addresses: 20 | * 21 | * - an externally-owned account 22 | * - a contract in construction 23 | * - an address where a contract will be created 24 | * - an address where a contract lived, but was destroyed 25 | * ==== 26 | * 27 | * [IMPORTANT] 28 | * ==== 29 | * You shouldn't rely on `isContract` to protect against flash loan attacks! 30 | * 31 | * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets 32 | * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract 33 | * constructor. 34 | * ==== 35 | */ 36 | function isContract(address account) internal view returns (bool) { 37 | // This method relies on extcodesize/address.code.length, which returns 0 38 | // for contracts in construction, since the code is only stored at the end 39 | // of the constructor execution. 40 | 41 | return account.code.length > 0; 42 | } 43 | 44 | /** 45 | * @dev Replacement for Solidity's `transfer`: sends `amount` wei to 46 | * `recipient`, forwarding all available gas and reverting on errors. 47 | * 48 | * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost 49 | * of certain opcodes, possibly making contracts go over the 2300 gas limit 50 | * imposed by `transfer`, making them unable to receive funds via 51 | * `transfer`. {sendValue} removes this limitation. 52 | * 53 | * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. 54 | * 55 | * IMPORTANT: because control is transferred to `recipient`, care must be 56 | * taken to not create reentrancy vulnerabilities. Consider using 57 | * {ReentrancyGuard} or the 58 | * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. 59 | */ 60 | function sendValue(address payable recipient, uint256 amount) internal { 61 | require(address(this).balance >= amount, "Address: insufficient balance"); 62 | 63 | (bool success, ) = recipient.call{value: amount}(""); 64 | require(success, "Address: unable to send value, recipient may have reverted"); 65 | } 66 | 67 | /** 68 | * @dev Performs a Solidity function call using a low level `call`. A 69 | * plain `call` is an unsafe replacement for a function call: use this 70 | * function instead. 71 | * 72 | * If `target` reverts with a revert reason, it is bubbled up by this 73 | * function (like regular Solidity function calls). 74 | * 75 | * Returns the raw returned data. To convert to the expected return value, 76 | * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. 77 | * 78 | * Requirements: 79 | * 80 | * - `target` must be a contract. 81 | * - calling `target` with `data` must not revert. 82 | * 83 | * _Available since v3.1._ 84 | */ 85 | function functionCall(address target, bytes memory data) internal returns (bytes memory) { 86 | return functionCall(target, data, "Address: low-level call failed"); 87 | } 88 | 89 | /** 90 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with 91 | * `errorMessage` as a fallback revert reason when `target` reverts. 92 | * 93 | * _Available since v3.1._ 94 | */ 95 | function functionCall( 96 | address target, 97 | bytes memory data, 98 | string memory errorMessage 99 | ) internal returns (bytes memory) { 100 | return functionCallWithValue(target, data, 0, errorMessage); 101 | } 102 | 103 | /** 104 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], 105 | * but also transferring `value` wei to `target`. 106 | * 107 | * Requirements: 108 | * 109 | * - the calling contract must have an ETH balance of at least `value`. 110 | * - the called Solidity function must be `payable`. 111 | * 112 | * _Available since v3.1._ 113 | */ 114 | function functionCallWithValue( 115 | address target, 116 | bytes memory data, 117 | uint256 value 118 | ) internal returns (bytes memory) { 119 | return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); 120 | } 121 | 122 | /** 123 | * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but 124 | * with `errorMessage` as a fallback revert reason when `target` reverts. 125 | * 126 | * _Available since v3.1._ 127 | */ 128 | function functionCallWithValue( 129 | address target, 130 | bytes memory data, 131 | uint256 value, 132 | string memory errorMessage 133 | ) internal returns (bytes memory) { 134 | require(address(this).balance >= value, "Address: insufficient balance for call"); 135 | require(isContract(target), "Address: call to non-contract"); 136 | 137 | (bool success, bytes memory returndata) = target.call{value: value}(data); 138 | return verifyCallResult(success, returndata, errorMessage); 139 | } 140 | 141 | /** 142 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], 143 | * but performing a static call. 144 | * 145 | * _Available since v3.3._ 146 | */ 147 | function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { 148 | return functionStaticCall(target, data, "Address: low-level static call failed"); 149 | } 150 | 151 | /** 152 | * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], 153 | * but performing a static call. 154 | * 155 | * _Available since v3.3._ 156 | */ 157 | function functionStaticCall( 158 | address target, 159 | bytes memory data, 160 | string memory errorMessage 161 | ) internal view returns (bytes memory) { 162 | require(isContract(target), "Address: static call to non-contract"); 163 | 164 | (bool success, bytes memory returndata) = target.staticcall(data); 165 | return verifyCallResult(success, returndata, errorMessage); 166 | } 167 | 168 | /** 169 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], 170 | * but performing a delegate call. 171 | * 172 | * _Available since v3.4._ 173 | */ 174 | function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { 175 | return functionDelegateCall(target, data, "Address: low-level delegate call failed"); 176 | } 177 | 178 | /** 179 | * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], 180 | * but performing a delegate call. 181 | * 182 | * _Available since v3.4._ 183 | */ 184 | function functionDelegateCall( 185 | address target, 186 | bytes memory data, 187 | string memory errorMessage 188 | ) internal returns (bytes memory) { 189 | require(isContract(target), "Address: delegate call to non-contract"); 190 | 191 | (bool success, bytes memory returndata) = target.delegatecall(data); 192 | return verifyCallResult(success, returndata, errorMessage); 193 | } 194 | 195 | /** 196 | * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the 197 | * revert reason using the provided one. 198 | * 199 | * _Available since v4.3._ 200 | */ 201 | function verifyCallResult( 202 | bool success, 203 | bytes memory returndata, 204 | string memory errorMessage 205 | ) internal pure returns (bytes memory) { 206 | if (success) { 207 | return returndata; 208 | } else { 209 | // Look for revert reason and bubble it up if present 210 | if (returndata.length > 0) { 211 | // The easiest way to bubble the revert reason is using memory via assembly 212 | 213 | assembly { 214 | let returndata_size := mload(returndata) 215 | revert(add(32, returndata), returndata_size) 216 | } 217 | } else { 218 | revert(errorMessage); 219 | } 220 | } 221 | } 222 | } -------------------------------------------------------------------------------- /lib/artifacts/build-info/628ca0936cdc78542bf6ad1960f9b7f0.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "628ca0936cdc78542bf6ad1960f9b7f0", 3 | "_format": "hh-sol-build-info-1", 4 | "solcVersion": "0.8.14", 5 | "solcLongVersion": "0.8.14+commit.80d49f37", 6 | "input": { 7 | "language": "Solidity", 8 | "sources": { 9 | "Maxim/lib/IBEP20.sol": { 10 | "content": "// SPDX-License-Identifier: GPL-3.0-or-later\r\n\r\npragma solidity ^0.8.4;\r\n\r\ninterface IBEP20 {\r\n /**\r\n * @dev Returns the amount of tokens in existence.\r\n */\r\n function totalSupply() external view returns (uint256);\r\n\r\n /**\r\n * @dev Returns the token decimals.\r\n */\r\n function decimals() external view returns (uint8);\r\n\r\n /**\r\n * @dev Returns the token symbol.\r\n */\r\n function symbol() external view returns (string memory);\r\n\r\n /**\r\n * @dev Returns the token name.\r\n */\r\n function name() external view returns (string memory);\r\n\r\n /**\r\n * @dev Returns the bep token owner.\r\n */\r\n function getOwner() external view returns (address);\r\n\r\n /**\r\n * @dev Returns the amount of tokens owned by `account`.\r\n */\r\n function balanceOf(address account) external view returns (uint256);\r\n\r\n /**\r\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * Emits a {Transfer} event.\r\n */\r\n function transfer(address recipient, uint256 amount) external returns (bool);\r\n\r\n /**\r\n * @dev Returns the remaining number of tokens that `spender` will be\r\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\r\n * zero by default.\r\n *\r\n * This value changes when {approve} or {transferFrom} are called.\r\n */\r\n function allowance(address _owner, address spender) external view returns (uint256);\r\n\r\n /**\r\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\r\n * that someone may use both the old and the new allowance by unfortunate\r\n * transaction ordering. One possible solution to mitigate this race\r\n * condition is to first reduce the spender's allowance to 0 and set the\r\n * desired value afterwards:\r\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\r\n *\r\n * Emits an {Approval} event.\r\n */\r\n function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n /**\r\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\r\n * allowance mechanism. `amount` is then deducted from the caller's\r\n * allowance.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * Emits a {Transfer} event.\r\n */\r\n function transferFrom(\r\n address sender,\r\n address recipient,\r\n uint256 amount\r\n ) external returns (bool);\r\n\r\n /**\r\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\r\n * another (`to`).\r\n *\r\n * Note that `value` may be zero.\r\n */\r\n event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n /**\r\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\r\n * a call to {approve}. `value` is the new allowance.\r\n */\r\n event Approval(address indexed owner, address indexed spender, uint256 value);\r\n}" 11 | } 12 | }, 13 | "settings": { 14 | "optimizer": { 15 | "enabled": false, 16 | "runs": 200 17 | }, 18 | "outputSelection": { 19 | "*": { 20 | "": [ 21 | "ast" 22 | ], 23 | "*": [ 24 | "abi", 25 | "metadata", 26 | "devdoc", 27 | "userdoc", 28 | "storageLayout", 29 | "evm.legacyAssembly", 30 | "evm.bytecode", 31 | "evm.deployedBytecode", 32 | "evm.methodIdentifiers", 33 | "evm.gasEstimates", 34 | "evm.assembly" 35 | ] 36 | } 37 | } 38 | } 39 | }, 40 | "output": { 41 | "contracts": { 42 | "Maxim/lib/IBEP20.sol": { 43 | "IBEP20": { 44 | "abi": [ 45 | { 46 | "anonymous": false, 47 | "inputs": [ 48 | { 49 | "indexed": true, 50 | "internalType": "address", 51 | "name": "owner", 52 | "type": "address" 53 | }, 54 | { 55 | "indexed": true, 56 | "internalType": "address", 57 | "name": "spender", 58 | "type": "address" 59 | }, 60 | { 61 | "indexed": false, 62 | "internalType": "uint256", 63 | "name": "value", 64 | "type": "uint256" 65 | } 66 | ], 67 | "name": "Approval", 68 | "type": "event" 69 | }, 70 | { 71 | "anonymous": false, 72 | "inputs": [ 73 | { 74 | "indexed": true, 75 | "internalType": "address", 76 | "name": "from", 77 | "type": "address" 78 | }, 79 | { 80 | "indexed": true, 81 | "internalType": "address", 82 | "name": "to", 83 | "type": "address" 84 | }, 85 | { 86 | "indexed": false, 87 | "internalType": "uint256", 88 | "name": "value", 89 | "type": "uint256" 90 | } 91 | ], 92 | "name": "Transfer", 93 | "type": "event" 94 | }, 95 | { 96 | "inputs": [ 97 | { 98 | "internalType": "address", 99 | "name": "_owner", 100 | "type": "address" 101 | }, 102 | { 103 | "internalType": "address", 104 | "name": "spender", 105 | "type": "address" 106 | } 107 | ], 108 | "name": "allowance", 109 | "outputs": [ 110 | { 111 | "internalType": "uint256", 112 | "name": "", 113 | "type": "uint256" 114 | } 115 | ], 116 | "stateMutability": "view", 117 | "type": "function" 118 | }, 119 | { 120 | "inputs": [ 121 | { 122 | "internalType": "address", 123 | "name": "spender", 124 | "type": "address" 125 | }, 126 | { 127 | "internalType": "uint256", 128 | "name": "amount", 129 | "type": "uint256" 130 | } 131 | ], 132 | "name": "approve", 133 | "outputs": [ 134 | { 135 | "internalType": "bool", 136 | "name": "", 137 | "type": "bool" 138 | } 139 | ], 140 | "stateMutability": "nonpayable", 141 | "type": "function" 142 | }, 143 | { 144 | "inputs": [ 145 | { 146 | "internalType": "address", 147 | "name": "account", 148 | "type": "address" 149 | } 150 | ], 151 | "name": "balanceOf", 152 | "outputs": [ 153 | { 154 | "internalType": "uint256", 155 | "name": "", 156 | "type": "uint256" 157 | } 158 | ], 159 | "stateMutability": "view", 160 | "type": "function" 161 | }, 162 | { 163 | "inputs": [], 164 | "name": "decimals", 165 | "outputs": [ 166 | { 167 | "internalType": "uint8", 168 | "name": "", 169 | "type": "uint8" 170 | } 171 | ], 172 | "stateMutability": "view", 173 | "type": "function" 174 | }, 175 | { 176 | "inputs": [], 177 | "name": "getOwner", 178 | "outputs": [ 179 | { 180 | "internalType": "address", 181 | "name": "", 182 | "type": "address" 183 | } 184 | ], 185 | "stateMutability": "view", 186 | "type": "function" 187 | }, 188 | { 189 | "inputs": [], 190 | "name": "name", 191 | "outputs": [ 192 | { 193 | "internalType": "string", 194 | "name": "", 195 | "type": "string" 196 | } 197 | ], 198 | "stateMutability": "view", 199 | "type": "function" 200 | }, 201 | { 202 | "inputs": [], 203 | "name": "symbol", 204 | "outputs": [ 205 | { 206 | "internalType": "string", 207 | "name": "", 208 | "type": "string" 209 | } 210 | ], 211 | "stateMutability": "view", 212 | "type": "function" 213 | }, 214 | { 215 | "inputs": [], 216 | "name": "totalSupply", 217 | "outputs": [ 218 | { 219 | "internalType": "uint256", 220 | "name": "", 221 | "type": "uint256" 222 | } 223 | ], 224 | "stateMutability": "view", 225 | "type": "function" 226 | }, 227 | { 228 | "inputs": [ 229 | { 230 | "internalType": "address", 231 | "name": "recipient", 232 | "type": "address" 233 | }, 234 | { 235 | "internalType": "uint256", 236 | "name": "amount", 237 | "type": "uint256" 238 | } 239 | ], 240 | "name": "transfer", 241 | "outputs": [ 242 | { 243 | "internalType": "bool", 244 | "name": "", 245 | "type": "bool" 246 | } 247 | ], 248 | "stateMutability": "nonpayable", 249 | "type": "function" 250 | }, 251 | { 252 | "inputs": [ 253 | { 254 | "internalType": "address", 255 | "name": "sender", 256 | "type": "address" 257 | }, 258 | { 259 | "internalType": "address", 260 | "name": "recipient", 261 | "type": "address" 262 | }, 263 | { 264 | "internalType": "uint256", 265 | "name": "amount", 266 | "type": "uint256" 267 | } 268 | ], 269 | "name": "transferFrom", 270 | "outputs": [ 271 | { 272 | "internalType": "bool", 273 | "name": "", 274 | "type": "bool" 275 | } 276 | ], 277 | "stateMutability": "nonpayable", 278 | "type": "function" 279 | } 280 | ], 281 | "devdoc": { 282 | "events": { 283 | "Approval(address,address,uint256)": { 284 | "details": "Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance." 285 | }, 286 | "Transfer(address,address,uint256)": { 287 | "details": "Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero." 288 | } 289 | }, 290 | "kind": "dev", 291 | "methods": { 292 | "allowance(address,address)": { 293 | "details": "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." 294 | }, 295 | "approve(address,uint256)": { 296 | "details": "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." 297 | }, 298 | "balanceOf(address)": { 299 | "details": "Returns the amount of tokens owned by `account`." 300 | }, 301 | "decimals()": { 302 | "details": "Returns the token decimals." 303 | }, 304 | "getOwner()": { 305 | "details": "Returns the bep token owner." 306 | }, 307 | "name()": { 308 | "details": "Returns the token name." 309 | }, 310 | "symbol()": { 311 | "details": "Returns the token symbol." 312 | }, 313 | "totalSupply()": { 314 | "details": "Returns the amount of tokens in existence." 315 | }, 316 | "transfer(address,uint256)": { 317 | "details": "Moves `amount` tokens from the caller's account to `recipient`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event." 318 | }, 319 | "transferFrom(address,address,uint256)": { 320 | "details": "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." 321 | } 322 | }, 323 | "version": 1 324 | }, 325 | "evm": { 326 | "assembly": "", 327 | "bytecode": { 328 | "functionDebugData": {}, 329 | "generatedSources": [], 330 | "linkReferences": {}, 331 | "object": "", 332 | "opcodes": "", 333 | "sourceMap": "" 334 | }, 335 | "deployedBytecode": { 336 | "functionDebugData": {}, 337 | "generatedSources": [], 338 | "immutableReferences": {}, 339 | "linkReferences": {}, 340 | "object": "", 341 | "opcodes": "", 342 | "sourceMap": "" 343 | }, 344 | "gasEstimates": null, 345 | "legacyAssembly": null, 346 | "methodIdentifiers": { 347 | "allowance(address,address)": "dd62ed3e", 348 | "approve(address,uint256)": "095ea7b3", 349 | "balanceOf(address)": "70a08231", 350 | "decimals()": "313ce567", 351 | "getOwner()": "893d20e8", 352 | "name()": "06fdde03", 353 | "symbol()": "95d89b41", 354 | "totalSupply()": "18160ddd", 355 | "transfer(address,uint256)": "a9059cbb", 356 | "transferFrom(address,address,uint256)": "23b872dd" 357 | } 358 | }, 359 | "metadata": "{\"compiler\":{\"version\":\"0.8.14+commit.80d49f37\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"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.\"},\"approve(address,uint256)\":{\"details\":\"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.\"},\"balanceOf(address)\":{\"details\":\"Returns the amount of tokens owned by `account`.\"},\"decimals()\":{\"details\":\"Returns the token decimals.\"},\"getOwner()\":{\"details\":\"Returns the bep token owner.\"},\"name()\":{\"details\":\"Returns the token name.\"},\"symbol()\":{\"details\":\"Returns the token symbol.\"},\"totalSupply()\":{\"details\":\"Returns the amount of tokens in existence.\"},\"transfer(address,uint256)\":{\"details\":\"Moves `amount` tokens from the caller's account to `recipient`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"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.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"Maxim/lib/IBEP20.sol\":\"IBEP20\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"Maxim/lib/IBEP20.sol\":{\"keccak256\":\"0x8cac4738a0b00bd1b06b333eb423e0d77a9d70f86576cbab3a4ca01b8773ebf3\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://35d0231ddf8926dd89b14fcfe2a6ae1c0821ab38178653dc6083e019b2fb6ee9\",\"dweb:/ipfs/QmSh1aEz5BLvsr6Zt8qjV2ZA9EfSUXTGX3PJ49aVgxoSPT\"]}},\"version\":1}", 360 | "storageLayout": { 361 | "storage": [], 362 | "types": null 363 | }, 364 | "userdoc": { 365 | "kind": "user", 366 | "methods": {}, 367 | "version": 1 368 | } 369 | } 370 | } 371 | }, 372 | "sources": { 373 | "Maxim/lib/IBEP20.sol": { 374 | "ast": { 375 | "absolutePath": "Maxim/lib/IBEP20.sol", 376 | "exportedSymbols": { 377 | "IBEP20": [ 378 | 100 379 | ] 380 | }, 381 | "id": 101, 382 | "license": "GPL-3.0-or-later", 383 | "nodeType": "SourceUnit", 384 | "nodes": [ 385 | { 386 | "id": 1, 387 | "literals": [ 388 | "solidity", 389 | "^", 390 | "0.8", 391 | ".4" 392 | ], 393 | "nodeType": "PragmaDirective", 394 | "src": "48:23:0" 395 | }, 396 | { 397 | "abstract": false, 398 | "baseContracts": [], 399 | "canonicalName": "IBEP20", 400 | "contractDependencies": [], 401 | "contractKind": "interface", 402 | "fullyImplemented": false, 403 | "id": 100, 404 | "linearizedBaseContracts": [ 405 | 100 406 | ], 407 | "name": "IBEP20", 408 | "nameLocation": "85:6:0", 409 | "nodeType": "ContractDefinition", 410 | "nodes": [ 411 | { 412 | "documentation": { 413 | "id": 2, 414 | "nodeType": "StructuredDocumentation", 415 | "src": "99:68:0", 416 | "text": " @dev Returns the amount of tokens in existence." 417 | }, 418 | "functionSelector": "18160ddd", 419 | "id": 7, 420 | "implemented": false, 421 | "kind": "function", 422 | "modifiers": [], 423 | "name": "totalSupply", 424 | "nameLocation": "182:11:0", 425 | "nodeType": "FunctionDefinition", 426 | "parameters": { 427 | "id": 3, 428 | "nodeType": "ParameterList", 429 | "parameters": [], 430 | "src": "193:2:0" 431 | }, 432 | "returnParameters": { 433 | "id": 6, 434 | "nodeType": "ParameterList", 435 | "parameters": [ 436 | { 437 | "constant": false, 438 | "id": 5, 439 | "mutability": "mutable", 440 | "name": "", 441 | "nameLocation": "-1:-1:-1", 442 | "nodeType": "VariableDeclaration", 443 | "scope": 7, 444 | "src": "219:7:0", 445 | "stateVariable": false, 446 | "storageLocation": "default", 447 | "typeDescriptions": { 448 | "typeIdentifier": "t_uint256", 449 | "typeString": "uint256" 450 | }, 451 | "typeName": { 452 | "id": 4, 453 | "name": "uint256", 454 | "nodeType": "ElementaryTypeName", 455 | "src": "219:7:0", 456 | "typeDescriptions": { 457 | "typeIdentifier": "t_uint256", 458 | "typeString": "uint256" 459 | } 460 | }, 461 | "visibility": "internal" 462 | } 463 | ], 464 | "src": "218:9:0" 465 | }, 466 | "scope": 100, 467 | "src": "173:55:0", 468 | "stateMutability": "view", 469 | "virtual": false, 470 | "visibility": "external" 471 | }, 472 | { 473 | "documentation": { 474 | "id": 8, 475 | "nodeType": "StructuredDocumentation", 476 | "src": "236:53:0", 477 | "text": " @dev Returns the token decimals." 478 | }, 479 | "functionSelector": "313ce567", 480 | "id": 13, 481 | "implemented": false, 482 | "kind": "function", 483 | "modifiers": [], 484 | "name": "decimals", 485 | "nameLocation": "304:8:0", 486 | "nodeType": "FunctionDefinition", 487 | "parameters": { 488 | "id": 9, 489 | "nodeType": "ParameterList", 490 | "parameters": [], 491 | "src": "312:2:0" 492 | }, 493 | "returnParameters": { 494 | "id": 12, 495 | "nodeType": "ParameterList", 496 | "parameters": [ 497 | { 498 | "constant": false, 499 | "id": 11, 500 | "mutability": "mutable", 501 | "name": "", 502 | "nameLocation": "-1:-1:-1", 503 | "nodeType": "VariableDeclaration", 504 | "scope": 13, 505 | "src": "338:5:0", 506 | "stateVariable": false, 507 | "storageLocation": "default", 508 | "typeDescriptions": { 509 | "typeIdentifier": "t_uint8", 510 | "typeString": "uint8" 511 | }, 512 | "typeName": { 513 | "id": 10, 514 | "name": "uint8", 515 | "nodeType": "ElementaryTypeName", 516 | "src": "338:5:0", 517 | "typeDescriptions": { 518 | "typeIdentifier": "t_uint8", 519 | "typeString": "uint8" 520 | } 521 | }, 522 | "visibility": "internal" 523 | } 524 | ], 525 | "src": "337:7:0" 526 | }, 527 | "scope": 100, 528 | "src": "295:50:0", 529 | "stateMutability": "view", 530 | "virtual": false, 531 | "visibility": "external" 532 | }, 533 | { 534 | "documentation": { 535 | "id": 14, 536 | "nodeType": "StructuredDocumentation", 537 | "src": "353:51:0", 538 | "text": " @dev Returns the token symbol." 539 | }, 540 | "functionSelector": "95d89b41", 541 | "id": 19, 542 | "implemented": false, 543 | "kind": "function", 544 | "modifiers": [], 545 | "name": "symbol", 546 | "nameLocation": "419:6:0", 547 | "nodeType": "FunctionDefinition", 548 | "parameters": { 549 | "id": 15, 550 | "nodeType": "ParameterList", 551 | "parameters": [], 552 | "src": "425:2:0" 553 | }, 554 | "returnParameters": { 555 | "id": 18, 556 | "nodeType": "ParameterList", 557 | "parameters": [ 558 | { 559 | "constant": false, 560 | "id": 17, 561 | "mutability": "mutable", 562 | "name": "", 563 | "nameLocation": "-1:-1:-1", 564 | "nodeType": "VariableDeclaration", 565 | "scope": 19, 566 | "src": "451:13:0", 567 | "stateVariable": false, 568 | "storageLocation": "memory", 569 | "typeDescriptions": { 570 | "typeIdentifier": "t_string_memory_ptr", 571 | "typeString": "string" 572 | }, 573 | "typeName": { 574 | "id": 16, 575 | "name": "string", 576 | "nodeType": "ElementaryTypeName", 577 | "src": "451:6:0", 578 | "typeDescriptions": { 579 | "typeIdentifier": "t_string_storage_ptr", 580 | "typeString": "string" 581 | } 582 | }, 583 | "visibility": "internal" 584 | } 585 | ], 586 | "src": "450:15:0" 587 | }, 588 | "scope": 100, 589 | "src": "410:56:0", 590 | "stateMutability": "view", 591 | "virtual": false, 592 | "visibility": "external" 593 | }, 594 | { 595 | "documentation": { 596 | "id": 20, 597 | "nodeType": "StructuredDocumentation", 598 | "src": "474:49:0", 599 | "text": " @dev Returns the token name." 600 | }, 601 | "functionSelector": "06fdde03", 602 | "id": 25, 603 | "implemented": false, 604 | "kind": "function", 605 | "modifiers": [], 606 | "name": "name", 607 | "nameLocation": "538:4:0", 608 | "nodeType": "FunctionDefinition", 609 | "parameters": { 610 | "id": 21, 611 | "nodeType": "ParameterList", 612 | "parameters": [], 613 | "src": "542:2:0" 614 | }, 615 | "returnParameters": { 616 | "id": 24, 617 | "nodeType": "ParameterList", 618 | "parameters": [ 619 | { 620 | "constant": false, 621 | "id": 23, 622 | "mutability": "mutable", 623 | "name": "", 624 | "nameLocation": "-1:-1:-1", 625 | "nodeType": "VariableDeclaration", 626 | "scope": 25, 627 | "src": "568:13:0", 628 | "stateVariable": false, 629 | "storageLocation": "memory", 630 | "typeDescriptions": { 631 | "typeIdentifier": "t_string_memory_ptr", 632 | "typeString": "string" 633 | }, 634 | "typeName": { 635 | "id": 22, 636 | "name": "string", 637 | "nodeType": "ElementaryTypeName", 638 | "src": "568:6:0", 639 | "typeDescriptions": { 640 | "typeIdentifier": "t_string_storage_ptr", 641 | "typeString": "string" 642 | } 643 | }, 644 | "visibility": "internal" 645 | } 646 | ], 647 | "src": "567:15:0" 648 | }, 649 | "scope": 100, 650 | "src": "529:54:0", 651 | "stateMutability": "view", 652 | "virtual": false, 653 | "visibility": "external" 654 | }, 655 | { 656 | "documentation": { 657 | "id": 26, 658 | "nodeType": "StructuredDocumentation", 659 | "src": "591:54:0", 660 | "text": " @dev Returns the bep token owner." 661 | }, 662 | "functionSelector": "893d20e8", 663 | "id": 31, 664 | "implemented": false, 665 | "kind": "function", 666 | "modifiers": [], 667 | "name": "getOwner", 668 | "nameLocation": "660:8:0", 669 | "nodeType": "FunctionDefinition", 670 | "parameters": { 671 | "id": 27, 672 | "nodeType": "ParameterList", 673 | "parameters": [], 674 | "src": "668:2:0" 675 | }, 676 | "returnParameters": { 677 | "id": 30, 678 | "nodeType": "ParameterList", 679 | "parameters": [ 680 | { 681 | "constant": false, 682 | "id": 29, 683 | "mutability": "mutable", 684 | "name": "", 685 | "nameLocation": "-1:-1:-1", 686 | "nodeType": "VariableDeclaration", 687 | "scope": 31, 688 | "src": "694:7:0", 689 | "stateVariable": false, 690 | "storageLocation": "default", 691 | "typeDescriptions": { 692 | "typeIdentifier": "t_address", 693 | "typeString": "address" 694 | }, 695 | "typeName": { 696 | "id": 28, 697 | "name": "address", 698 | "nodeType": "ElementaryTypeName", 699 | "src": "694:7:0", 700 | "stateMutability": "nonpayable", 701 | "typeDescriptions": { 702 | "typeIdentifier": "t_address", 703 | "typeString": "address" 704 | } 705 | }, 706 | "visibility": "internal" 707 | } 708 | ], 709 | "src": "693:9:0" 710 | }, 711 | "scope": 100, 712 | "src": "651:52:0", 713 | "stateMutability": "view", 714 | "virtual": false, 715 | "visibility": "external" 716 | }, 717 | { 718 | "documentation": { 719 | "id": 32, 720 | "nodeType": "StructuredDocumentation", 721 | "src": "711:74:0", 722 | "text": " @dev Returns the amount of tokens owned by `account`." 723 | }, 724 | "functionSelector": "70a08231", 725 | "id": 39, 726 | "implemented": false, 727 | "kind": "function", 728 | "modifiers": [], 729 | "name": "balanceOf", 730 | "nameLocation": "800:9:0", 731 | "nodeType": "FunctionDefinition", 732 | "parameters": { 733 | "id": 35, 734 | "nodeType": "ParameterList", 735 | "parameters": [ 736 | { 737 | "constant": false, 738 | "id": 34, 739 | "mutability": "mutable", 740 | "name": "account", 741 | "nameLocation": "818:7:0", 742 | "nodeType": "VariableDeclaration", 743 | "scope": 39, 744 | "src": "810:15:0", 745 | "stateVariable": false, 746 | "storageLocation": "default", 747 | "typeDescriptions": { 748 | "typeIdentifier": "t_address", 749 | "typeString": "address" 750 | }, 751 | "typeName": { 752 | "id": 33, 753 | "name": "address", 754 | "nodeType": "ElementaryTypeName", 755 | "src": "810:7:0", 756 | "stateMutability": "nonpayable", 757 | "typeDescriptions": { 758 | "typeIdentifier": "t_address", 759 | "typeString": "address" 760 | } 761 | }, 762 | "visibility": "internal" 763 | } 764 | ], 765 | "src": "809:17:0" 766 | }, 767 | "returnParameters": { 768 | "id": 38, 769 | "nodeType": "ParameterList", 770 | "parameters": [ 771 | { 772 | "constant": false, 773 | "id": 37, 774 | "mutability": "mutable", 775 | "name": "", 776 | "nameLocation": "-1:-1:-1", 777 | "nodeType": "VariableDeclaration", 778 | "scope": 39, 779 | "src": "850:7:0", 780 | "stateVariable": false, 781 | "storageLocation": "default", 782 | "typeDescriptions": { 783 | "typeIdentifier": "t_uint256", 784 | "typeString": "uint256" 785 | }, 786 | "typeName": { 787 | "id": 36, 788 | "name": "uint256", 789 | "nodeType": "ElementaryTypeName", 790 | "src": "850:7:0", 791 | "typeDescriptions": { 792 | "typeIdentifier": "t_uint256", 793 | "typeString": "uint256" 794 | } 795 | }, 796 | "visibility": "internal" 797 | } 798 | ], 799 | "src": "849:9:0" 800 | }, 801 | "scope": 100, 802 | "src": "791:68:0", 803 | "stateMutability": "view", 804 | "virtual": false, 805 | "visibility": "external" 806 | }, 807 | { 808 | "documentation": { 809 | "id": 40, 810 | "nodeType": "StructuredDocumentation", 811 | "src": "867:215:0", 812 | "text": " @dev Moves `amount` tokens from the caller's account to `recipient`.\n Returns a boolean value indicating whether the operation succeeded.\n Emits a {Transfer} event." 813 | }, 814 | "functionSelector": "a9059cbb", 815 | "id": 49, 816 | "implemented": false, 817 | "kind": "function", 818 | "modifiers": [], 819 | "name": "transfer", 820 | "nameLocation": "1097:8:0", 821 | "nodeType": "FunctionDefinition", 822 | "parameters": { 823 | "id": 45, 824 | "nodeType": "ParameterList", 825 | "parameters": [ 826 | { 827 | "constant": false, 828 | "id": 42, 829 | "mutability": "mutable", 830 | "name": "recipient", 831 | "nameLocation": "1114:9:0", 832 | "nodeType": "VariableDeclaration", 833 | "scope": 49, 834 | "src": "1106:17:0", 835 | "stateVariable": false, 836 | "storageLocation": "default", 837 | "typeDescriptions": { 838 | "typeIdentifier": "t_address", 839 | "typeString": "address" 840 | }, 841 | "typeName": { 842 | "id": 41, 843 | "name": "address", 844 | "nodeType": "ElementaryTypeName", 845 | "src": "1106:7:0", 846 | "stateMutability": "nonpayable", 847 | "typeDescriptions": { 848 | "typeIdentifier": "t_address", 849 | "typeString": "address" 850 | } 851 | }, 852 | "visibility": "internal" 853 | }, 854 | { 855 | "constant": false, 856 | "id": 44, 857 | "mutability": "mutable", 858 | "name": "amount", 859 | "nameLocation": "1133:6:0", 860 | "nodeType": "VariableDeclaration", 861 | "scope": 49, 862 | "src": "1125:14:0", 863 | "stateVariable": false, 864 | "storageLocation": "default", 865 | "typeDescriptions": { 866 | "typeIdentifier": "t_uint256", 867 | "typeString": "uint256" 868 | }, 869 | "typeName": { 870 | "id": 43, 871 | "name": "uint256", 872 | "nodeType": "ElementaryTypeName", 873 | "src": "1125:7:0", 874 | "typeDescriptions": { 875 | "typeIdentifier": "t_uint256", 876 | "typeString": "uint256" 877 | } 878 | }, 879 | "visibility": "internal" 880 | } 881 | ], 882 | "src": "1105:35:0" 883 | }, 884 | "returnParameters": { 885 | "id": 48, 886 | "nodeType": "ParameterList", 887 | "parameters": [ 888 | { 889 | "constant": false, 890 | "id": 47, 891 | "mutability": "mutable", 892 | "name": "", 893 | "nameLocation": "-1:-1:-1", 894 | "nodeType": "VariableDeclaration", 895 | "scope": 49, 896 | "src": "1159:4:0", 897 | "stateVariable": false, 898 | "storageLocation": "default", 899 | "typeDescriptions": { 900 | "typeIdentifier": "t_bool", 901 | "typeString": "bool" 902 | }, 903 | "typeName": { 904 | "id": 46, 905 | "name": "bool", 906 | "nodeType": "ElementaryTypeName", 907 | "src": "1159:4:0", 908 | "typeDescriptions": { 909 | "typeIdentifier": "t_bool", 910 | "typeString": "bool" 911 | } 912 | }, 913 | "visibility": "internal" 914 | } 915 | ], 916 | "src": "1158:6:0" 917 | }, 918 | "scope": 100, 919 | "src": "1088:77:0", 920 | "stateMutability": "nonpayable", 921 | "virtual": false, 922 | "visibility": "external" 923 | }, 924 | { 925 | "documentation": { 926 | "id": 50, 927 | "nodeType": "StructuredDocumentation", 928 | "src": "1173:270:0", 929 | "text": " @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 This value changes when {approve} or {transferFrom} are called." 930 | }, 931 | "functionSelector": "dd62ed3e", 932 | "id": 59, 933 | "implemented": false, 934 | "kind": "function", 935 | "modifiers": [], 936 | "name": "allowance", 937 | "nameLocation": "1458:9:0", 938 | "nodeType": "FunctionDefinition", 939 | "parameters": { 940 | "id": 55, 941 | "nodeType": "ParameterList", 942 | "parameters": [ 943 | { 944 | "constant": false, 945 | "id": 52, 946 | "mutability": "mutable", 947 | "name": "_owner", 948 | "nameLocation": "1476:6:0", 949 | "nodeType": "VariableDeclaration", 950 | "scope": 59, 951 | "src": "1468:14:0", 952 | "stateVariable": false, 953 | "storageLocation": "default", 954 | "typeDescriptions": { 955 | "typeIdentifier": "t_address", 956 | "typeString": "address" 957 | }, 958 | "typeName": { 959 | "id": 51, 960 | "name": "address", 961 | "nodeType": "ElementaryTypeName", 962 | "src": "1468:7:0", 963 | "stateMutability": "nonpayable", 964 | "typeDescriptions": { 965 | "typeIdentifier": "t_address", 966 | "typeString": "address" 967 | } 968 | }, 969 | "visibility": "internal" 970 | }, 971 | { 972 | "constant": false, 973 | "id": 54, 974 | "mutability": "mutable", 975 | "name": "spender", 976 | "nameLocation": "1492:7:0", 977 | "nodeType": "VariableDeclaration", 978 | "scope": 59, 979 | "src": "1484:15:0", 980 | "stateVariable": false, 981 | "storageLocation": "default", 982 | "typeDescriptions": { 983 | "typeIdentifier": "t_address", 984 | "typeString": "address" 985 | }, 986 | "typeName": { 987 | "id": 53, 988 | "name": "address", 989 | "nodeType": "ElementaryTypeName", 990 | "src": "1484:7:0", 991 | "stateMutability": "nonpayable", 992 | "typeDescriptions": { 993 | "typeIdentifier": "t_address", 994 | "typeString": "address" 995 | } 996 | }, 997 | "visibility": "internal" 998 | } 999 | ], 1000 | "src": "1467:33:0" 1001 | }, 1002 | "returnParameters": { 1003 | "id": 58, 1004 | "nodeType": "ParameterList", 1005 | "parameters": [ 1006 | { 1007 | "constant": false, 1008 | "id": 57, 1009 | "mutability": "mutable", 1010 | "name": "", 1011 | "nameLocation": "-1:-1:-1", 1012 | "nodeType": "VariableDeclaration", 1013 | "scope": 59, 1014 | "src": "1524:7:0", 1015 | "stateVariable": false, 1016 | "storageLocation": "default", 1017 | "typeDescriptions": { 1018 | "typeIdentifier": "t_uint256", 1019 | "typeString": "uint256" 1020 | }, 1021 | "typeName": { 1022 | "id": 56, 1023 | "name": "uint256", 1024 | "nodeType": "ElementaryTypeName", 1025 | "src": "1524:7:0", 1026 | "typeDescriptions": { 1027 | "typeIdentifier": "t_uint256", 1028 | "typeString": "uint256" 1029 | } 1030 | }, 1031 | "visibility": "internal" 1032 | } 1033 | ], 1034 | "src": "1523:9:0" 1035 | }, 1036 | "scope": 100, 1037 | "src": "1449:84:0", 1038 | "stateMutability": "view", 1039 | "virtual": false, 1040 | "visibility": "external" 1041 | }, 1042 | { 1043 | "documentation": { 1044 | "id": 60, 1045 | "nodeType": "StructuredDocumentation", 1046 | "src": "1541:655:0", 1047 | "text": " @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n Returns a boolean value indicating whether the operation succeeded.\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 Emits an {Approval} event." 1048 | }, 1049 | "functionSelector": "095ea7b3", 1050 | "id": 69, 1051 | "implemented": false, 1052 | "kind": "function", 1053 | "modifiers": [], 1054 | "name": "approve", 1055 | "nameLocation": "2211:7:0", 1056 | "nodeType": "FunctionDefinition", 1057 | "parameters": { 1058 | "id": 65, 1059 | "nodeType": "ParameterList", 1060 | "parameters": [ 1061 | { 1062 | "constant": false, 1063 | "id": 62, 1064 | "mutability": "mutable", 1065 | "name": "spender", 1066 | "nameLocation": "2227:7:0", 1067 | "nodeType": "VariableDeclaration", 1068 | "scope": 69, 1069 | "src": "2219:15:0", 1070 | "stateVariable": false, 1071 | "storageLocation": "default", 1072 | "typeDescriptions": { 1073 | "typeIdentifier": "t_address", 1074 | "typeString": "address" 1075 | }, 1076 | "typeName": { 1077 | "id": 61, 1078 | "name": "address", 1079 | "nodeType": "ElementaryTypeName", 1080 | "src": "2219:7:0", 1081 | "stateMutability": "nonpayable", 1082 | "typeDescriptions": { 1083 | "typeIdentifier": "t_address", 1084 | "typeString": "address" 1085 | } 1086 | }, 1087 | "visibility": "internal" 1088 | }, 1089 | { 1090 | "constant": false, 1091 | "id": 64, 1092 | "mutability": "mutable", 1093 | "name": "amount", 1094 | "nameLocation": "2244:6:0", 1095 | "nodeType": "VariableDeclaration", 1096 | "scope": 69, 1097 | "src": "2236:14:0", 1098 | "stateVariable": false, 1099 | "storageLocation": "default", 1100 | "typeDescriptions": { 1101 | "typeIdentifier": "t_uint256", 1102 | "typeString": "uint256" 1103 | }, 1104 | "typeName": { 1105 | "id": 63, 1106 | "name": "uint256", 1107 | "nodeType": "ElementaryTypeName", 1108 | "src": "2236:7:0", 1109 | "typeDescriptions": { 1110 | "typeIdentifier": "t_uint256", 1111 | "typeString": "uint256" 1112 | } 1113 | }, 1114 | "visibility": "internal" 1115 | } 1116 | ], 1117 | "src": "2218:33:0" 1118 | }, 1119 | "returnParameters": { 1120 | "id": 68, 1121 | "nodeType": "ParameterList", 1122 | "parameters": [ 1123 | { 1124 | "constant": false, 1125 | "id": 67, 1126 | "mutability": "mutable", 1127 | "name": "", 1128 | "nameLocation": "-1:-1:-1", 1129 | "nodeType": "VariableDeclaration", 1130 | "scope": 69, 1131 | "src": "2270:4:0", 1132 | "stateVariable": false, 1133 | "storageLocation": "default", 1134 | "typeDescriptions": { 1135 | "typeIdentifier": "t_bool", 1136 | "typeString": "bool" 1137 | }, 1138 | "typeName": { 1139 | "id": 66, 1140 | "name": "bool", 1141 | "nodeType": "ElementaryTypeName", 1142 | "src": "2270:4:0", 1143 | "typeDescriptions": { 1144 | "typeIdentifier": "t_bool", 1145 | "typeString": "bool" 1146 | } 1147 | }, 1148 | "visibility": "internal" 1149 | } 1150 | ], 1151 | "src": "2269:6:0" 1152 | }, 1153 | "scope": 100, 1154 | "src": "2202:74:0", 1155 | "stateMutability": "nonpayable", 1156 | "virtual": false, 1157 | "visibility": "external" 1158 | }, 1159 | { 1160 | "documentation": { 1161 | "id": 70, 1162 | "nodeType": "StructuredDocumentation", 1163 | "src": "2284:304:0", 1164 | "text": " @dev Moves `amount` tokens from `sender` to `recipient` using the\n allowance mechanism. `amount` is then deducted from the caller's\n allowance.\n Returns a boolean value indicating whether the operation succeeded.\n Emits a {Transfer} event." 1165 | }, 1166 | "functionSelector": "23b872dd", 1167 | "id": 81, 1168 | "implemented": false, 1169 | "kind": "function", 1170 | "modifiers": [], 1171 | "name": "transferFrom", 1172 | "nameLocation": "2603:12:0", 1173 | "nodeType": "FunctionDefinition", 1174 | "parameters": { 1175 | "id": 77, 1176 | "nodeType": "ParameterList", 1177 | "parameters": [ 1178 | { 1179 | "constant": false, 1180 | "id": 72, 1181 | "mutability": "mutable", 1182 | "name": "sender", 1183 | "nameLocation": "2634:6:0", 1184 | "nodeType": "VariableDeclaration", 1185 | "scope": 81, 1186 | "src": "2626:14:0", 1187 | "stateVariable": false, 1188 | "storageLocation": "default", 1189 | "typeDescriptions": { 1190 | "typeIdentifier": "t_address", 1191 | "typeString": "address" 1192 | }, 1193 | "typeName": { 1194 | "id": 71, 1195 | "name": "address", 1196 | "nodeType": "ElementaryTypeName", 1197 | "src": "2626:7:0", 1198 | "stateMutability": "nonpayable", 1199 | "typeDescriptions": { 1200 | "typeIdentifier": "t_address", 1201 | "typeString": "address" 1202 | } 1203 | }, 1204 | "visibility": "internal" 1205 | }, 1206 | { 1207 | "constant": false, 1208 | "id": 74, 1209 | "mutability": "mutable", 1210 | "name": "recipient", 1211 | "nameLocation": "2659:9:0", 1212 | "nodeType": "VariableDeclaration", 1213 | "scope": 81, 1214 | "src": "2651:17:0", 1215 | "stateVariable": false, 1216 | "storageLocation": "default", 1217 | "typeDescriptions": { 1218 | "typeIdentifier": "t_address", 1219 | "typeString": "address" 1220 | }, 1221 | "typeName": { 1222 | "id": 73, 1223 | "name": "address", 1224 | "nodeType": "ElementaryTypeName", 1225 | "src": "2651:7:0", 1226 | "stateMutability": "nonpayable", 1227 | "typeDescriptions": { 1228 | "typeIdentifier": "t_address", 1229 | "typeString": "address" 1230 | } 1231 | }, 1232 | "visibility": "internal" 1233 | }, 1234 | { 1235 | "constant": false, 1236 | "id": 76, 1237 | "mutability": "mutable", 1238 | "name": "amount", 1239 | "nameLocation": "2687:6:0", 1240 | "nodeType": "VariableDeclaration", 1241 | "scope": 81, 1242 | "src": "2679:14:0", 1243 | "stateVariable": false, 1244 | "storageLocation": "default", 1245 | "typeDescriptions": { 1246 | "typeIdentifier": "t_uint256", 1247 | "typeString": "uint256" 1248 | }, 1249 | "typeName": { 1250 | "id": 75, 1251 | "name": "uint256", 1252 | "nodeType": "ElementaryTypeName", 1253 | "src": "2679:7:0", 1254 | "typeDescriptions": { 1255 | "typeIdentifier": "t_uint256", 1256 | "typeString": "uint256" 1257 | } 1258 | }, 1259 | "visibility": "internal" 1260 | } 1261 | ], 1262 | "src": "2615:85:0" 1263 | }, 1264 | "returnParameters": { 1265 | "id": 80, 1266 | "nodeType": "ParameterList", 1267 | "parameters": [ 1268 | { 1269 | "constant": false, 1270 | "id": 79, 1271 | "mutability": "mutable", 1272 | "name": "", 1273 | "nameLocation": "-1:-1:-1", 1274 | "nodeType": "VariableDeclaration", 1275 | "scope": 81, 1276 | "src": "2719:4:0", 1277 | "stateVariable": false, 1278 | "storageLocation": "default", 1279 | "typeDescriptions": { 1280 | "typeIdentifier": "t_bool", 1281 | "typeString": "bool" 1282 | }, 1283 | "typeName": { 1284 | "id": 78, 1285 | "name": "bool", 1286 | "nodeType": "ElementaryTypeName", 1287 | "src": "2719:4:0", 1288 | "typeDescriptions": { 1289 | "typeIdentifier": "t_bool", 1290 | "typeString": "bool" 1291 | } 1292 | }, 1293 | "visibility": "internal" 1294 | } 1295 | ], 1296 | "src": "2718:6:0" 1297 | }, 1298 | "scope": 100, 1299 | "src": "2594:131:0", 1300 | "stateMutability": "nonpayable", 1301 | "virtual": false, 1302 | "visibility": "external" 1303 | }, 1304 | { 1305 | "anonymous": false, 1306 | "documentation": { 1307 | "id": 82, 1308 | "nodeType": "StructuredDocumentation", 1309 | "src": "2733:163:0", 1310 | "text": " @dev Emitted when `value` tokens are moved from one account (`from`) to\n another (`to`).\n Note that `value` may be zero." 1311 | }, 1312 | "eventSelector": "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", 1313 | "id": 90, 1314 | "name": "Transfer", 1315 | "nameLocation": "2908:8:0", 1316 | "nodeType": "EventDefinition", 1317 | "parameters": { 1318 | "id": 89, 1319 | "nodeType": "ParameterList", 1320 | "parameters": [ 1321 | { 1322 | "constant": false, 1323 | "id": 84, 1324 | "indexed": true, 1325 | "mutability": "mutable", 1326 | "name": "from", 1327 | "nameLocation": "2933:4:0", 1328 | "nodeType": "VariableDeclaration", 1329 | "scope": 90, 1330 | "src": "2917:20:0", 1331 | "stateVariable": false, 1332 | "storageLocation": "default", 1333 | "typeDescriptions": { 1334 | "typeIdentifier": "t_address", 1335 | "typeString": "address" 1336 | }, 1337 | "typeName": { 1338 | "id": 83, 1339 | "name": "address", 1340 | "nodeType": "ElementaryTypeName", 1341 | "src": "2917:7:0", 1342 | "stateMutability": "nonpayable", 1343 | "typeDescriptions": { 1344 | "typeIdentifier": "t_address", 1345 | "typeString": "address" 1346 | } 1347 | }, 1348 | "visibility": "internal" 1349 | }, 1350 | { 1351 | "constant": false, 1352 | "id": 86, 1353 | "indexed": true, 1354 | "mutability": "mutable", 1355 | "name": "to", 1356 | "nameLocation": "2955:2:0", 1357 | "nodeType": "VariableDeclaration", 1358 | "scope": 90, 1359 | "src": "2939:18:0", 1360 | "stateVariable": false, 1361 | "storageLocation": "default", 1362 | "typeDescriptions": { 1363 | "typeIdentifier": "t_address", 1364 | "typeString": "address" 1365 | }, 1366 | "typeName": { 1367 | "id": 85, 1368 | "name": "address", 1369 | "nodeType": "ElementaryTypeName", 1370 | "src": "2939:7:0", 1371 | "stateMutability": "nonpayable", 1372 | "typeDescriptions": { 1373 | "typeIdentifier": "t_address", 1374 | "typeString": "address" 1375 | } 1376 | }, 1377 | "visibility": "internal" 1378 | }, 1379 | { 1380 | "constant": false, 1381 | "id": 88, 1382 | "indexed": false, 1383 | "mutability": "mutable", 1384 | "name": "value", 1385 | "nameLocation": "2967:5:0", 1386 | "nodeType": "VariableDeclaration", 1387 | "scope": 90, 1388 | "src": "2959:13:0", 1389 | "stateVariable": false, 1390 | "storageLocation": "default", 1391 | "typeDescriptions": { 1392 | "typeIdentifier": "t_uint256", 1393 | "typeString": "uint256" 1394 | }, 1395 | "typeName": { 1396 | "id": 87, 1397 | "name": "uint256", 1398 | "nodeType": "ElementaryTypeName", 1399 | "src": "2959:7:0", 1400 | "typeDescriptions": { 1401 | "typeIdentifier": "t_uint256", 1402 | "typeString": "uint256" 1403 | } 1404 | }, 1405 | "visibility": "internal" 1406 | } 1407 | ], 1408 | "src": "2916:57:0" 1409 | }, 1410 | "src": "2902:72:0" 1411 | }, 1412 | { 1413 | "anonymous": false, 1414 | "documentation": { 1415 | "id": 91, 1416 | "nodeType": "StructuredDocumentation", 1417 | "src": "2982:151:0", 1418 | "text": " @dev Emitted when the allowance of a `spender` for an `owner` is set by\n a call to {approve}. `value` is the new allowance." 1419 | }, 1420 | "eventSelector": "8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925", 1421 | "id": 99, 1422 | "name": "Approval", 1423 | "nameLocation": "3145:8:0", 1424 | "nodeType": "EventDefinition", 1425 | "parameters": { 1426 | "id": 98, 1427 | "nodeType": "ParameterList", 1428 | "parameters": [ 1429 | { 1430 | "constant": false, 1431 | "id": 93, 1432 | "indexed": true, 1433 | "mutability": "mutable", 1434 | "name": "owner", 1435 | "nameLocation": "3170:5:0", 1436 | "nodeType": "VariableDeclaration", 1437 | "scope": 99, 1438 | "src": "3154:21:0", 1439 | "stateVariable": false, 1440 | "storageLocation": "default", 1441 | "typeDescriptions": { 1442 | "typeIdentifier": "t_address", 1443 | "typeString": "address" 1444 | }, 1445 | "typeName": { 1446 | "id": 92, 1447 | "name": "address", 1448 | "nodeType": "ElementaryTypeName", 1449 | "src": "3154:7:0", 1450 | "stateMutability": "nonpayable", 1451 | "typeDescriptions": { 1452 | "typeIdentifier": "t_address", 1453 | "typeString": "address" 1454 | } 1455 | }, 1456 | "visibility": "internal" 1457 | }, 1458 | { 1459 | "constant": false, 1460 | "id": 95, 1461 | "indexed": true, 1462 | "mutability": "mutable", 1463 | "name": "spender", 1464 | "nameLocation": "3193:7:0", 1465 | "nodeType": "VariableDeclaration", 1466 | "scope": 99, 1467 | "src": "3177:23:0", 1468 | "stateVariable": false, 1469 | "storageLocation": "default", 1470 | "typeDescriptions": { 1471 | "typeIdentifier": "t_address", 1472 | "typeString": "address" 1473 | }, 1474 | "typeName": { 1475 | "id": 94, 1476 | "name": "address", 1477 | "nodeType": "ElementaryTypeName", 1478 | "src": "3177:7:0", 1479 | "stateMutability": "nonpayable", 1480 | "typeDescriptions": { 1481 | "typeIdentifier": "t_address", 1482 | "typeString": "address" 1483 | } 1484 | }, 1485 | "visibility": "internal" 1486 | }, 1487 | { 1488 | "constant": false, 1489 | "id": 97, 1490 | "indexed": false, 1491 | "mutability": "mutable", 1492 | "name": "value", 1493 | "nameLocation": "3210:5:0", 1494 | "nodeType": "VariableDeclaration", 1495 | "scope": 99, 1496 | "src": "3202:13:0", 1497 | "stateVariable": false, 1498 | "storageLocation": "default", 1499 | "typeDescriptions": { 1500 | "typeIdentifier": "t_uint256", 1501 | "typeString": "uint256" 1502 | }, 1503 | "typeName": { 1504 | "id": 96, 1505 | "name": "uint256", 1506 | "nodeType": "ElementaryTypeName", 1507 | "src": "3202:7:0", 1508 | "typeDescriptions": { 1509 | "typeIdentifier": "t_uint256", 1510 | "typeString": "uint256" 1511 | } 1512 | }, 1513 | "visibility": "internal" 1514 | } 1515 | ], 1516 | "src": "3153:63:0" 1517 | }, 1518 | "src": "3139:78:0" 1519 | } 1520 | ], 1521 | "scope": 101, 1522 | "src": "75:3145:0", 1523 | "usedErrors": [] 1524 | } 1525 | ], 1526 | "src": "48:3172:0" 1527 | }, 1528 | "id": 0 1529 | } 1530 | } 1531 | } 1532 | } -------------------------------------------------------------------------------- /lib/artifacts/build-info/2dd65a92c987e0a1e13d3d7591fd2243.json: -------------------------------------------------------------------------------- 1 | { 2 | "id": "2dd65a92c987e0a1e13d3d7591fd2243", 3 | "_format": "hh-sol-build-info-1", 4 | "solcVersion": "0.8.14", 5 | "solcLongVersion": "0.8.14+commit.80d49f37", 6 | "input": { 7 | "language": "Solidity", 8 | "sources": { 9 | "Maxim/lib/IBEP20.sol": { 10 | "content": "// SPDX-License-Identifier: GPL-3.0-or-later\r\n\r\npragma solidity >=0.4.0;\r\n\r\ninterface IBEP20 {\r\n /**\r\n * @dev Returns the amount of tokens in existence.\r\n */\r\n function totalSupply() external view returns (uint256);\r\n\r\n /**\r\n * @dev Returns the token decimals.\r\n */\r\n function decimals() external view returns (uint8);\r\n\r\n /**\r\n * @dev Returns the token symbol.\r\n */\r\n function symbol() external view returns (string memory);\r\n\r\n /**\r\n * @dev Returns the token name.\r\n */\r\n function name() external view returns (string memory);\r\n\r\n /**\r\n * @dev Returns the bep token owner.\r\n */\r\n function getOwner() external view returns (address);\r\n\r\n /**\r\n * @dev Returns the amount of tokens owned by `account`.\r\n */\r\n function balanceOf(address account) external view returns (uint256);\r\n\r\n /**\r\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * Emits a {Transfer} event.\r\n */\r\n function transfer(address recipient, uint256 amount) external returns (bool);\r\n\r\n /**\r\n * @dev Returns the remaining number of tokens that `spender` will be\r\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\r\n * zero by default.\r\n *\r\n * This value changes when {approve} or {transferFrom} are called.\r\n */\r\n function allowance(address _owner, address spender) external view returns (uint256);\r\n\r\n /**\r\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\r\n * that someone may use both the old and the new allowance by unfortunate\r\n * transaction ordering. One possible solution to mitigate this race\r\n * condition is to first reduce the spender's allowance to 0 and set the\r\n * desired value afterwards:\r\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\r\n *\r\n * Emits an {Approval} event.\r\n */\r\n function approve(address spender, uint256 amount) external returns (bool);\r\n\r\n /**\r\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\r\n * allowance mechanism. `amount` is then deducted from the caller's\r\n * allowance.\r\n *\r\n * Returns a boolean value indicating whether the operation succeeded.\r\n *\r\n * Emits a {Transfer} event.\r\n */\r\n function transferFrom(\r\n address sender,\r\n address recipient,\r\n uint256 amount\r\n ) external returns (bool);\r\n\r\n /**\r\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\r\n * another (`to`).\r\n *\r\n * Note that `value` may be zero.\r\n */\r\n event Transfer(address indexed from, address indexed to, uint256 value);\r\n\r\n /**\r\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\r\n * a call to {approve}. `value` is the new allowance.\r\n */\r\n event Approval(address indexed owner, address indexed spender, uint256 value);\r\n}" 11 | } 12 | }, 13 | "settings": { 14 | "optimizer": { 15 | "enabled": false, 16 | "runs": 200 17 | }, 18 | "outputSelection": { 19 | "*": { 20 | "": [ 21 | "ast" 22 | ], 23 | "*": [ 24 | "abi", 25 | "metadata", 26 | "devdoc", 27 | "userdoc", 28 | "storageLayout", 29 | "evm.legacyAssembly", 30 | "evm.bytecode", 31 | "evm.deployedBytecode", 32 | "evm.methodIdentifiers", 33 | "evm.gasEstimates", 34 | "evm.assembly" 35 | ] 36 | } 37 | } 38 | } 39 | }, 40 | "output": { 41 | "contracts": { 42 | "Maxim/lib/IBEP20.sol": { 43 | "IBEP20": { 44 | "abi": [ 45 | { 46 | "anonymous": false, 47 | "inputs": [ 48 | { 49 | "indexed": true, 50 | "internalType": "address", 51 | "name": "owner", 52 | "type": "address" 53 | }, 54 | { 55 | "indexed": true, 56 | "internalType": "address", 57 | "name": "spender", 58 | "type": "address" 59 | }, 60 | { 61 | "indexed": false, 62 | "internalType": "uint256", 63 | "name": "value", 64 | "type": "uint256" 65 | } 66 | ], 67 | "name": "Approval", 68 | "type": "event" 69 | }, 70 | { 71 | "anonymous": false, 72 | "inputs": [ 73 | { 74 | "indexed": true, 75 | "internalType": "address", 76 | "name": "from", 77 | "type": "address" 78 | }, 79 | { 80 | "indexed": true, 81 | "internalType": "address", 82 | "name": "to", 83 | "type": "address" 84 | }, 85 | { 86 | "indexed": false, 87 | "internalType": "uint256", 88 | "name": "value", 89 | "type": "uint256" 90 | } 91 | ], 92 | "name": "Transfer", 93 | "type": "event" 94 | }, 95 | { 96 | "inputs": [ 97 | { 98 | "internalType": "address", 99 | "name": "_owner", 100 | "type": "address" 101 | }, 102 | { 103 | "internalType": "address", 104 | "name": "spender", 105 | "type": "address" 106 | } 107 | ], 108 | "name": "allowance", 109 | "outputs": [ 110 | { 111 | "internalType": "uint256", 112 | "name": "", 113 | "type": "uint256" 114 | } 115 | ], 116 | "stateMutability": "view", 117 | "type": "function" 118 | }, 119 | { 120 | "inputs": [ 121 | { 122 | "internalType": "address", 123 | "name": "spender", 124 | "type": "address" 125 | }, 126 | { 127 | "internalType": "uint256", 128 | "name": "amount", 129 | "type": "uint256" 130 | } 131 | ], 132 | "name": "approve", 133 | "outputs": [ 134 | { 135 | "internalType": "bool", 136 | "name": "", 137 | "type": "bool" 138 | } 139 | ], 140 | "stateMutability": "nonpayable", 141 | "type": "function" 142 | }, 143 | { 144 | "inputs": [ 145 | { 146 | "internalType": "address", 147 | "name": "account", 148 | "type": "address" 149 | } 150 | ], 151 | "name": "balanceOf", 152 | "outputs": [ 153 | { 154 | "internalType": "uint256", 155 | "name": "", 156 | "type": "uint256" 157 | } 158 | ], 159 | "stateMutability": "view", 160 | "type": "function" 161 | }, 162 | { 163 | "inputs": [], 164 | "name": "decimals", 165 | "outputs": [ 166 | { 167 | "internalType": "uint8", 168 | "name": "", 169 | "type": "uint8" 170 | } 171 | ], 172 | "stateMutability": "view", 173 | "type": "function" 174 | }, 175 | { 176 | "inputs": [], 177 | "name": "getOwner", 178 | "outputs": [ 179 | { 180 | "internalType": "address", 181 | "name": "", 182 | "type": "address" 183 | } 184 | ], 185 | "stateMutability": "view", 186 | "type": "function" 187 | }, 188 | { 189 | "inputs": [], 190 | "name": "name", 191 | "outputs": [ 192 | { 193 | "internalType": "string", 194 | "name": "", 195 | "type": "string" 196 | } 197 | ], 198 | "stateMutability": "view", 199 | "type": "function" 200 | }, 201 | { 202 | "inputs": [], 203 | "name": "symbol", 204 | "outputs": [ 205 | { 206 | "internalType": "string", 207 | "name": "", 208 | "type": "string" 209 | } 210 | ], 211 | "stateMutability": "view", 212 | "type": "function" 213 | }, 214 | { 215 | "inputs": [], 216 | "name": "totalSupply", 217 | "outputs": [ 218 | { 219 | "internalType": "uint256", 220 | "name": "", 221 | "type": "uint256" 222 | } 223 | ], 224 | "stateMutability": "view", 225 | "type": "function" 226 | }, 227 | { 228 | "inputs": [ 229 | { 230 | "internalType": "address", 231 | "name": "recipient", 232 | "type": "address" 233 | }, 234 | { 235 | "internalType": "uint256", 236 | "name": "amount", 237 | "type": "uint256" 238 | } 239 | ], 240 | "name": "transfer", 241 | "outputs": [ 242 | { 243 | "internalType": "bool", 244 | "name": "", 245 | "type": "bool" 246 | } 247 | ], 248 | "stateMutability": "nonpayable", 249 | "type": "function" 250 | }, 251 | { 252 | "inputs": [ 253 | { 254 | "internalType": "address", 255 | "name": "sender", 256 | "type": "address" 257 | }, 258 | { 259 | "internalType": "address", 260 | "name": "recipient", 261 | "type": "address" 262 | }, 263 | { 264 | "internalType": "uint256", 265 | "name": "amount", 266 | "type": "uint256" 267 | } 268 | ], 269 | "name": "transferFrom", 270 | "outputs": [ 271 | { 272 | "internalType": "bool", 273 | "name": "", 274 | "type": "bool" 275 | } 276 | ], 277 | "stateMutability": "nonpayable", 278 | "type": "function" 279 | } 280 | ], 281 | "devdoc": { 282 | "events": { 283 | "Approval(address,address,uint256)": { 284 | "details": "Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance." 285 | }, 286 | "Transfer(address,address,uint256)": { 287 | "details": "Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero." 288 | } 289 | }, 290 | "kind": "dev", 291 | "methods": { 292 | "allowance(address,address)": { 293 | "details": "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." 294 | }, 295 | "approve(address,uint256)": { 296 | "details": "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." 297 | }, 298 | "balanceOf(address)": { 299 | "details": "Returns the amount of tokens owned by `account`." 300 | }, 301 | "decimals()": { 302 | "details": "Returns the token decimals." 303 | }, 304 | "getOwner()": { 305 | "details": "Returns the bep token owner." 306 | }, 307 | "name()": { 308 | "details": "Returns the token name." 309 | }, 310 | "symbol()": { 311 | "details": "Returns the token symbol." 312 | }, 313 | "totalSupply()": { 314 | "details": "Returns the amount of tokens in existence." 315 | }, 316 | "transfer(address,uint256)": { 317 | "details": "Moves `amount` tokens from the caller's account to `recipient`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event." 318 | }, 319 | "transferFrom(address,address,uint256)": { 320 | "details": "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." 321 | } 322 | }, 323 | "version": 1 324 | }, 325 | "evm": { 326 | "assembly": "", 327 | "bytecode": { 328 | "functionDebugData": {}, 329 | "generatedSources": [], 330 | "linkReferences": {}, 331 | "object": "", 332 | "opcodes": "", 333 | "sourceMap": "" 334 | }, 335 | "deployedBytecode": { 336 | "functionDebugData": {}, 337 | "generatedSources": [], 338 | "immutableReferences": {}, 339 | "linkReferences": {}, 340 | "object": "", 341 | "opcodes": "", 342 | "sourceMap": "" 343 | }, 344 | "gasEstimates": null, 345 | "legacyAssembly": null, 346 | "methodIdentifiers": { 347 | "allowance(address,address)": "dd62ed3e", 348 | "approve(address,uint256)": "095ea7b3", 349 | "balanceOf(address)": "70a08231", 350 | "decimals()": "313ce567", 351 | "getOwner()": "893d20e8", 352 | "name()": "06fdde03", 353 | "symbol()": "95d89b41", 354 | "totalSupply()": "18160ddd", 355 | "transfer(address,uint256)": "a9059cbb", 356 | "transferFrom(address,address,uint256)": "23b872dd" 357 | } 358 | }, 359 | "metadata": "{\"compiler\":{\"version\":\"0.8.14+commit.80d49f37\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"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.\"},\"approve(address,uint256)\":{\"details\":\"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.\"},\"balanceOf(address)\":{\"details\":\"Returns the amount of tokens owned by `account`.\"},\"decimals()\":{\"details\":\"Returns the token decimals.\"},\"getOwner()\":{\"details\":\"Returns the bep token owner.\"},\"name()\":{\"details\":\"Returns the token name.\"},\"symbol()\":{\"details\":\"Returns the token symbol.\"},\"totalSupply()\":{\"details\":\"Returns the amount of tokens in existence.\"},\"transfer(address,uint256)\":{\"details\":\"Moves `amount` tokens from the caller's account to `recipient`. Returns a boolean value indicating whether the operation succeeded. Emits a {Transfer} event.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"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.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"Maxim/lib/IBEP20.sol\":\"IBEP20\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"Maxim/lib/IBEP20.sol\":{\"keccak256\":\"0xe6555dcb6ec5cb9dcaf2322cf003a1e3d2257471768b32cdc433025a0bc3ac3d\",\"license\":\"GPL-3.0-or-later\",\"urls\":[\"bzz-raw://a1f47d4071cfc9f31174526b1a63d0be2169a199f0a5b9819267d9d070adad6d\",\"dweb:/ipfs/QmcmHiuPjMSXZLNubeScGkXvWAz6dM1cciv5zGPNJaK9Po\"]}},\"version\":1}", 360 | "storageLayout": { 361 | "storage": [], 362 | "types": null 363 | }, 364 | "userdoc": { 365 | "kind": "user", 366 | "methods": {}, 367 | "version": 1 368 | } 369 | } 370 | } 371 | }, 372 | "sources": { 373 | "Maxim/lib/IBEP20.sol": { 374 | "ast": { 375 | "absolutePath": "Maxim/lib/IBEP20.sol", 376 | "exportedSymbols": { 377 | "IBEP20": [ 378 | 100 379 | ] 380 | }, 381 | "id": 101, 382 | "license": "GPL-3.0-or-later", 383 | "nodeType": "SourceUnit", 384 | "nodes": [ 385 | { 386 | "id": 1, 387 | "literals": [ 388 | "solidity", 389 | ">=", 390 | "0.4", 391 | ".0" 392 | ], 393 | "nodeType": "PragmaDirective", 394 | "src": "48:24:0" 395 | }, 396 | { 397 | "abstract": false, 398 | "baseContracts": [], 399 | "canonicalName": "IBEP20", 400 | "contractDependencies": [], 401 | "contractKind": "interface", 402 | "fullyImplemented": false, 403 | "id": 100, 404 | "linearizedBaseContracts": [ 405 | 100 406 | ], 407 | "name": "IBEP20", 408 | "nameLocation": "86:6:0", 409 | "nodeType": "ContractDefinition", 410 | "nodes": [ 411 | { 412 | "documentation": { 413 | "id": 2, 414 | "nodeType": "StructuredDocumentation", 415 | "src": "100:68:0", 416 | "text": " @dev Returns the amount of tokens in existence." 417 | }, 418 | "functionSelector": "18160ddd", 419 | "id": 7, 420 | "implemented": false, 421 | "kind": "function", 422 | "modifiers": [], 423 | "name": "totalSupply", 424 | "nameLocation": "183:11:0", 425 | "nodeType": "FunctionDefinition", 426 | "parameters": { 427 | "id": 3, 428 | "nodeType": "ParameterList", 429 | "parameters": [], 430 | "src": "194:2:0" 431 | }, 432 | "returnParameters": { 433 | "id": 6, 434 | "nodeType": "ParameterList", 435 | "parameters": [ 436 | { 437 | "constant": false, 438 | "id": 5, 439 | "mutability": "mutable", 440 | "name": "", 441 | "nameLocation": "-1:-1:-1", 442 | "nodeType": "VariableDeclaration", 443 | "scope": 7, 444 | "src": "220:7:0", 445 | "stateVariable": false, 446 | "storageLocation": "default", 447 | "typeDescriptions": { 448 | "typeIdentifier": "t_uint256", 449 | "typeString": "uint256" 450 | }, 451 | "typeName": { 452 | "id": 4, 453 | "name": "uint256", 454 | "nodeType": "ElementaryTypeName", 455 | "src": "220:7:0", 456 | "typeDescriptions": { 457 | "typeIdentifier": "t_uint256", 458 | "typeString": "uint256" 459 | } 460 | }, 461 | "visibility": "internal" 462 | } 463 | ], 464 | "src": "219:9:0" 465 | }, 466 | "scope": 100, 467 | "src": "174:55:0", 468 | "stateMutability": "view", 469 | "virtual": false, 470 | "visibility": "external" 471 | }, 472 | { 473 | "documentation": { 474 | "id": 8, 475 | "nodeType": "StructuredDocumentation", 476 | "src": "237:53:0", 477 | "text": " @dev Returns the token decimals." 478 | }, 479 | "functionSelector": "313ce567", 480 | "id": 13, 481 | "implemented": false, 482 | "kind": "function", 483 | "modifiers": [], 484 | "name": "decimals", 485 | "nameLocation": "305:8:0", 486 | "nodeType": "FunctionDefinition", 487 | "parameters": { 488 | "id": 9, 489 | "nodeType": "ParameterList", 490 | "parameters": [], 491 | "src": "313:2:0" 492 | }, 493 | "returnParameters": { 494 | "id": 12, 495 | "nodeType": "ParameterList", 496 | "parameters": [ 497 | { 498 | "constant": false, 499 | "id": 11, 500 | "mutability": "mutable", 501 | "name": "", 502 | "nameLocation": "-1:-1:-1", 503 | "nodeType": "VariableDeclaration", 504 | "scope": 13, 505 | "src": "339:5:0", 506 | "stateVariable": false, 507 | "storageLocation": "default", 508 | "typeDescriptions": { 509 | "typeIdentifier": "t_uint8", 510 | "typeString": "uint8" 511 | }, 512 | "typeName": { 513 | "id": 10, 514 | "name": "uint8", 515 | "nodeType": "ElementaryTypeName", 516 | "src": "339:5:0", 517 | "typeDescriptions": { 518 | "typeIdentifier": "t_uint8", 519 | "typeString": "uint8" 520 | } 521 | }, 522 | "visibility": "internal" 523 | } 524 | ], 525 | "src": "338:7:0" 526 | }, 527 | "scope": 100, 528 | "src": "296:50:0", 529 | "stateMutability": "view", 530 | "virtual": false, 531 | "visibility": "external" 532 | }, 533 | { 534 | "documentation": { 535 | "id": 14, 536 | "nodeType": "StructuredDocumentation", 537 | "src": "354:51:0", 538 | "text": " @dev Returns the token symbol." 539 | }, 540 | "functionSelector": "95d89b41", 541 | "id": 19, 542 | "implemented": false, 543 | "kind": "function", 544 | "modifiers": [], 545 | "name": "symbol", 546 | "nameLocation": "420:6:0", 547 | "nodeType": "FunctionDefinition", 548 | "parameters": { 549 | "id": 15, 550 | "nodeType": "ParameterList", 551 | "parameters": [], 552 | "src": "426:2:0" 553 | }, 554 | "returnParameters": { 555 | "id": 18, 556 | "nodeType": "ParameterList", 557 | "parameters": [ 558 | { 559 | "constant": false, 560 | "id": 17, 561 | "mutability": "mutable", 562 | "name": "", 563 | "nameLocation": "-1:-1:-1", 564 | "nodeType": "VariableDeclaration", 565 | "scope": 19, 566 | "src": "452:13:0", 567 | "stateVariable": false, 568 | "storageLocation": "memory", 569 | "typeDescriptions": { 570 | "typeIdentifier": "t_string_memory_ptr", 571 | "typeString": "string" 572 | }, 573 | "typeName": { 574 | "id": 16, 575 | "name": "string", 576 | "nodeType": "ElementaryTypeName", 577 | "src": "452:6:0", 578 | "typeDescriptions": { 579 | "typeIdentifier": "t_string_storage_ptr", 580 | "typeString": "string" 581 | } 582 | }, 583 | "visibility": "internal" 584 | } 585 | ], 586 | "src": "451:15:0" 587 | }, 588 | "scope": 100, 589 | "src": "411:56:0", 590 | "stateMutability": "view", 591 | "virtual": false, 592 | "visibility": "external" 593 | }, 594 | { 595 | "documentation": { 596 | "id": 20, 597 | "nodeType": "StructuredDocumentation", 598 | "src": "475:49:0", 599 | "text": " @dev Returns the token name." 600 | }, 601 | "functionSelector": "06fdde03", 602 | "id": 25, 603 | "implemented": false, 604 | "kind": "function", 605 | "modifiers": [], 606 | "name": "name", 607 | "nameLocation": "539:4:0", 608 | "nodeType": "FunctionDefinition", 609 | "parameters": { 610 | "id": 21, 611 | "nodeType": "ParameterList", 612 | "parameters": [], 613 | "src": "543:2:0" 614 | }, 615 | "returnParameters": { 616 | "id": 24, 617 | "nodeType": "ParameterList", 618 | "parameters": [ 619 | { 620 | "constant": false, 621 | "id": 23, 622 | "mutability": "mutable", 623 | "name": "", 624 | "nameLocation": "-1:-1:-1", 625 | "nodeType": "VariableDeclaration", 626 | "scope": 25, 627 | "src": "569:13:0", 628 | "stateVariable": false, 629 | "storageLocation": "memory", 630 | "typeDescriptions": { 631 | "typeIdentifier": "t_string_memory_ptr", 632 | "typeString": "string" 633 | }, 634 | "typeName": { 635 | "id": 22, 636 | "name": "string", 637 | "nodeType": "ElementaryTypeName", 638 | "src": "569:6:0", 639 | "typeDescriptions": { 640 | "typeIdentifier": "t_string_storage_ptr", 641 | "typeString": "string" 642 | } 643 | }, 644 | "visibility": "internal" 645 | } 646 | ], 647 | "src": "568:15:0" 648 | }, 649 | "scope": 100, 650 | "src": "530:54:0", 651 | "stateMutability": "view", 652 | "virtual": false, 653 | "visibility": "external" 654 | }, 655 | { 656 | "documentation": { 657 | "id": 26, 658 | "nodeType": "StructuredDocumentation", 659 | "src": "592:54:0", 660 | "text": " @dev Returns the bep token owner." 661 | }, 662 | "functionSelector": "893d20e8", 663 | "id": 31, 664 | "implemented": false, 665 | "kind": "function", 666 | "modifiers": [], 667 | "name": "getOwner", 668 | "nameLocation": "661:8:0", 669 | "nodeType": "FunctionDefinition", 670 | "parameters": { 671 | "id": 27, 672 | "nodeType": "ParameterList", 673 | "parameters": [], 674 | "src": "669:2:0" 675 | }, 676 | "returnParameters": { 677 | "id": 30, 678 | "nodeType": "ParameterList", 679 | "parameters": [ 680 | { 681 | "constant": false, 682 | "id": 29, 683 | "mutability": "mutable", 684 | "name": "", 685 | "nameLocation": "-1:-1:-1", 686 | "nodeType": "VariableDeclaration", 687 | "scope": 31, 688 | "src": "695:7:0", 689 | "stateVariable": false, 690 | "storageLocation": "default", 691 | "typeDescriptions": { 692 | "typeIdentifier": "t_address", 693 | "typeString": "address" 694 | }, 695 | "typeName": { 696 | "id": 28, 697 | "name": "address", 698 | "nodeType": "ElementaryTypeName", 699 | "src": "695:7:0", 700 | "stateMutability": "nonpayable", 701 | "typeDescriptions": { 702 | "typeIdentifier": "t_address", 703 | "typeString": "address" 704 | } 705 | }, 706 | "visibility": "internal" 707 | } 708 | ], 709 | "src": "694:9:0" 710 | }, 711 | "scope": 100, 712 | "src": "652:52:0", 713 | "stateMutability": "view", 714 | "virtual": false, 715 | "visibility": "external" 716 | }, 717 | { 718 | "documentation": { 719 | "id": 32, 720 | "nodeType": "StructuredDocumentation", 721 | "src": "712:74:0", 722 | "text": " @dev Returns the amount of tokens owned by `account`." 723 | }, 724 | "functionSelector": "70a08231", 725 | "id": 39, 726 | "implemented": false, 727 | "kind": "function", 728 | "modifiers": [], 729 | "name": "balanceOf", 730 | "nameLocation": "801:9:0", 731 | "nodeType": "FunctionDefinition", 732 | "parameters": { 733 | "id": 35, 734 | "nodeType": "ParameterList", 735 | "parameters": [ 736 | { 737 | "constant": false, 738 | "id": 34, 739 | "mutability": "mutable", 740 | "name": "account", 741 | "nameLocation": "819:7:0", 742 | "nodeType": "VariableDeclaration", 743 | "scope": 39, 744 | "src": "811:15:0", 745 | "stateVariable": false, 746 | "storageLocation": "default", 747 | "typeDescriptions": { 748 | "typeIdentifier": "t_address", 749 | "typeString": "address" 750 | }, 751 | "typeName": { 752 | "id": 33, 753 | "name": "address", 754 | "nodeType": "ElementaryTypeName", 755 | "src": "811:7:0", 756 | "stateMutability": "nonpayable", 757 | "typeDescriptions": { 758 | "typeIdentifier": "t_address", 759 | "typeString": "address" 760 | } 761 | }, 762 | "visibility": "internal" 763 | } 764 | ], 765 | "src": "810:17:0" 766 | }, 767 | "returnParameters": { 768 | "id": 38, 769 | "nodeType": "ParameterList", 770 | "parameters": [ 771 | { 772 | "constant": false, 773 | "id": 37, 774 | "mutability": "mutable", 775 | "name": "", 776 | "nameLocation": "-1:-1:-1", 777 | "nodeType": "VariableDeclaration", 778 | "scope": 39, 779 | "src": "851:7:0", 780 | "stateVariable": false, 781 | "storageLocation": "default", 782 | "typeDescriptions": { 783 | "typeIdentifier": "t_uint256", 784 | "typeString": "uint256" 785 | }, 786 | "typeName": { 787 | "id": 36, 788 | "name": "uint256", 789 | "nodeType": "ElementaryTypeName", 790 | "src": "851:7:0", 791 | "typeDescriptions": { 792 | "typeIdentifier": "t_uint256", 793 | "typeString": "uint256" 794 | } 795 | }, 796 | "visibility": "internal" 797 | } 798 | ], 799 | "src": "850:9:0" 800 | }, 801 | "scope": 100, 802 | "src": "792:68:0", 803 | "stateMutability": "view", 804 | "virtual": false, 805 | "visibility": "external" 806 | }, 807 | { 808 | "documentation": { 809 | "id": 40, 810 | "nodeType": "StructuredDocumentation", 811 | "src": "868:215:0", 812 | "text": " @dev Moves `amount` tokens from the caller's account to `recipient`.\n Returns a boolean value indicating whether the operation succeeded.\n Emits a {Transfer} event." 813 | }, 814 | "functionSelector": "a9059cbb", 815 | "id": 49, 816 | "implemented": false, 817 | "kind": "function", 818 | "modifiers": [], 819 | "name": "transfer", 820 | "nameLocation": "1098:8:0", 821 | "nodeType": "FunctionDefinition", 822 | "parameters": { 823 | "id": 45, 824 | "nodeType": "ParameterList", 825 | "parameters": [ 826 | { 827 | "constant": false, 828 | "id": 42, 829 | "mutability": "mutable", 830 | "name": "recipient", 831 | "nameLocation": "1115:9:0", 832 | "nodeType": "VariableDeclaration", 833 | "scope": 49, 834 | "src": "1107:17:0", 835 | "stateVariable": false, 836 | "storageLocation": "default", 837 | "typeDescriptions": { 838 | "typeIdentifier": "t_address", 839 | "typeString": "address" 840 | }, 841 | "typeName": { 842 | "id": 41, 843 | "name": "address", 844 | "nodeType": "ElementaryTypeName", 845 | "src": "1107:7:0", 846 | "stateMutability": "nonpayable", 847 | "typeDescriptions": { 848 | "typeIdentifier": "t_address", 849 | "typeString": "address" 850 | } 851 | }, 852 | "visibility": "internal" 853 | }, 854 | { 855 | "constant": false, 856 | "id": 44, 857 | "mutability": "mutable", 858 | "name": "amount", 859 | "nameLocation": "1134:6:0", 860 | "nodeType": "VariableDeclaration", 861 | "scope": 49, 862 | "src": "1126:14:0", 863 | "stateVariable": false, 864 | "storageLocation": "default", 865 | "typeDescriptions": { 866 | "typeIdentifier": "t_uint256", 867 | "typeString": "uint256" 868 | }, 869 | "typeName": { 870 | "id": 43, 871 | "name": "uint256", 872 | "nodeType": "ElementaryTypeName", 873 | "src": "1126:7:0", 874 | "typeDescriptions": { 875 | "typeIdentifier": "t_uint256", 876 | "typeString": "uint256" 877 | } 878 | }, 879 | "visibility": "internal" 880 | } 881 | ], 882 | "src": "1106:35:0" 883 | }, 884 | "returnParameters": { 885 | "id": 48, 886 | "nodeType": "ParameterList", 887 | "parameters": [ 888 | { 889 | "constant": false, 890 | "id": 47, 891 | "mutability": "mutable", 892 | "name": "", 893 | "nameLocation": "-1:-1:-1", 894 | "nodeType": "VariableDeclaration", 895 | "scope": 49, 896 | "src": "1160:4:0", 897 | "stateVariable": false, 898 | "storageLocation": "default", 899 | "typeDescriptions": { 900 | "typeIdentifier": "t_bool", 901 | "typeString": "bool" 902 | }, 903 | "typeName": { 904 | "id": 46, 905 | "name": "bool", 906 | "nodeType": "ElementaryTypeName", 907 | "src": "1160:4:0", 908 | "typeDescriptions": { 909 | "typeIdentifier": "t_bool", 910 | "typeString": "bool" 911 | } 912 | }, 913 | "visibility": "internal" 914 | } 915 | ], 916 | "src": "1159:6:0" 917 | }, 918 | "scope": 100, 919 | "src": "1089:77:0", 920 | "stateMutability": "nonpayable", 921 | "virtual": false, 922 | "visibility": "external" 923 | }, 924 | { 925 | "documentation": { 926 | "id": 50, 927 | "nodeType": "StructuredDocumentation", 928 | "src": "1174:270:0", 929 | "text": " @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 This value changes when {approve} or {transferFrom} are called." 930 | }, 931 | "functionSelector": "dd62ed3e", 932 | "id": 59, 933 | "implemented": false, 934 | "kind": "function", 935 | "modifiers": [], 936 | "name": "allowance", 937 | "nameLocation": "1459:9:0", 938 | "nodeType": "FunctionDefinition", 939 | "parameters": { 940 | "id": 55, 941 | "nodeType": "ParameterList", 942 | "parameters": [ 943 | { 944 | "constant": false, 945 | "id": 52, 946 | "mutability": "mutable", 947 | "name": "_owner", 948 | "nameLocation": "1477:6:0", 949 | "nodeType": "VariableDeclaration", 950 | "scope": 59, 951 | "src": "1469:14:0", 952 | "stateVariable": false, 953 | "storageLocation": "default", 954 | "typeDescriptions": { 955 | "typeIdentifier": "t_address", 956 | "typeString": "address" 957 | }, 958 | "typeName": { 959 | "id": 51, 960 | "name": "address", 961 | "nodeType": "ElementaryTypeName", 962 | "src": "1469:7:0", 963 | "stateMutability": "nonpayable", 964 | "typeDescriptions": { 965 | "typeIdentifier": "t_address", 966 | "typeString": "address" 967 | } 968 | }, 969 | "visibility": "internal" 970 | }, 971 | { 972 | "constant": false, 973 | "id": 54, 974 | "mutability": "mutable", 975 | "name": "spender", 976 | "nameLocation": "1493:7:0", 977 | "nodeType": "VariableDeclaration", 978 | "scope": 59, 979 | "src": "1485:15:0", 980 | "stateVariable": false, 981 | "storageLocation": "default", 982 | "typeDescriptions": { 983 | "typeIdentifier": "t_address", 984 | "typeString": "address" 985 | }, 986 | "typeName": { 987 | "id": 53, 988 | "name": "address", 989 | "nodeType": "ElementaryTypeName", 990 | "src": "1485:7:0", 991 | "stateMutability": "nonpayable", 992 | "typeDescriptions": { 993 | "typeIdentifier": "t_address", 994 | "typeString": "address" 995 | } 996 | }, 997 | "visibility": "internal" 998 | } 999 | ], 1000 | "src": "1468:33:0" 1001 | }, 1002 | "returnParameters": { 1003 | "id": 58, 1004 | "nodeType": "ParameterList", 1005 | "parameters": [ 1006 | { 1007 | "constant": false, 1008 | "id": 57, 1009 | "mutability": "mutable", 1010 | "name": "", 1011 | "nameLocation": "-1:-1:-1", 1012 | "nodeType": "VariableDeclaration", 1013 | "scope": 59, 1014 | "src": "1525:7:0", 1015 | "stateVariable": false, 1016 | "storageLocation": "default", 1017 | "typeDescriptions": { 1018 | "typeIdentifier": "t_uint256", 1019 | "typeString": "uint256" 1020 | }, 1021 | "typeName": { 1022 | "id": 56, 1023 | "name": "uint256", 1024 | "nodeType": "ElementaryTypeName", 1025 | "src": "1525:7:0", 1026 | "typeDescriptions": { 1027 | "typeIdentifier": "t_uint256", 1028 | "typeString": "uint256" 1029 | } 1030 | }, 1031 | "visibility": "internal" 1032 | } 1033 | ], 1034 | "src": "1524:9:0" 1035 | }, 1036 | "scope": 100, 1037 | "src": "1450:84:0", 1038 | "stateMutability": "view", 1039 | "virtual": false, 1040 | "visibility": "external" 1041 | }, 1042 | { 1043 | "documentation": { 1044 | "id": 60, 1045 | "nodeType": "StructuredDocumentation", 1046 | "src": "1542:655:0", 1047 | "text": " @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n Returns a boolean value indicating whether the operation succeeded.\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 Emits an {Approval} event." 1048 | }, 1049 | "functionSelector": "095ea7b3", 1050 | "id": 69, 1051 | "implemented": false, 1052 | "kind": "function", 1053 | "modifiers": [], 1054 | "name": "approve", 1055 | "nameLocation": "2212:7:0", 1056 | "nodeType": "FunctionDefinition", 1057 | "parameters": { 1058 | "id": 65, 1059 | "nodeType": "ParameterList", 1060 | "parameters": [ 1061 | { 1062 | "constant": false, 1063 | "id": 62, 1064 | "mutability": "mutable", 1065 | "name": "spender", 1066 | "nameLocation": "2228:7:0", 1067 | "nodeType": "VariableDeclaration", 1068 | "scope": 69, 1069 | "src": "2220:15:0", 1070 | "stateVariable": false, 1071 | "storageLocation": "default", 1072 | "typeDescriptions": { 1073 | "typeIdentifier": "t_address", 1074 | "typeString": "address" 1075 | }, 1076 | "typeName": { 1077 | "id": 61, 1078 | "name": "address", 1079 | "nodeType": "ElementaryTypeName", 1080 | "src": "2220:7:0", 1081 | "stateMutability": "nonpayable", 1082 | "typeDescriptions": { 1083 | "typeIdentifier": "t_address", 1084 | "typeString": "address" 1085 | } 1086 | }, 1087 | "visibility": "internal" 1088 | }, 1089 | { 1090 | "constant": false, 1091 | "id": 64, 1092 | "mutability": "mutable", 1093 | "name": "amount", 1094 | "nameLocation": "2245:6:0", 1095 | "nodeType": "VariableDeclaration", 1096 | "scope": 69, 1097 | "src": "2237:14:0", 1098 | "stateVariable": false, 1099 | "storageLocation": "default", 1100 | "typeDescriptions": { 1101 | "typeIdentifier": "t_uint256", 1102 | "typeString": "uint256" 1103 | }, 1104 | "typeName": { 1105 | "id": 63, 1106 | "name": "uint256", 1107 | "nodeType": "ElementaryTypeName", 1108 | "src": "2237:7:0", 1109 | "typeDescriptions": { 1110 | "typeIdentifier": "t_uint256", 1111 | "typeString": "uint256" 1112 | } 1113 | }, 1114 | "visibility": "internal" 1115 | } 1116 | ], 1117 | "src": "2219:33:0" 1118 | }, 1119 | "returnParameters": { 1120 | "id": 68, 1121 | "nodeType": "ParameterList", 1122 | "parameters": [ 1123 | { 1124 | "constant": false, 1125 | "id": 67, 1126 | "mutability": "mutable", 1127 | "name": "", 1128 | "nameLocation": "-1:-1:-1", 1129 | "nodeType": "VariableDeclaration", 1130 | "scope": 69, 1131 | "src": "2271:4:0", 1132 | "stateVariable": false, 1133 | "storageLocation": "default", 1134 | "typeDescriptions": { 1135 | "typeIdentifier": "t_bool", 1136 | "typeString": "bool" 1137 | }, 1138 | "typeName": { 1139 | "id": 66, 1140 | "name": "bool", 1141 | "nodeType": "ElementaryTypeName", 1142 | "src": "2271:4:0", 1143 | "typeDescriptions": { 1144 | "typeIdentifier": "t_bool", 1145 | "typeString": "bool" 1146 | } 1147 | }, 1148 | "visibility": "internal" 1149 | } 1150 | ], 1151 | "src": "2270:6:0" 1152 | }, 1153 | "scope": 100, 1154 | "src": "2203:74:0", 1155 | "stateMutability": "nonpayable", 1156 | "virtual": false, 1157 | "visibility": "external" 1158 | }, 1159 | { 1160 | "documentation": { 1161 | "id": 70, 1162 | "nodeType": "StructuredDocumentation", 1163 | "src": "2285:304:0", 1164 | "text": " @dev Moves `amount` tokens from `sender` to `recipient` using the\n allowance mechanism. `amount` is then deducted from the caller's\n allowance.\n Returns a boolean value indicating whether the operation succeeded.\n Emits a {Transfer} event." 1165 | }, 1166 | "functionSelector": "23b872dd", 1167 | "id": 81, 1168 | "implemented": false, 1169 | "kind": "function", 1170 | "modifiers": [], 1171 | "name": "transferFrom", 1172 | "nameLocation": "2604:12:0", 1173 | "nodeType": "FunctionDefinition", 1174 | "parameters": { 1175 | "id": 77, 1176 | "nodeType": "ParameterList", 1177 | "parameters": [ 1178 | { 1179 | "constant": false, 1180 | "id": 72, 1181 | "mutability": "mutable", 1182 | "name": "sender", 1183 | "nameLocation": "2635:6:0", 1184 | "nodeType": "VariableDeclaration", 1185 | "scope": 81, 1186 | "src": "2627:14:0", 1187 | "stateVariable": false, 1188 | "storageLocation": "default", 1189 | "typeDescriptions": { 1190 | "typeIdentifier": "t_address", 1191 | "typeString": "address" 1192 | }, 1193 | "typeName": { 1194 | "id": 71, 1195 | "name": "address", 1196 | "nodeType": "ElementaryTypeName", 1197 | "src": "2627:7:0", 1198 | "stateMutability": "nonpayable", 1199 | "typeDescriptions": { 1200 | "typeIdentifier": "t_address", 1201 | "typeString": "address" 1202 | } 1203 | }, 1204 | "visibility": "internal" 1205 | }, 1206 | { 1207 | "constant": false, 1208 | "id": 74, 1209 | "mutability": "mutable", 1210 | "name": "recipient", 1211 | "nameLocation": "2660:9:0", 1212 | "nodeType": "VariableDeclaration", 1213 | "scope": 81, 1214 | "src": "2652:17:0", 1215 | "stateVariable": false, 1216 | "storageLocation": "default", 1217 | "typeDescriptions": { 1218 | "typeIdentifier": "t_address", 1219 | "typeString": "address" 1220 | }, 1221 | "typeName": { 1222 | "id": 73, 1223 | "name": "address", 1224 | "nodeType": "ElementaryTypeName", 1225 | "src": "2652:7:0", 1226 | "stateMutability": "nonpayable", 1227 | "typeDescriptions": { 1228 | "typeIdentifier": "t_address", 1229 | "typeString": "address" 1230 | } 1231 | }, 1232 | "visibility": "internal" 1233 | }, 1234 | { 1235 | "constant": false, 1236 | "id": 76, 1237 | "mutability": "mutable", 1238 | "name": "amount", 1239 | "nameLocation": "2688:6:0", 1240 | "nodeType": "VariableDeclaration", 1241 | "scope": 81, 1242 | "src": "2680:14:0", 1243 | "stateVariable": false, 1244 | "storageLocation": "default", 1245 | "typeDescriptions": { 1246 | "typeIdentifier": "t_uint256", 1247 | "typeString": "uint256" 1248 | }, 1249 | "typeName": { 1250 | "id": 75, 1251 | "name": "uint256", 1252 | "nodeType": "ElementaryTypeName", 1253 | "src": "2680:7:0", 1254 | "typeDescriptions": { 1255 | "typeIdentifier": "t_uint256", 1256 | "typeString": "uint256" 1257 | } 1258 | }, 1259 | "visibility": "internal" 1260 | } 1261 | ], 1262 | "src": "2616:85:0" 1263 | }, 1264 | "returnParameters": { 1265 | "id": 80, 1266 | "nodeType": "ParameterList", 1267 | "parameters": [ 1268 | { 1269 | "constant": false, 1270 | "id": 79, 1271 | "mutability": "mutable", 1272 | "name": "", 1273 | "nameLocation": "-1:-1:-1", 1274 | "nodeType": "VariableDeclaration", 1275 | "scope": 81, 1276 | "src": "2720:4:0", 1277 | "stateVariable": false, 1278 | "storageLocation": "default", 1279 | "typeDescriptions": { 1280 | "typeIdentifier": "t_bool", 1281 | "typeString": "bool" 1282 | }, 1283 | "typeName": { 1284 | "id": 78, 1285 | "name": "bool", 1286 | "nodeType": "ElementaryTypeName", 1287 | "src": "2720:4:0", 1288 | "typeDescriptions": { 1289 | "typeIdentifier": "t_bool", 1290 | "typeString": "bool" 1291 | } 1292 | }, 1293 | "visibility": "internal" 1294 | } 1295 | ], 1296 | "src": "2719:6:0" 1297 | }, 1298 | "scope": 100, 1299 | "src": "2595:131:0", 1300 | "stateMutability": "nonpayable", 1301 | "virtual": false, 1302 | "visibility": "external" 1303 | }, 1304 | { 1305 | "anonymous": false, 1306 | "documentation": { 1307 | "id": 82, 1308 | "nodeType": "StructuredDocumentation", 1309 | "src": "2734:163:0", 1310 | "text": " @dev Emitted when `value` tokens are moved from one account (`from`) to\n another (`to`).\n Note that `value` may be zero." 1311 | }, 1312 | "eventSelector": "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef", 1313 | "id": 90, 1314 | "name": "Transfer", 1315 | "nameLocation": "2909:8:0", 1316 | "nodeType": "EventDefinition", 1317 | "parameters": { 1318 | "id": 89, 1319 | "nodeType": "ParameterList", 1320 | "parameters": [ 1321 | { 1322 | "constant": false, 1323 | "id": 84, 1324 | "indexed": true, 1325 | "mutability": "mutable", 1326 | "name": "from", 1327 | "nameLocation": "2934:4:0", 1328 | "nodeType": "VariableDeclaration", 1329 | "scope": 90, 1330 | "src": "2918:20:0", 1331 | "stateVariable": false, 1332 | "storageLocation": "default", 1333 | "typeDescriptions": { 1334 | "typeIdentifier": "t_address", 1335 | "typeString": "address" 1336 | }, 1337 | "typeName": { 1338 | "id": 83, 1339 | "name": "address", 1340 | "nodeType": "ElementaryTypeName", 1341 | "src": "2918:7:0", 1342 | "stateMutability": "nonpayable", 1343 | "typeDescriptions": { 1344 | "typeIdentifier": "t_address", 1345 | "typeString": "address" 1346 | } 1347 | }, 1348 | "visibility": "internal" 1349 | }, 1350 | { 1351 | "constant": false, 1352 | "id": 86, 1353 | "indexed": true, 1354 | "mutability": "mutable", 1355 | "name": "to", 1356 | "nameLocation": "2956:2:0", 1357 | "nodeType": "VariableDeclaration", 1358 | "scope": 90, 1359 | "src": "2940:18:0", 1360 | "stateVariable": false, 1361 | "storageLocation": "default", 1362 | "typeDescriptions": { 1363 | "typeIdentifier": "t_address", 1364 | "typeString": "address" 1365 | }, 1366 | "typeName": { 1367 | "id": 85, 1368 | "name": "address", 1369 | "nodeType": "ElementaryTypeName", 1370 | "src": "2940:7:0", 1371 | "stateMutability": "nonpayable", 1372 | "typeDescriptions": { 1373 | "typeIdentifier": "t_address", 1374 | "typeString": "address" 1375 | } 1376 | }, 1377 | "visibility": "internal" 1378 | }, 1379 | { 1380 | "constant": false, 1381 | "id": 88, 1382 | "indexed": false, 1383 | "mutability": "mutable", 1384 | "name": "value", 1385 | "nameLocation": "2968:5:0", 1386 | "nodeType": "VariableDeclaration", 1387 | "scope": 90, 1388 | "src": "2960:13:0", 1389 | "stateVariable": false, 1390 | "storageLocation": "default", 1391 | "typeDescriptions": { 1392 | "typeIdentifier": "t_uint256", 1393 | "typeString": "uint256" 1394 | }, 1395 | "typeName": { 1396 | "id": 87, 1397 | "name": "uint256", 1398 | "nodeType": "ElementaryTypeName", 1399 | "src": "2960:7:0", 1400 | "typeDescriptions": { 1401 | "typeIdentifier": "t_uint256", 1402 | "typeString": "uint256" 1403 | } 1404 | }, 1405 | "visibility": "internal" 1406 | } 1407 | ], 1408 | "src": "2917:57:0" 1409 | }, 1410 | "src": "2903:72:0" 1411 | }, 1412 | { 1413 | "anonymous": false, 1414 | "documentation": { 1415 | "id": 91, 1416 | "nodeType": "StructuredDocumentation", 1417 | "src": "2983:151:0", 1418 | "text": " @dev Emitted when the allowance of a `spender` for an `owner` is set by\n a call to {approve}. `value` is the new allowance." 1419 | }, 1420 | "eventSelector": "8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925", 1421 | "id": 99, 1422 | "name": "Approval", 1423 | "nameLocation": "3146:8:0", 1424 | "nodeType": "EventDefinition", 1425 | "parameters": { 1426 | "id": 98, 1427 | "nodeType": "ParameterList", 1428 | "parameters": [ 1429 | { 1430 | "constant": false, 1431 | "id": 93, 1432 | "indexed": true, 1433 | "mutability": "mutable", 1434 | "name": "owner", 1435 | "nameLocation": "3171:5:0", 1436 | "nodeType": "VariableDeclaration", 1437 | "scope": 99, 1438 | "src": "3155:21:0", 1439 | "stateVariable": false, 1440 | "storageLocation": "default", 1441 | "typeDescriptions": { 1442 | "typeIdentifier": "t_address", 1443 | "typeString": "address" 1444 | }, 1445 | "typeName": { 1446 | "id": 92, 1447 | "name": "address", 1448 | "nodeType": "ElementaryTypeName", 1449 | "src": "3155:7:0", 1450 | "stateMutability": "nonpayable", 1451 | "typeDescriptions": { 1452 | "typeIdentifier": "t_address", 1453 | "typeString": "address" 1454 | } 1455 | }, 1456 | "visibility": "internal" 1457 | }, 1458 | { 1459 | "constant": false, 1460 | "id": 95, 1461 | "indexed": true, 1462 | "mutability": "mutable", 1463 | "name": "spender", 1464 | "nameLocation": "3194:7:0", 1465 | "nodeType": "VariableDeclaration", 1466 | "scope": 99, 1467 | "src": "3178:23:0", 1468 | "stateVariable": false, 1469 | "storageLocation": "default", 1470 | "typeDescriptions": { 1471 | "typeIdentifier": "t_address", 1472 | "typeString": "address" 1473 | }, 1474 | "typeName": { 1475 | "id": 94, 1476 | "name": "address", 1477 | "nodeType": "ElementaryTypeName", 1478 | "src": "3178:7:0", 1479 | "stateMutability": "nonpayable", 1480 | "typeDescriptions": { 1481 | "typeIdentifier": "t_address", 1482 | "typeString": "address" 1483 | } 1484 | }, 1485 | "visibility": "internal" 1486 | }, 1487 | { 1488 | "constant": false, 1489 | "id": 97, 1490 | "indexed": false, 1491 | "mutability": "mutable", 1492 | "name": "value", 1493 | "nameLocation": "3211:5:0", 1494 | "nodeType": "VariableDeclaration", 1495 | "scope": 99, 1496 | "src": "3203:13:0", 1497 | "stateVariable": false, 1498 | "storageLocation": "default", 1499 | "typeDescriptions": { 1500 | "typeIdentifier": "t_uint256", 1501 | "typeString": "uint256" 1502 | }, 1503 | "typeName": { 1504 | "id": 96, 1505 | "name": "uint256", 1506 | "nodeType": "ElementaryTypeName", 1507 | "src": "3203:7:0", 1508 | "typeDescriptions": { 1509 | "typeIdentifier": "t_uint256", 1510 | "typeString": "uint256" 1511 | } 1512 | }, 1513 | "visibility": "internal" 1514 | } 1515 | ], 1516 | "src": "3154:63:0" 1517 | }, 1518 | "src": "3140:78:0" 1519 | } 1520 | ], 1521 | "scope": 101, 1522 | "src": "76:3145:0", 1523 | "usedErrors": [] 1524 | } 1525 | ], 1526 | "src": "48:3173:0" 1527 | }, 1528 | "id": 0 1529 | } 1530 | } 1531 | } 1532 | } --------------------------------------------------------------------------------