From 3f61eaae0c4d97a74a6a08a88c6b8ec5b82b8618 Mon Sep 17 00:00:00 2001 From: victor Date: Wed, 4 Oct 2017 11:13:34 +0200 Subject: [PATCH 01/37] add iexec-oracle-contract to deps --- package-lock.json | 11 +++++++++++ package.json | 22 ++++++++++++++++++++++ 2 files changed, 33 insertions(+) create mode 100644 package-lock.json create mode 100644 package.json diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..daa1bed --- /dev/null +++ b/package-lock.json @@ -0,0 +1,11 @@ +{ + "name": "iexec-dapp-init", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "iexec-oracle-contract": { + "version": "github:iExecBlockchainComputing/iexec-oracle-contract#64d31fa289acdd1a1f4a4c1d9426b9f610134a94" + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..3c82fbc --- /dev/null +++ b/package.json @@ -0,0 +1,22 @@ +{ + "name": "iexec-dapp-init", + "version": "1.0.0", + "description": "This is the registry for sample iexec dapps, used by the iexec-sdk cli.", + "main": "iexec.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/iExecBlockchainComputing/iexec-dapp-samples.git" + }, + "author": "", + "license": "ISC", + "bugs": { + "url": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples/issues" + }, + "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", + "dependencies": { + "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.0" + } +} From e44acc061f32b5e99515c82b0b336ec0160287a7 Mon Sep 17 00:00:00 2001 From: victor Date: Wed, 4 Oct 2017 11:13:39 +0200 Subject: [PATCH 02/37] add gitignore --- .gitignore | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fd4eb98 --- /dev/null +++ b/.gitignore @@ -0,0 +1,28 @@ +# Logs +logs +*.log +npm-debug.log* + +# Runtime data +pids +*.pid +*.seed + +# Coverage directory used by tools like istanbul +coverage + +# node-waf configuration +.lock-wscript + +# Dependency directory +node_modules + +# Compiled JS directory +/dist/* +!/dist/iexec.js + +# Optional npm cache directory +.npm + +# Optional REPL history +.node_repl_history From 104105ef454b5a7173d4e7316f1ee541c1491f74 Mon Sep 17 00:00:00 2001 From: victor Date: Wed, 4 Oct 2017 11:20:12 +0200 Subject: [PATCH 03/37] use IexecOracleAPI from npm instead of local --- contracts/MyContract.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/contracts/MyContract.sol b/contracts/MyContract.sol index 5382017..f64a050 100644 --- a/contracts/MyContract.sol +++ b/contracts/MyContract.sol @@ -1,9 +1,9 @@ pragma solidity ^0.4.11; -import "./IexecOracleAPI.sol"; +import "iexec-oracle-contract/contracts/IexecOracleAPI.sol"; contract MyContract is IexecOracleAPI{ function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress){ } -} \ No newline at end of file +} From 0334db32ae97e1371819b4d925e068c3b4a35fd1 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Tue, 17 Oct 2017 12:46:55 +0200 Subject: [PATCH 04/37] add DAPP_PRICE --- contracts/MyContract.sol | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/contracts/MyContract.sol b/contracts/MyContract.sol index f64a050..c244a7b 100644 --- a/contracts/MyContract.sol +++ b/contracts/MyContract.sol @@ -2,7 +2,9 @@ pragma solidity ^0.4.11; import "iexec-oracle-contract/contracts/IexecOracleAPI.sol"; contract MyContract is IexecOracleAPI{ - function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress){ + uint public constant DAPP_PRICE = 0; + + function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE){ } From d80832b956ad28123777063b0a45b34523d549d2 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Wed, 18 Oct 2017 11:52:02 +0200 Subject: [PATCH 05/37] Update package.json --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 3c82fbc..f91886d 100644 --- a/package.json +++ b/package.json @@ -17,6 +17,6 @@ }, "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", "dependencies": { - "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.0" + "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.4" } } From bf373ca75f7eaa53f43ba2ed63ce65689a7c600d Mon Sep 17 00:00:00 2001 From: fbranciard Date: Wed, 18 Oct 2017 15:26:00 +0200 Subject: [PATCH 06/37] Update truffle.js --- truffle.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/truffle.js b/truffle.js index 87b347c..47c2e49 100644 --- a/truffle.js +++ b/truffle.js @@ -1,3 +1,9 @@ +const oracleJSON = require('iexec-oracle-contract/build/contracts/IexecOracle.json'); + +const ROPSTEN_ORACLE_ADDRESS = oracleJSON.networks['3'].address; +const RINKEBY_ORACLE_ADDRESS = oracleJSON.networks['4'].address; +const KOVAN_ORACLE_ADDRESS = oracleJSON.networks['42'].address; + module.exports = { networks: { development: { From 7485cf80dcc6a47baa2fc1971bf7f34011e58a59 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Wed, 18 Oct 2017 15:27:45 +0200 Subject: [PATCH 07/37] Update truffle.js --- truffle.js | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/truffle.js b/truffle.js index 47c2e49..6a8eab3 100644 --- a/truffle.js +++ b/truffle.js @@ -15,7 +15,7 @@ module.exports = { host: "https://ropsten.infura.io/berv5GTB5cSdOJPPnqOq", port: 8545, network_id: "3", - iexecOracleAddress: "0xb34406538112bd2b3036b2c417c7cff827777a11", // oracle v0.1.2 ropsten + constructorArgs: [ROPSTEN_ORACLE_ADDRESS], // gasPriceMultiplier: 2, // use factor 2 of the network estimated gasPrice // gasLimitMultiplier: 4, // use factor 4 of the network estimated gasLimit // gasPrice: 21000000000 // manually set the gasPrice in gwei. Prefer "gasPriceMultiplier" @@ -25,13 +25,13 @@ module.exports = { host: "https://rinkeby.infura.io/berv5GTB5cSdOJPPnqOq", port: 8545, network_id: "4", - iexecOracleAddress: "0x98275d4b6511ef05ed063d127dd82b72588326c9",// oracle v0.1.2 rinkeby + constructorArgs: [RINKEBY_ORACLE_ADDRESS], }, kovan: { host: "https://kovan.infura.io/berv5GTB5cSdOJPPnqOq", port: 8545, network_id: "42", - iexecOracleAddress: "0xb81d38d843cb526a3d0c3130d568fe09799135aa",// oracle v0.1.2 kovan + constructorArgs: [KOVAN_ORACLE_ADDRESS], }, } }; From a8d115ed9c2c8bef20d2d7d1724da5295dd3098d Mon Sep 17 00:00:00 2001 From: fbranciard Date: Wed, 18 Oct 2017 15:28:35 +0200 Subject: [PATCH 08/37] Update truffle.js --- truffle.js | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/truffle.js b/truffle.js index 6a8eab3..f6e5b60 100644 --- a/truffle.js +++ b/truffle.js @@ -3,13 +3,15 @@ const oracleJSON = require('iexec-oracle-contract/build/contracts/IexecOracle.js const ROPSTEN_ORACLE_ADDRESS = oracleJSON.networks['3'].address; const RINKEBY_ORACLE_ADDRESS = oracleJSON.networks['4'].address; const KOVAN_ORACLE_ADDRESS = oracleJSON.networks['42'].address; +const LOCAL_ORACLE_ADDRESS = 'LOCAL_ORACLE_ADDRESS_VALUE'; module.exports = { networks: { development: { host: "http://localhost:8545", port: 8545, - network_id: "*" // Match any network id + network_id: "*" // Match any network id, + constructorArgs: [LOCAL_ORACLE_ADDRESS], }, ropsten: { host: "https://ropsten.infura.io/berv5GTB5cSdOJPPnqOq", From be235cbd6feb075b6109d9654ea38fb72c477b5c Mon Sep 17 00:00:00 2001 From: fbranciard Date: Wed, 25 Oct 2017 18:01:26 +0200 Subject: [PATCH 09/37] Update MyContract.sol --- contracts/MyContract.sol | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/contracts/MyContract.sol b/contracts/MyContract.sol index c244a7b..ab269b8 100644 --- a/contracts/MyContract.sol +++ b/contracts/MyContract.sol @@ -3,8 +3,9 @@ import "iexec-oracle-contract/contracts/IexecOracleAPI.sol"; contract MyContract is IexecOracleAPI{ uint public constant DAPP_PRICE = 0; + string public constant DAPP_NAME = "init"; - function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE){ + function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){ } From 8534944e16c71e531807d194eb2f93df9c8771c5 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Thu, 9 Nov 2017 19:49:43 -0500 Subject: [PATCH 10/37] Update iexec.js --- iexec.js | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/iexec.js b/iexec.js index ddb3c67..589dc09 100644 --- a/iexec.js +++ b/iexec.js @@ -1,6 +1,3 @@ module.exports = { - name: 'MyContract', - constructorArgs: ['0xb34406538112bd2b3036b2c417c7cff827777a11'], // oracle v0.1.2 ropsten - // constructorArgs: ['0x98275d4b6511ef05ed063d127dd82b72588326c9'], // oracle v0.1.2 rinkeby - // constructorArgs: ['0xb81d38d843cb526a3d0c3130d568fe09799135aa'], // oracle v0.1.2 kovan -}; \ No newline at end of file + name: 'MyContract' +}; From 188f445a3fe3db5df42ad30da144103c9cbf81e5 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Thu, 9 Nov 2017 19:50:29 -0500 Subject: [PATCH 11/37] Update package.json --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index f91886d..4686bee 100644 --- a/package.json +++ b/package.json @@ -17,6 +17,6 @@ }, "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", "dependencies": { - "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.4" + "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.9" } } From d0627ab20c8c118df0e5b2dced85e685ea769904 Mon Sep 17 00:00:00 2001 From: fbranciard Date: Fri, 10 Nov 2017 15:24:41 -0500 Subject: [PATCH 12/37] missing coma --- iexec.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/iexec.js b/iexec.js index 589dc09..57dee80 100644 --- a/iexec.js +++ b/iexec.js @@ -1,3 +1,3 @@ module.exports = { - name: 'MyContract' + name: 'MyContract', }; From b1c5568f984782c853453660998d18ea28e17e76 Mon Sep 17 00:00:00 2001 From: Andy92Pac Date: Sat, 11 Nov 2017 17:00:44 +0100 Subject: [PATCH 13/37] Adding missing comma to truffle.js This missing comma raise an exception when calling iexec commands --- truffle.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/truffle.js b/truffle.js index f6e5b60..7444b21 100644 --- a/truffle.js +++ b/truffle.js @@ -10,7 +10,7 @@ module.exports = { development: { host: "http://localhost:8545", port: 8545, - network_id: "*" // Match any network id, + network_id: "*", // Match any network id, constructorArgs: [LOCAL_ORACLE_ADDRESS], }, ropsten: { From 5830dc270cf186ef81998142ebe2d1c9f9e0127c Mon Sep 17 00:00:00 2001 From: francois branciard Date: Fri, 8 Dec 2017 16:33:49 +0100 Subject: [PATCH 14/37] add README --- apps/README.md | 7 +++++++ 1 file changed, 7 insertions(+) create mode 100644 apps/README.md diff --git a/apps/README.md b/apps/README.md new file mode 100644 index 0000000..3a425c0 --- /dev/null +++ b/apps/README.md @@ -0,0 +1,7 @@ +Your iexec Dapp is composed of : + +* under apps directory : +the offchain app, which can be any kind of legacy application. The offchain app will be executed by the iexec decentralized cloud. + +* under contracts directory : +a smart contract that interfaces your iExec Dapp from Ethereum to the offchain app. From 3c54f1d6270b882d5cbb50b588940b6f796832d9 Mon Sep 17 00:00:00 2001 From: victor Date: Wed, 13 Dec 2017 12:08:14 +0100 Subject: [PATCH 15/37] update oracle to v1.1.1 --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 4686bee..d4bfaa0 100644 --- a/package.json +++ b/package.json @@ -17,6 +17,6 @@ }, "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", "dependencies": { - "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.0.9" + "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.1.1" } } From 5ac27924dbb289ca520a5f3f3d4621c3fe146a2e Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 00:36:40 +0100 Subject: [PATCH 16/37] immprove readme --- README.md | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index fecb605..cafe4bf 100644 --- a/README.md +++ b/README.md @@ -1,13 +1,14 @@ -# iexec dapps samples +# iExec dapp samples -This is the registry for sample iexec dapps, used by the iexec-sdk cli. +Each branch of this repo is a sample iExec dapp, and can be easily played with by using the [iexec sdk cli](https://github.com/iExecBlockchainComputing/iexec-sdk) like this: +```iexec init branchName``` -Each branch name of this repo can be used as an argument to iexec init command. - -ex: +# Example ```bash -iexec init -iexec init factorial -iexec init echo +iexec init # current branch containing minimum working config +iexec init factorial # download and init factorial dapp +iexec init echo # download and init echo dapp ``` + +You are warmly welcome to push your dapp on a new branch in this repo. You may even request to be listed on the [iExec dapp store](https://iex.ec) From 01729054a51eba78a937be76be3948d951e9840d Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 00:37:33 +0100 Subject: [PATCH 17/37] remove truffle.js --- truffle.js | 39 --------------------------------------- 1 file changed, 39 deletions(-) delete mode 100644 truffle.js diff --git a/truffle.js b/truffle.js deleted file mode 100644 index 7444b21..0000000 --- a/truffle.js +++ /dev/null @@ -1,39 +0,0 @@ -const oracleJSON = require('iexec-oracle-contract/build/contracts/IexecOracle.json'); - -const ROPSTEN_ORACLE_ADDRESS = oracleJSON.networks['3'].address; -const RINKEBY_ORACLE_ADDRESS = oracleJSON.networks['4'].address; -const KOVAN_ORACLE_ADDRESS = oracleJSON.networks['42'].address; -const LOCAL_ORACLE_ADDRESS = 'LOCAL_ORACLE_ADDRESS_VALUE'; - -module.exports = { - networks: { - development: { - host: "http://localhost:8545", - port: 8545, - network_id: "*", // Match any network id, - constructorArgs: [LOCAL_ORACLE_ADDRESS], - }, - ropsten: { - host: "https://ropsten.infura.io/berv5GTB5cSdOJPPnqOq", - port: 8545, - network_id: "3", - constructorArgs: [ROPSTEN_ORACLE_ADDRESS], - // gasPriceMultiplier: 2, // use factor 2 of the network estimated gasPrice - // gasLimitMultiplier: 4, // use factor 4 of the network estimated gasLimit - // gasPrice: 21000000000 // manually set the gasPrice in gwei. Prefer "gasPriceMultiplier" - // gas: 400000 // manually set the gas limit in gwei. Prefer "gasLimitMultiplier" - }, - rinkeby: { - host: "https://rinkeby.infura.io/berv5GTB5cSdOJPPnqOq", - port: 8545, - network_id: "4", - constructorArgs: [RINKEBY_ORACLE_ADDRESS], - }, - kovan: { - host: "https://kovan.infura.io/berv5GTB5cSdOJPPnqOq", - port: 8545, - network_id: "42", - constructorArgs: [KOVAN_ORACLE_ADDRESS], - }, - } -}; From 19b5781f34a156fb7a3d429f001b002964217a0e Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 00:38:48 +0100 Subject: [PATCH 18/37] add example fields --- iexec.js | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/iexec.js b/iexec.js index 57dee80..7d6b547 100644 --- a/iexec.js +++ b/iexec.js @@ -1,3 +1,11 @@ module.exports = { - name: 'MyContract', + name: 'MyContract', + data: { + type: 'BINARY', + cpu: 'AMD64', + os: 'LINUX', + }, + work: { + cmdline: '10', + } }; From bdaaf5e5e5ecb72dd0e6ce99e096aa38af8ec1b6 Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 11:12:48 +0100 Subject: [PATCH 19/37] improve description --- apps/README.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/apps/README.md b/apps/README.md index 3a425c0..bc23275 100644 --- a/apps/README.md +++ b/apps/README.md @@ -1,7 +1,7 @@ -Your iexec Dapp is composed of : +Your iExec Dapp is composed of two parts: -* under apps directory : -the offchain app, which can be any kind of legacy application. The offchain app will be executed by the iexec decentralized cloud. +* under the ```apps``` directory : +Put the offchain app (any kind of legacy application). The offchain app will be executed by the iExec decentralized cloud. -* under contracts directory : -a smart contract that interfaces your iExec Dapp from Ethereum to the offchain app. +* under the ```contracts``` directory : +A smart contract that interfaces with your iExec Dapp, it will serve as a gateway from Ethereum to your offchain app. From 527791dbdd8a306bb25fdf2ba2071557463b6dc7 Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 11:20:11 +0100 Subject: [PATCH 20/37] improve desc --- README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index cafe4bf..edb7f00 100644 --- a/README.md +++ b/README.md @@ -11,4 +11,6 @@ iexec init factorial # download and init factorial dapp iexec init echo # download and init echo dapp ``` -You are warmly welcome to push your dapp on a new branch in this repo. You may even request to be listed on the [iExec dapp store](https://iex.ec) +Start a Pull Request with your code onto a new branch of this repo to let other developers discover it by running ```iexec init yourDappName```. + +Finally, you should checkout the [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) as well as submit us a request to be listed on the [iExec dapp store](https://dapps.iex.ec/) From 58c6f39eb9b5f870554c505ef2f257a30cf55cde Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 14:23:02 +0100 Subject: [PATCH 21/37] improve readme --- README.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index edb7f00..70b615d 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,6 @@ Each branch of this repo is a sample iExec dapp, and can be easily played with by using the [iexec sdk cli](https://github.com/iExecBlockchainComputing/iexec-sdk) like this: ```iexec init branchName``` -# Example ```bash iexec init # current branch containing minimum working config @@ -14,3 +13,16 @@ iexec init echo # download and init echo dapp Start a Pull Request with your code onto a new branch of this repo to let other developers discover it by running ```iexec init yourDappName```. Finally, you should checkout the [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) as well as submit us a request to be listed on the [iExec dapp store](https://dapps.iex.ec/) + +--------------- +# My Dapp name +## Description +My Dapp description here... +## Howto +```bash +# ... +# ... +``` +## Checklist + * add license + * author name From 55a95af1f12cd582e9ab35828f9a4e8756ba9f12 Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 14:23:14 +0100 Subject: [PATCH 22/37] add License --- LICENSE | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..b372aef --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +The MIT License + +Copyright (c) 2017 iExec Blockchain Tech, https://iex.ec + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. From 63b924ef2b16b70a42f9db9b674399834aa88540 Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 14:48:29 +0100 Subject: [PATCH 23/37] remove deps --- package.json | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/package.json b/package.json index d4bfaa0..7f3d9c3 100644 --- a/package.json +++ b/package.json @@ -15,8 +15,5 @@ "bugs": { "url": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples/issues" }, - "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", - "dependencies": { - "iexec-oracle-contract": "github:iExecBlockchainComputing/iexec-oracle-contract#v1.1.1" - } + "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme" } From fadd08b5e466a9a83c63fb62ddc7e26b34e1841b Mon Sep 17 00:00:00 2001 From: victor Date: Tue, 19 Dec 2017 14:54:12 +0100 Subject: [PATCH 24/37] Improve readme --- README.md | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 70b615d..eff9ac8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,5 @@ # iExec dapp samples +## 1 branch = 1 dapp Each branch of this repo is a sample iExec dapp, and can be easily played with by using the [iexec sdk cli](https://github.com/iExecBlockchainComputing/iexec-sdk) like this: ```iexec init branchName``` @@ -10,15 +11,20 @@ iexec init factorial # download and init factorial dapp iexec init echo # download and init echo dapp ``` -Start a Pull Request with your code onto a new branch of this repo to let other developers discover it by running ```iexec init yourDappName```. +Start a [Pull Request](https://github.com/iExecBlockchainComputing/iexec-dapp-samples/pulls) to add you dapp to this repo. -Finally, you should checkout the [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) as well as submit us a request to be listed on the [iExec dapp store](https://dapps.iex.ec/) +## [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) ---------------- + * Go checkout the [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) + * Go submit a request to be listed on the [iExec dapp store](https://dapps.iex.ec/) + +--- # My Dapp name ## Description My Dapp description here... ## Howto +How it works... +## Example ```bash # ... # ... From 4b16baa7867e9ab4b4e11c451465bb9f376531ba Mon Sep 17 00:00:00 2001 From: francois branciard Date: Wed, 20 Dec 2017 17:18:11 +0100 Subject: [PATCH 25/37] update init dapp readme --- README.md | 14 +- build/contracts/MyContract.json | 436 ++++++++++++++++++++++++++++++++ 2 files changed, 440 insertions(+), 10 deletions(-) create mode 100644 build/contracts/MyContract.json diff --git a/README.md b/README.md index eff9ac8..e89b76d 100644 --- a/README.md +++ b/README.md @@ -22,13 +22,7 @@ Start a [Pull Request](https://github.com/iExecBlockchainComputing/iexec-dapp-sa # My Dapp name ## Description My Dapp description here... -## Howto -How it works... -## Example -```bash -# ... -# ... -``` -## Checklist - * add license - * author name +## Dapp params +An examples of a iexec.js conf +## [Examples](./examples) +A like to all iexec.js conf examples for the dapp. diff --git a/build/contracts/MyContract.json b/build/contracts/MyContract.json new file mode 100644 index 0000000..eda0a85 --- /dev/null +++ b/build/contracts/MyContract.json @@ -0,0 +1,436 @@ +{ + "contractName": "MyContract", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + }, + { + "name": "user", + "type": "address" + }, + { + "name": "stdout", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ], + "name": "iexecSubmitCallback", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "DAPP_PRICE", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "param", + "type": "string" + } + ], + "name": "iexecSubmit", + "outputs": [], + "payable": true, + "stateMutability": "payable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "DAPP_NAME", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "_iexecOracleAddress", + "type": "address" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "submitTxHash", + "type": "bytes32" + }, + { + "indexed": true, + "name": "user", + "type": "address" + }, + { + "indexed": false, + "name": "stdout", + "type": "string" + }, + { + "indexed": false, + "name": "uri", + "type": "string" + } + ], + "name": "IexecSubmitCallback", + "type": "event" + } + ], + "bytecode": "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", + "deployedBytecode": "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", + "sourceMap": "86:254:0:-;;;223:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;288:19;164:1;319:9;;;;;;;;;;;;;;;;;;426:23:3;397:19;378:18;;:38;;;;;;;;;;;;;;;;;;464:18;;;;;;;;;;;426:57;;501:11;:35;;;537:9;547:8;501:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;493:64:3;;;;;;;;272:292;;;;223:114:0;86:254;;;;;;", + "deployedSourceMap": "86:254:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;570:185:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;171:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;870:4;907:18;;;;;;;;;;;893:32;;:10;:32;;;885:41;;;;;;;;969:4;936:49;;;956:12;974:6;981:3;936:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1002:4:3;995:11;;761:252;;;;;;:::o;130:35:0:-;164:1;130:35;:::o;570:185:3:-;630:23;668:18;;;;;;;;;;;630:57;;705:11;:18;;;730:9;741:5;705:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;697:51:3;;;;;;;;570:185;;:::o;171:41:0:-;;;;;;;;;;;;;;;;;;;;:::o", + "source": "pragma solidity ^0.4.11;\nimport \"iexec-oracle-contract/contracts/IexecOracleAPI.sol\";\ncontract MyContract is IexecOracleAPI{\n\n uint public constant DAPP_PRICE = 0;\n string public constant DAPP_NAME = \"init\";\n \n function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){\n\n }\n\n}\n", + "sourcePath": "/home/vagrant/iexecdev/iexec-init/contracts/MyContract.sol", + "ast": { + "attributes": { + "absolutePath": "/home/vagrant/iexecdev/iexec-init/contracts/MyContract.sol", + "exportedSymbols": { + "MyContract": [ + 22 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".11" + ] + }, + "id": 1, + "name": "PragmaDirective", + "src": "0:24:0" + }, + { + "attributes": { + "SourceUnit": 795, + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "file": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "scope": 23, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 2, + "name": "ImportDirective", + "src": "25:60:0" + }, + { + "attributes": { + "contractDependencies": [ + 794 + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 22, + 794 + ], + "name": "MyContract", + "scope": 23 + }, + "children": [ + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracleAPI", + "referencedDeclaration": 794, + "type": "contract IexecOracleAPI" + }, + "id": 3, + "name": "UserDefinedTypeName", + "src": "109:14:0" + } + ], + "id": 4, + "name": "InheritanceSpecifier", + "src": "109:14:0" + }, + { + "attributes": { + "constant": true, + "name": "DAPP_PRICE", + "scope": 22, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 5, + "name": "ElementaryTypeName", + "src": "130:4:0" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 6, + "name": "Literal", + "src": "164:1:0" + } + ], + "id": 7, + "name": "VariableDeclaration", + "src": "130:35:0" + }, + { + "attributes": { + "constant": true, + "name": "DAPP_NAME", + "scope": 22, + "stateVariable": true, + "storageLocation": "default", + "type": "string memory", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 8, + "name": "ElementaryTypeName", + "src": "171:6:0" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "696e6974", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"init\"", + "value": "init" + }, + "id": 9, + "name": "Literal", + "src": "206:6:0" + } + ], + "id": 10, + "name": "VariableDeclaration", + "src": "171:41:0" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "name": "MyContract", + "payable": false, + "scope": 22, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_iexecOracleAddress", + "scope": 21, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 11, + "name": "ElementaryTypeName", + "src": "244:7:0" + } + ], + "id": 12, + "name": "VariableDeclaration", + "src": "244:27:0" + } + ], + "id": 13, + "name": "ParameterList", + "src": "243:29:0" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 19, + "name": "ParameterList", + "src": "329:0:0" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 794, + "type": "type(contract IexecOracleAPI)", + "value": "IexecOracleAPI" + }, + "id": 14, + "name": "Identifier", + "src": "273:14:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 12, + "type": "address", + "value": "_iexecOracleAddress" + }, + "id": 15, + "name": "Identifier", + "src": "288:19:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 7, + "type": "uint256", + "value": "DAPP_PRICE" + }, + "id": 16, + "name": "Identifier", + "src": "308:10:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 10, + "type": "string memory", + "value": "DAPP_NAME" + }, + "id": 17, + "name": "Identifier", + "src": "319:9:0" + } + ], + "id": 18, + "name": "ModifierInvocation", + "src": "273:56:0" + }, + { + "attributes": { + "statements": [ + null + ] + }, + "children": [], + "id": 20, + "name": "Block", + "src": "329:8:0" + } + ], + "id": 21, + "name": "FunctionDefinition", + "src": "223:114:0" + } + ], + "id": 22, + "name": "ContractDefinition", + "src": "86:254:0" + } + ], + "id": 23, + "name": "SourceUnit", + "src": "0:341:0" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2017-12-20T16:10:37.901Z" +} \ No newline at end of file From 2d2e8613f16ee07417cdac77d7bec6c4d4688cff Mon Sep 17 00:00:00 2001 From: francois branciard Date: Wed, 20 Dec 2017 17:19:49 +0100 Subject: [PATCH 26/37] update init dapp readme --- README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index e89b76d..0b0e6dc 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,6 @@ Start a [Pull Request](https://github.com/iExecBlockchainComputing/iexec-dapp-sa ## Description My Dapp description here... ## Dapp params -An examples of a iexec.js conf +An example of a iexec.js conf ## [Examples](./examples) -A like to all iexec.js conf examples for the dapp. +A link to all iexec.js conf examples for the dapp. From 11fc1141a5b6e4e3ba27f58fc4841a02ce0a4a14 Mon Sep 17 00:00:00 2001 From: francois branciard Date: Wed, 20 Dec 2017 17:20:27 +0100 Subject: [PATCH 27/37] update init dapp readme --- examples/iexec-cmdline-10.js | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 examples/iexec-cmdline-10.js diff --git a/examples/iexec-cmdline-10.js b/examples/iexec-cmdline-10.js new file mode 100644 index 0000000..7d6b547 --- /dev/null +++ b/examples/iexec-cmdline-10.js @@ -0,0 +1,11 @@ +module.exports = { + name: 'MyContract', + data: { + type: 'BINARY', + cpu: 'AMD64', + os: 'LINUX', + }, + work: { + cmdline: '10', + } +}; From 0a8fa65caa17dcc69c93a759a1a03874d5f7b9e5 Mon Sep 17 00:00:00 2001 From: victor Date: Thu, 25 Jan 2018 11:52:41 +0100 Subject: [PATCH 28/37] remove lock --- package-lock.json | 11 ----------- 1 file changed, 11 deletions(-) delete mode 100644 package-lock.json diff --git a/package-lock.json b/package-lock.json deleted file mode 100644 index daa1bed..0000000 --- a/package-lock.json +++ /dev/null @@ -1,11 +0,0 @@ -{ - "name": "iexec-dapp-init", - "version": "1.0.0", - "lockfileVersion": 1, - "requires": true, - "dependencies": { - "iexec-oracle-contract": { - "version": "github:iExecBlockchainComputing/iexec-oracle-contract#64d31fa289acdd1a1f4a4c1d9426b9f610134a94" - } - } -} From e7f14222c71426d33a077791afb754454cefdbe5 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 22:16:27 +0000 Subject: [PATCH 29/37] del: remove template files --- build/contracts/MyContract.json | 436 -------------------------------- contracts/MyContract.sol | 12 - 2 files changed, 448 deletions(-) delete mode 100644 build/contracts/MyContract.json delete mode 100644 contracts/MyContract.sol diff --git a/build/contracts/MyContract.json b/build/contracts/MyContract.json deleted file mode 100644 index eda0a85..0000000 --- a/build/contracts/MyContract.json +++ /dev/null @@ -1,436 +0,0 @@ -{ - "contractName": "MyContract", - "abi": [ - { - "constant": false, - "inputs": [ - { - "name": "submitTxHash", - "type": "bytes32" - }, - { - "name": "user", - "type": "address" - }, - { - "name": "stdout", - "type": "string" - }, - { - "name": "uri", - "type": "string" - } - ], - "name": "iexecSubmitCallback", - "outputs": [ - { - "name": "", - "type": "bool" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "DAPP_PRICE", - "outputs": [ - { - "name": "", - "type": "uint256" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "constant": false, - "inputs": [ - { - "name": "param", - "type": "string" - } - ], - "name": "iexecSubmit", - "outputs": [], - "payable": true, - "stateMutability": "payable", - "type": "function" - }, - { - "constant": true, - "inputs": [], - "name": "DAPP_NAME", - "outputs": [ - { - "name": "", - "type": "string" - } - ], - "payable": false, - "stateMutability": "view", - "type": "function" - }, - { - "inputs": [ - { - "name": "_iexecOracleAddress", - "type": "address" - } - ], - "payable": false, - "stateMutability": "nonpayable", - "type": "constructor" - }, - { - "anonymous": false, - "inputs": [ - { - "indexed": false, - "name": "submitTxHash", - "type": "bytes32" - }, - { - "indexed": true, - "name": "user", - "type": "address" - }, - { - "indexed": false, - "name": "stdout", - "type": "string" - }, - { - "indexed": false, - "name": "uri", - "type": "string" - } - ], - "name": "IexecSubmitCallback", - "type": "event" - } - ], - "bytecode": "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", - "deployedBytecode": "0x606060405260043610610062576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806310a9f201146100675780633c0aef301461014b5780638cd213b914610174578063c878f958146101c6575b600080fd5b341561007257600080fd5b61013160048080356000191690602001909190803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803590602001908201803590602001908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509190803590602001908201803590602001908080601f01602080910402602001604051908101604052809392919081815260200183838082843782019150505050505091905050610254565b604051808215151515815260200191505060405180910390f35b341561015657600080fd5b61015e6103ed565b6040518082815260200191505060405180910390f35b6101c4600480803590602001908201803590602001908080601f016020809104026020016040519081016040528093929190818152602001838380828437820191505050505050919050506103f2565b005b34156101d157600080fd5b6101d961051f565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156102195780820151818401526020810190506101fe565b50505050905090810190601f1680156102465780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156102b157600080fd5b8373ffffffffffffffffffffffffffffffffffffffff167f68d2eaa37ea3e53bbe55f11eb038084f280086b8f4c4552dbca1b5692efeb9138685856040518084600019166000191681526020018060200180602001838103835285818151815260200191508051906020019080838360005b8381101561033e578082015181840152602081019050610323565b50505050905090810190601f16801561036b5780820380516001836020036101000a031916815260200191505b50838103825284818151815260200191508051906020019080838360005b838110156103a4578082015181840152602081019050610389565b50505050905090810190601f1680156103d15780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a260019050949350505050565b600081565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508073ffffffffffffffffffffffffffffffffffffffff1663d99a8dc334846000604051602001526040518363ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018080602001828103825283818151815260200191508051906020019080838360005b838110156104aa57808201518184015260208101905061048f565b50505050905090810190601f1680156104d75780820380516001836020036101000a031916815260200191505b50925050506020604051808303818588803b15156104f457600080fd5b6125ee5a03f1151561050557600080fd5b5050505060405180519050151561051b57600080fd5b5050565b6040805190810160405280600481526020017f696e697400000000000000000000000000000000000000000000000000000000815250815600a165627a7a723058203ad58bfd842836fbab63e8da1c58eacc04f060ed5ec703ac1d057a1a060c776e0029", - "sourceMap": "86:254:0:-;;;223:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;288:19;164:1;319:9;;;;;;;;;;;;;;;;;;426:23:3;397:19;378:18;;:38;;;;;;;;;;;;;;;;;;464:18;;;;;;;;;;;426:57;;501:11;:35;;;537:9;547:8;501:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;493:64:3;;;;;;;;272:292;;;;223:114:0;86:254;;;;;;", - "deployedSourceMap": "86:254:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;570:185:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;171:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;870:4;907:18;;;;;;;;;;;893:32;;:10;:32;;;885:41;;;;;;;;969:4;936:49;;;956:12;974:6;981:3;936:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1002:4:3;995:11;;761:252;;;;;;:::o;130:35:0:-;164:1;130:35;:::o;570:185:3:-;630:23;668:18;;;;;;;;;;;630:57;;705:11;:18;;;730:9;741:5;705:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;697:51:3;;;;;;;;570:185;;:::o;171:41:0:-;;;;;;;;;;;;;;;;;;;;:::o", - "source": "pragma solidity ^0.4.11;\nimport \"iexec-oracle-contract/contracts/IexecOracleAPI.sol\";\ncontract MyContract is IexecOracleAPI{\n\n uint public constant DAPP_PRICE = 0;\n string public constant DAPP_NAME = \"init\";\n \n function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){\n\n }\n\n}\n", - "sourcePath": "/home/vagrant/iexecdev/iexec-init/contracts/MyContract.sol", - "ast": { - "attributes": { - "absolutePath": "/home/vagrant/iexecdev/iexec-init/contracts/MyContract.sol", - "exportedSymbols": { - "MyContract": [ - 22 - ] - } - }, - "children": [ - { - "attributes": { - "literals": [ - "solidity", - "^", - "0.4", - ".11" - ] - }, - "id": 1, - "name": "PragmaDirective", - "src": "0:24:0" - }, - { - "attributes": { - "SourceUnit": 795, - "absolutePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", - "file": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", - "scope": 23, - "symbolAliases": [ - null - ], - "unitAlias": "" - }, - "id": 2, - "name": "ImportDirective", - "src": "25:60:0" - }, - { - "attributes": { - "contractDependencies": [ - 794 - ], - "contractKind": "contract", - "documentation": null, - "fullyImplemented": true, - "linearizedBaseContracts": [ - 22, - 794 - ], - "name": "MyContract", - "scope": 23 - }, - "children": [ - { - "attributes": { - "arguments": [ - null - ] - }, - "children": [ - { - "attributes": { - "contractScope": null, - "name": "IexecOracleAPI", - "referencedDeclaration": 794, - "type": "contract IexecOracleAPI" - }, - "id": 3, - "name": "UserDefinedTypeName", - "src": "109:14:0" - } - ], - "id": 4, - "name": "InheritanceSpecifier", - "src": "109:14:0" - }, - { - "attributes": { - "constant": true, - "name": "DAPP_PRICE", - "scope": 22, - "stateVariable": true, - "storageLocation": "default", - "type": "uint256", - "visibility": "public" - }, - "children": [ - { - "attributes": { - "name": "uint", - "type": "uint256" - }, - "id": 5, - "name": "ElementaryTypeName", - "src": "130:4:0" - }, - { - "attributes": { - "argumentTypes": null, - "hexvalue": "30", - "isConstant": false, - "isLValue": false, - "isPure": true, - "lValueRequested": false, - "subdenomination": null, - "token": "number", - "type": "int_const 0", - "value": "0" - }, - "id": 6, - "name": "Literal", - "src": "164:1:0" - } - ], - "id": 7, - "name": "VariableDeclaration", - "src": "130:35:0" - }, - { - "attributes": { - "constant": true, - "name": "DAPP_NAME", - "scope": 22, - "stateVariable": true, - "storageLocation": "default", - "type": "string memory", - "visibility": "public" - }, - "children": [ - { - "attributes": { - "name": "string", - "type": "string storage pointer" - }, - "id": 8, - "name": "ElementaryTypeName", - "src": "171:6:0" - }, - { - "attributes": { - "argumentTypes": null, - "hexvalue": "696e6974", - "isConstant": false, - "isLValue": false, - "isPure": true, - "lValueRequested": false, - "subdenomination": null, - "token": "string", - "type": "literal_string \"init\"", - "value": "init" - }, - "id": 9, - "name": "Literal", - "src": "206:6:0" - } - ], - "id": 10, - "name": "VariableDeclaration", - "src": "171:41:0" - }, - { - "attributes": { - "constant": false, - "implemented": true, - "isConstructor": true, - "name": "MyContract", - "payable": false, - "scope": 22, - "stateMutability": "nonpayable", - "superFunction": null, - "visibility": "public" - }, - "children": [ - { - "children": [ - { - "attributes": { - "constant": false, - "name": "_iexecOracleAddress", - "scope": 21, - "stateVariable": false, - "storageLocation": "default", - "type": "address", - "value": null, - "visibility": "internal" - }, - "children": [ - { - "attributes": { - "name": "address", - "type": "address" - }, - "id": 11, - "name": "ElementaryTypeName", - "src": "244:7:0" - } - ], - "id": 12, - "name": "VariableDeclaration", - "src": "244:27:0" - } - ], - "id": 13, - "name": "ParameterList", - "src": "243:29:0" - }, - { - "attributes": { - "parameters": [ - null - ] - }, - "children": [], - "id": 19, - "name": "ParameterList", - "src": "329:0:0" - }, - { - "children": [ - { - "attributes": { - "argumentTypes": null, - "overloadedDeclarations": [ - null - ], - "referencedDeclaration": 794, - "type": "type(contract IexecOracleAPI)", - "value": "IexecOracleAPI" - }, - "id": 14, - "name": "Identifier", - "src": "273:14:0" - }, - { - "attributes": { - "argumentTypes": null, - "overloadedDeclarations": [ - null - ], - "referencedDeclaration": 12, - "type": "address", - "value": "_iexecOracleAddress" - }, - "id": 15, - "name": "Identifier", - "src": "288:19:0" - }, - { - "attributes": { - "argumentTypes": null, - "overloadedDeclarations": [ - null - ], - "referencedDeclaration": 7, - "type": "uint256", - "value": "DAPP_PRICE" - }, - "id": 16, - "name": "Identifier", - "src": "308:10:0" - }, - { - "attributes": { - "argumentTypes": null, - "overloadedDeclarations": [ - null - ], - "referencedDeclaration": 10, - "type": "string memory", - "value": "DAPP_NAME" - }, - "id": 17, - "name": "Identifier", - "src": "319:9:0" - } - ], - "id": 18, - "name": "ModifierInvocation", - "src": "273:56:0" - }, - { - "attributes": { - "statements": [ - null - ] - }, - "children": [], - "id": 20, - "name": "Block", - "src": "329:8:0" - } - ], - "id": 21, - "name": "FunctionDefinition", - "src": "223:114:0" - } - ], - "id": 22, - "name": "ContractDefinition", - "src": "86:254:0" - } - ], - "id": 23, - "name": "SourceUnit", - "src": "0:341:0" - }, - "compiler": { - "name": "solc", - "version": "0.4.18+commit.9cf6e910.Emscripten.clang" - }, - "networks": {}, - "schemaVersion": "1.0.1", - "updatedAt": "2017-12-20T16:10:37.901Z" -} \ No newline at end of file diff --git a/contracts/MyContract.sol b/contracts/MyContract.sol deleted file mode 100644 index ab269b8..0000000 --- a/contracts/MyContract.sol +++ /dev/null @@ -1,12 +0,0 @@ -pragma solidity ^0.4.11; -import "iexec-oracle-contract/contracts/IexecOracleAPI.sol"; -contract MyContract is IexecOracleAPI{ - - uint public constant DAPP_PRICE = 0; - string public constant DAPP_NAME = "init"; - - function MyContract (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){ - - } - -} From f6f78155037ab5ae2f99d0062fdd229c41538a78 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 22:17:00 +0000 Subject: [PATCH 30/37] enh: update package.json to import prebuilt contracts --- package.json | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index 7f3d9c3..3b45b48 100644 --- a/package.json +++ b/package.json @@ -15,5 +15,8 @@ "bugs": { "url": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples/issues" }, - "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme" + "homepage": "https://github.com/iExecBlockchainComputing/iexec-dapp-samples#readme", + "dependencies": { + "iexec-oracle-contract": "^1.1.3" + } } From 617b357022362e8441cd148f68a170fc949c0207 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 22:19:10 +0000 Subject: [PATCH 31/37] enh: stop tracking wallet, lock and account --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index fd4eb98..3cfcccc 100644 --- a/.gitignore +++ b/.gitignore @@ -26,3 +26,7 @@ node_modules # Optional REPL history .node_repl_history + +package-lock.json +wallet.json +account.json From ff200773505e714f6e74294fb982e98697496596 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 22:34:53 +0000 Subject: [PATCH 32/37] add: files from iexec init --- build/contracts/ERC20.json | 1036 +++ build/contracts/IexecLib.json | 127 + build/contracts/IexecOracle.json | 9719 ++++++++++++++++++++++++ build/contracts/IexecOracleAPI.json | 1522 ++++ build/contracts/IexecOracleEscrow.json | 2125 ++++++ build/contracts/OpenMOLEPi.json | 440 ++ build/contracts/Ownable.json | 602 ++ build/contracts/RLC.json | 4899 ++++++++++++ build/contracts/SafeMath.json | 2694 +++++++ build/contracts/TokenSpender.json | 239 + truffle.js | 53 + 11 files changed, 23456 insertions(+) create mode 100644 build/contracts/ERC20.json create mode 100644 build/contracts/IexecLib.json create mode 100644 build/contracts/IexecOracle.json create mode 100644 build/contracts/IexecOracleAPI.json create mode 100644 build/contracts/IexecOracleEscrow.json create mode 100644 build/contracts/OpenMOLEPi.json create mode 100644 build/contracts/Ownable.json create mode 100644 build/contracts/RLC.json create mode 100644 build/contracts/SafeMath.json create mode 100644 build/contracts/TokenSpender.json create mode 100644 truffle.js diff --git a/build/contracts/ERC20.json b/build/contracts/ERC20.json new file mode 100644 index 0000000..a0148f4 --- /dev/null +++ b/build/contracts/ERC20.json @@ -0,0 +1,1036 @@ +{ + "contractName": "ERC20", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "spender", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [ + { + "name": "ok", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "from", + "type": "address" + }, + { + "name": "to", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [ + { + "name": "ok", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "who", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "to", + "type": "address" + }, + { + "name": "value", + "type": "uint256" + } + ], + "name": "transfer", + "outputs": [ + { + "name": "ok", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "owner", + "type": "address" + }, + { + "name": "spender", + "type": "address" + } + ], + "name": "allowance", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "from", + "type": "address" + }, + { + "indexed": true, + "name": "to", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "name": "spender", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + } + ], + "bytecode": "0x", + "deployedBytecode": "0x", + "sourceMap": "", + "deployedSourceMap": "", + "source": "pragma solidity ^0.4.8;\n\ncontract ERC20 {\n uint public totalSupply;\n function balanceOf(address who) constant returns (uint);\n function allowance(address owner, address spender) constant returns (uint);\n\n function transfer(address to, uint value) returns (bool ok);\n function transferFrom(address from, address to, uint value) returns (bool ok);\n function approve(address spender, uint value) returns (bool ok);\n event Transfer(address indexed from, address indexed to, uint value);\n event Approval(address indexed owner, address indexed spender, uint value);\n}\n", + "sourcePath": "rlc-token/contracts/ERC20.sol", + "ast": { + "attributes": { + "absolutePath": "rlc-token/contracts/ERC20.sol", + "exportedSymbols": { + "ERC20": [ + 1004 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".8" + ] + }, + "id": 940, + "name": "PragmaDirective", + "src": "0:23:5" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": false, + "linearizedBaseContracts": [ + 1004 + ], + "name": "ERC20", + "scope": 1005 + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "totalSupply", + "scope": 1004, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 941, + "name": "ElementaryTypeName", + "src": "44:4:5" + } + ], + "id": 942, + "name": "VariableDeclaration", + "src": "44:23:5" + }, + { + "attributes": { + "body": null, + "constant": true, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "balanceOf", + "payable": false, + "scope": 1004, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "who", + "scope": 949, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 943, + "name": "ElementaryTypeName", + "src": "90:7:5" + } + ], + "id": 944, + "name": "VariableDeclaration", + "src": "90:11:5" + } + ], + "id": 945, + "name": "ParameterList", + "src": "89:13:5" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 949, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 946, + "name": "ElementaryTypeName", + "src": "121:4:5" + } + ], + "id": 947, + "name": "VariableDeclaration", + "src": "121:4:5" + } + ], + "id": 948, + "name": "ParameterList", + "src": "120:6:5" + } + ], + "id": 949, + "name": "FunctionDefinition", + "src": "71:56:5" + }, + { + "attributes": { + "body": null, + "constant": true, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "allowance", + "payable": false, + "scope": 1004, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "owner", + "scope": 958, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 950, + "name": "ElementaryTypeName", + "src": "149:7:5" + } + ], + "id": 951, + "name": "VariableDeclaration", + "src": "149:13:5" + }, + { + "attributes": { + "constant": false, + "name": "spender", + "scope": 958, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 952, + "name": "ElementaryTypeName", + "src": "164:7:5" + } + ], + "id": 953, + "name": "VariableDeclaration", + "src": "164:15:5" + } + ], + "id": 954, + "name": "ParameterList", + "src": "148:32:5" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 958, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 955, + "name": "ElementaryTypeName", + "src": "199:4:5" + } + ], + "id": 956, + "name": "VariableDeclaration", + "src": "199:4:5" + } + ], + "id": 957, + "name": "ParameterList", + "src": "198:6:5" + } + ], + "id": 958, + "name": "FunctionDefinition", + "src": "130:75:5" + }, + { + "attributes": { + "body": null, + "constant": false, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "transfer", + "payable": false, + "scope": 1004, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "to", + "scope": 967, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 959, + "name": "ElementaryTypeName", + "src": "227:7:5" + } + ], + "id": 960, + "name": "VariableDeclaration", + "src": "227:10:5" + }, + { + "attributes": { + "constant": false, + "name": "value", + "scope": 967, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 961, + "name": "ElementaryTypeName", + "src": "239:4:5" + } + ], + "id": 962, + "name": "VariableDeclaration", + "src": "239:10:5" + } + ], + "id": 963, + "name": "ParameterList", + "src": "226:24:5" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "ok", + "scope": 967, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 964, + "name": "ElementaryTypeName", + "src": "260:4:5" + } + ], + "id": 965, + "name": "VariableDeclaration", + "src": "260:7:5" + } + ], + "id": 966, + "name": "ParameterList", + "src": "259:9:5" + } + ], + "id": 967, + "name": "FunctionDefinition", + "src": "209:60:5" + }, + { + "attributes": { + "body": null, + "constant": false, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "transferFrom", + "payable": false, + "scope": 1004, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "from", + "scope": 978, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 968, + "name": "ElementaryTypeName", + "src": "294:7:5" + } + ], + "id": 969, + "name": "VariableDeclaration", + "src": "294:12:5" + }, + { + "attributes": { + "constant": false, + "name": "to", + "scope": 978, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 970, + "name": "ElementaryTypeName", + "src": "308:7:5" + } + ], + "id": 971, + "name": "VariableDeclaration", + "src": "308:10:5" + }, + { + "attributes": { + "constant": false, + "name": "value", + "scope": 978, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 972, + "name": "ElementaryTypeName", + "src": "320:4:5" + } + ], + "id": 973, + "name": "VariableDeclaration", + "src": "320:10:5" + } + ], + "id": 974, + "name": "ParameterList", + "src": "293:38:5" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "ok", + "scope": 978, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 975, + "name": "ElementaryTypeName", + "src": "341:4:5" + } + ], + "id": 976, + "name": "VariableDeclaration", + "src": "341:7:5" + } + ], + "id": 977, + "name": "ParameterList", + "src": "340:9:5" + } + ], + "id": 978, + "name": "FunctionDefinition", + "src": "272:78:5" + }, + { + "attributes": { + "body": null, + "constant": false, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "approve", + "payable": false, + "scope": 1004, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "spender", + "scope": 987, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 979, + "name": "ElementaryTypeName", + "src": "370:7:5" + } + ], + "id": 980, + "name": "VariableDeclaration", + "src": "370:15:5" + }, + { + "attributes": { + "constant": false, + "name": "value", + "scope": 987, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 981, + "name": "ElementaryTypeName", + "src": "387:4:5" + } + ], + "id": 982, + "name": "VariableDeclaration", + "src": "387:10:5" + } + ], + "id": 983, + "name": "ParameterList", + "src": "369:29:5" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "ok", + "scope": 987, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 984, + "name": "ElementaryTypeName", + "src": "408:4:5" + } + ], + "id": 985, + "name": "VariableDeclaration", + "src": "408:7:5" + } + ], + "id": 986, + "name": "ParameterList", + "src": "407:9:5" + } + ], + "id": 987, + "name": "FunctionDefinition", + "src": "353:64:5" + }, + { + "attributes": { + "anonymous": false, + "name": "Transfer" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": true, + "name": "from", + "scope": 995, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 988, + "name": "ElementaryTypeName", + "src": "435:7:5" + } + ], + "id": 989, + "name": "VariableDeclaration", + "src": "435:20:5" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "to", + "scope": 995, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 990, + "name": "ElementaryTypeName", + "src": "457:7:5" + } + ], + "id": 991, + "name": "VariableDeclaration", + "src": "457:18:5" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "value", + "scope": 995, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 992, + "name": "ElementaryTypeName", + "src": "477:4:5" + } + ], + "id": 993, + "name": "VariableDeclaration", + "src": "477:10:5" + } + ], + "id": 994, + "name": "ParameterList", + "src": "434:54:5" + } + ], + "id": 995, + "name": "EventDefinition", + "src": "420:69:5" + }, + { + "attributes": { + "anonymous": false, + "name": "Approval" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": true, + "name": "owner", + "scope": 1003, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 996, + "name": "ElementaryTypeName", + "src": "507:7:5" + } + ], + "id": 997, + "name": "VariableDeclaration", + "src": "507:21:5" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "spender", + "scope": 1003, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 998, + "name": "ElementaryTypeName", + "src": "530:7:5" + } + ], + "id": 999, + "name": "VariableDeclaration", + "src": "530:23:5" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "value", + "scope": 1003, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1000, + "name": "ElementaryTypeName", + "src": "555:4:5" + } + ], + "id": 1001, + "name": "VariableDeclaration", + "src": "555:10:5" + } + ], + "id": 1002, + "name": "ParameterList", + "src": "506:60:5" + } + ], + "id": 1003, + "name": "EventDefinition", + "src": "492:75:5" + } + ], + "id": 1004, + "name": "ContractDefinition", + "src": "25:544:5" + } + ], + "id": 1005, + "name": "SourceUnit", + "src": "0:570:5" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.802Z" +} \ No newline at end of file diff --git a/build/contracts/IexecLib.json b/build/contracts/IexecLib.json new file mode 100644 index 0000000..3571525 --- /dev/null +++ b/build/contracts/IexecLib.json @@ -0,0 +1,127 @@ +{ + "contractName": "IexecLib", + "abi": [], + "bytecode": "0x60606040523415600e57600080fd5b603580601b6000396000f3006060604052600080fd00a165627a7a723058203d915f9a840ab23e889ffc5680df47849f31afeb3759254af85def4473b667830029", + "deployedBytecode": "0x6060604052600080fd00a165627a7a723058203d915f9a840ab23e889ffc5680df47849f31afeb3759254af85def4473b667830029", + "sourceMap": "34:99:1:-;;;;;;;;;;;;;;;;;", + "deployedSourceMap": "34:99:1:-;;;;;", + "source": "pragma solidity ^0.4.18;\n//v1.1.1\nlibrary IexecLib{\n\n enum StatusEnum { UNSET, UNAVAILABLE, PENDING, RUNNING, COMPLETED, ERROR}\n\n}", + "sourcePath": "iexec-oracle-contract/contracts/IexecLib.sol", + "ast": { + "attributes": { + "absolutePath": "iexec-oracle-contract/contracts/IexecLib.sol", + "exportedSymbols": { + "IexecLib": [ + 32 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".18" + ] + }, + "id": 24, + "name": "PragmaDirective", + "src": "0:24:1" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "library", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 32 + ], + "name": "IexecLib", + "scope": 33 + }, + "children": [ + { + "attributes": { + "canonicalName": "IexecLib.StatusEnum", + "name": "StatusEnum" + }, + "children": [ + { + "attributes": { + "name": "UNSET" + }, + "id": 25, + "name": "EnumValue", + "src": "75:5:1" + }, + { + "attributes": { + "name": "UNAVAILABLE" + }, + "id": 26, + "name": "EnumValue", + "src": "82:11:1" + }, + { + "attributes": { + "name": "PENDING" + }, + "id": 27, + "name": "EnumValue", + "src": "95:7:1" + }, + { + "attributes": { + "name": "RUNNING" + }, + "id": 28, + "name": "EnumValue", + "src": "104:7:1" + }, + { + "attributes": { + "name": "COMPLETED" + }, + "id": 29, + "name": "EnumValue", + "src": "113:9:1" + }, + { + "attributes": { + "name": "ERROR" + }, + "id": 30, + "name": "EnumValue", + "src": "124:5:1" + } + ], + "id": 31, + "name": "EnumDefinition", + "src": "57:73:1" + } + ], + "id": 32, + "name": "ContractDefinition", + "src": "34:99:1" + } + ], + "id": 33, + "name": "SourceUnit", + "src": "0:133:1" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.800Z" +} \ No newline at end of file diff --git a/build/contracts/IexecOracle.json b/build/contracts/IexecOracle.json new file mode 100644 index 0000000..13b6d66 --- /dev/null +++ b/build/contracts/IexecOracle.json @@ -0,0 +1,9719 @@ +{ + "contractName": "IexecOracle", + "abi": [ + { + "constant": false, + "inputs": [], + "name": "toggleContractActive", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "dapp", + "type": "address" + } + ], + "name": "getDappPrice", + "outputs": [ + { + "name": "dappPrice", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + }, + { + "name": "user", + "type": "address" + }, + { + "name": "dapp", + "type": "address" + }, + { + "name": "status", + "type": "uint8" + }, + { + "name": "stdout", + "type": "string" + }, + { + "name": "stderr", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ], + "name": "submitCallback", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWork", + "outputs": [ + { + "name": "timestamp", + "type": "uint256" + }, + { + "name": "status", + "type": "uint8" + }, + { + "name": "stdout", + "type": "string" + }, + { + "name": "stderr", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "callbackPrice", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "dapp", + "type": "address" + } + ], + "name": "getDapp", + "outputs": [ + { + "name": "dappName", + "type": "string" + }, + { + "name": "dappPrice", + "type": "uint256" + }, + { + "name": "provider", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWorkUri", + "outputs": [ + { + "name": "uri", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "dapp", + "type": "address" + } + ], + "name": "getDappName", + "outputs": [ + { + "name": "dappName", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "dapp", + "type": "address" + } + ], + "name": "getProvider", + "outputs": [ + { + "name": "provider", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "dappPrice", + "type": "uint256" + }, + { + "name": "dappName", + "type": "string" + } + ], + "name": "registerDappAndProvider", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "stopped", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "owner", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "iexecOracleEscrow", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWorkStderr", + "outputs": [ + { + "name": "stderr", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_callbackPrice", + "type": "uint256" + } + ], + "name": "changeCallbackPrice", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWorkStatus", + "outputs": [ + { + "name": "status", + "type": "uint8" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWorkStdout", + "outputs": [ + { + "name": "stdout", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "param", + "type": "string" + } + ], + "name": "submit", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": true, + "stateMutability": "payable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "rlcTokenAddress", + "type": "address" + }, + { + "name": "amount", + "type": "uint256" + } + ], + "name": "emergencyERC20Drain", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + } + ], + "name": "getWorkTimestamp", + "outputs": [ + { + "name": "timestamp", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "_iexecOracleEscrow", + "type": "address" + }, + { + "name": "_callbackPrice", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "user", + "type": "address" + }, + { + "indexed": true, + "name": "dapp", + "type": "address" + }, + { + "indexed": true, + "name": "provider", + "type": "address" + }, + { + "indexed": false, + "name": "args", + "type": "string" + } + ], + "name": "Submit", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "submitTxHash", + "type": "bytes32" + }, + { + "indexed": true, + "name": "user", + "type": "address" + }, + { + "indexed": false, + "name": "stdout", + "type": "string" + }, + { + "indexed": false, + "name": "uri", + "type": "string" + } + ], + "name": "SubmitCallback", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "dapp", + "type": "address" + }, + { + "indexed": true, + "name": "provider", + "type": "address" + }, + { + "indexed": false, + "name": "dappPrice", + "type": "uint256" + }, + { + "indexed": false, + "name": "dappName", + "type": "string" + } + ], + "name": "Register", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "code", + "type": "uint256" + }, + { + "indexed": false, + "name": "message", + "type": "string" + } + ], + "name": "Error", + "type": "event" + } + ], + "bytecode": "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", + "deployedBytecode": "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", + "sourceMap": "206:6616:2:-;;;268:5;246:27;;;;;;;;;;;;;;;;;;;;1804:189;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;104:10:6;96:5;;:18;;;;;;;;;;;;;;;;;;1929::2;1893:17;;:55;;;;;;;;;;;;;;;;;;1972:14;1958:13;:28;;;;1804:189;;206:6616;;;;;;", + "deployedSourceMap": "206:6616:2:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2023:88;;;;;;;;;;;;;;2972:132;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4890:1240;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3244:402;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;749:28:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2575:256;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4267:133:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3110:128:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2837:129:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2117:452;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;246:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46:20:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;700:42:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4119:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6136:142:2;;;;;;;;;;;;;;;;;;;;;;;;;;3810:155;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3971:142;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4406:478:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6641:178;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;191:110:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;3652:152:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2023:88;168:5:6;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;2097:7:2;;;;;;;;;;;2096:8;2086:7;;:18;;;;;;;;;;;;;;;;;;150:32:6;2023:88:2:o;2972:132::-;3033:17;3069:12;:18;3082:4;3069:18;;;;;;;;;;;;;;;:28;;;3062:35;;2972:132;;;:::o;4890:1240::-;5736:17;1253:7;;;;;;;;;;;1252:8;1244:17;;;;;;;;5088:5;;;;;;;;;;;5074:19;;:10;:19;;;5067:27;;;;;;5163:25;5153:35;;;;;;;;:6;:35;;;;;;;;;;5145:44;;;;;;;;5330:25;5293:62;;;;;;;;:12;:26;5306:12;5293:26;;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;:62;;;;;;;;;5285:71;;;;;;;;5403:3;5366:12;:26;5379:12;5366:26;;;;;;;;;;;;;;;;;:36;;:40;;;;5452:6;5416:12;:26;5429:12;5416:26;;;;;;;;;;;;;;;;;:33;;;:42;;;;;;;;;;;;;;;;;;;;;;;;5504:6;5468:12;:26;5481:12;5468:26;;;;;;;;;;;;;;;;;:33;;:42;;;;;;;;;;;;:::i;:::-;;5556:6;5520:12;:26;5533:12;5520:26;;;;;;;;;;;;;;;;;:33;;:42;;;;;;;;;;;;:::i;:::-;;5605:3;5572:12;:26;5585:12;5572:26;;;;;;;;;;;;;;;;;:30;;:36;;;;;;;;;;;;:::i;:::-;;5646:4;5618:44;;;5633:12;5651:6;5658:3;5618:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5672:54:2;5692:12;5705:4;5710;5715:6;5722:3;5672:19;:54::i;:::-;5754:12;:18;5767:4;5754:18;;;;;;;;;;;;;;;:28;;;5736:46;;5807:1;5795:9;:13;5792:332;;;5837:29;5827:39;;;;;;;;:6;:39;;;;;;;;;5824:152;;;5893:17;;;;;;;;;;;:28;;;5922:12;:18;5935:4;5922:18;;;;;;;;;;;;;;;:27;;;;;;;;;;;;5950:9;5893:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5885:76;;;;;;;;5824:152;6002:25;5992:35;;;;;;;;:6;:35;;;;;;;;;5989:125;;;6054:17;;;;;;;;;;;:28;;;6083:4;6088:9;6054:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6046:53;;;;;;;;5989:125;5792:332;4890:1240;;;;;;;;:::o;3244:402::-;3308:17;3327:26;3355:13;;:::i;:::-;3370;;:::i;:::-;3385:10;;:::i;:::-;3424:12;:26;3437:12;3424:26;;;;;;;;;;;;;;;;;:36;;;3470:12;:26;3483:12;3470:26;;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;3513:12;:26;3526:12;3513:26;;;;;;;;;;;;;;;;;:33;;3556:12;:26;3569:12;3556:26;;;;;;;;;;;;;;;;;:33;;3599:12;:26;3612:12;3599:26;;;;;;;;;;;;;;;;;:30;;3407:232;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3244:402;;;;;;;:::o;749:28::-;;;;:::o;2575:256::-;2631:15;;:::i;:::-;2648:17;2667:16;2712:12;:18;2725:4;2712:18;;;;;;;;;;;;;;;:27;;2749:12;:18;2762:4;2749:18;;;;;;;;;;;;;;;:28;;;2787:12;:18;2800:4;2787:18;;;;;;;;;;;;;;;:27;;;;;;;;;;;;2695:129;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2575:256;;;;;:::o;4267:133::-;4334:10;;:::i;:::-;4363:12;:26;4376:12;4363:26;;;;;;;;;;;;;;;;;:30;;4356:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4267:133;;;:::o;3110:128::-;3170:15;;:::i;:::-;3204:12;:18;3217:4;3204:18;;;;;;;;;;;;;;;:27;;3197:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3110:128;;;:::o;2837:129::-;2897:16;2932:12;:18;2945:4;2932:18;;;;;;;;;;;;;;;:27;;;;;;;;;;;;2925:34;;2837:129;;;:::o;2117:452::-;2218:4;1253:7;;;;;;;;;;;1252:8;1244:17;;;;;;;;2278:3;2241:12;:24;2254:10;2241:24;;;;;;;;;;;;;;;:33;;;;;;;;;;;;:40;;;2234:48;;;;;;2313:9;2299:23;;:10;:23;;;;2292:31;;;;;;2367:9;2333:12;:24;2346:10;2333:24;;;;;;;;;;;;;;;:33;;;:43;;;;;;;;;;;;;;;;;;2421:9;2386:12;:24;2399:10;2386:24;;;;;;;;;;;;;;;:34;;:44;;;;2474:8;2440:12;:24;2453:10;2440:24;;;;;;;;;;;;;;;:33;;:42;;;;;;;;;;;;:::i;:::-;;2512:9;2492:49;;2501:10;2492:49;;;2522:9;2532:8;2492:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2558:4:2;2551:11;;2117:452;;;;:::o;246:27::-;;;;;;;;;;;;;:::o;46:20:6:-;;;;;;;;;;;;;:::o;700:42:2:-;;;;;;;;;;;;;:::o;4119:142::-;4189:13;;:::i;:::-;4221:12;:26;4234:12;4221:26;;;;;;;;;;;;;;;;;:33;;4214:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4119:142;;;:::o;6136:::-;6227:5;;;;;;;;;;;6213:19;;:10;:19;;;6206:27;;;;;;6257:14;6243:13;:28;;;;6136:142;:::o;3810:155::-;3880:26;3925:12;:26;3938:12;3925:26;;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;3918:40;;3810:155;;;:::o;3971:142::-;4041:13;;:::i;:::-;4073:12;:26;4086:12;4073:26;;;;;;;;;;;;;;;;;:33;;4066:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3971:142;;;:::o;4406:478::-;4511:4;4526:17;1362:3;1325:12;:24;1338:10;1325:24;;;;;;;;;;;;;;;:33;;;;;;;;;;;;:40;;;;1318:48;;;;;;1444:13;;1432:9;:25;1429:167;;;1470:95;1476:1;1470:95;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1577:8;;;1429:167;1621:7;1608:9;:20;;1605:158;;;1641:91;1647:1;1641:91;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1744:8;;;1605:158;1253:7;;;;;;;;;;;1252:8;1244:17;;;;;;;;4544:12;:24;4557:10;4544:24;;;;;;;;;;;;;;;:34;;;4526:52;;4603:1;4591:9;:13;4588:154;;;4691:17;;;;;;;;;;;:28;;;4720:9;4691:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4683:48;;;;;;;;4588:154;4751:5;;;;;;;;;;;:14;;:25;4766:9;4751:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4815:12;:24;4828:10;4815:24;;;;;;;;;;;;;;;:33;;;;;;;;;;;;4786:70;;4804:10;4786:70;;4793:9;4786:70;;;4850:5;4786:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4873:4:2;4866:11;;4406:478;;;;:::o;6641:178::-;6735:12;168:5:6;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;6754:15:2;6735:35;;6780:8;:17;;;6798:5;;;;;;;;;;;6805:6;6780:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;150::6;6641:178:2;;;:::o;191:110:6:-;168:5;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;276:1;256:22;;:8;:22;;;;252:44;;;288:8;280:5;;:16;;;;;;;;;;;;;;;;;;252:44;150:32;191:110;:::o;3652:152:2:-;3725:17;3761:12;:26;3774:12;3761:26;;;;;;;;;;;;;;;;;:36;;;3754:43;;3652:152;;;:::o;6284:267::-;6409:29;6456:4;6409:52;;6479:14;:34;;;6514:12;6527:4;6532:6;6539:3;6479:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6471:73:2;;;;;;;;6284:267;;;;;;:::o;206:6616::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o", + "source": "pragma solidity ^0.4.18;\n//v1.1.1\nimport './IexecOracleAPI.sol';\nimport './IexecOracleEscrow.sol';\nimport './IexecLib.sol';\nimport \"rlc-token/contracts/Ownable.sol\";\nimport \"rlc-token/contracts/RLC.sol\";\n\n\ncontract IexecOracle is Ownable {\n\n\n bool public stopped = false;\n /*\n * EVENTS AND MODIFIERS\n */\n event Submit(address indexed user, address indexed dapp, address indexed provider, string args); // special log to launch process\n event SubmitCallback(bytes32 submitTxHash, address indexed user, string stdout, string uri);\n event Register(address indexed dapp, address indexed provider,uint256 dappPrice, string dappName);\n event Error(uint code,string message);\n\n IexecOracleEscrow public iexecOracleEscrow;\n\n uint256 public callbackPrice;\n\n struct Work {\n uint256 timestamp;\n IexecLib.StatusEnum status;\n string stdout;\n string stderr;\n string uri;\n }\n //mapping (submitTxHash => Work) workRegistry;\n mapping (bytes32 => Work) workRegistry;\n\n struct Dapp {\n string dappName;\n uint256 dappPrice;\n address provider;\n }\n\n //mapping (dapp address => Dapp Struct)\n mapping (address => Dapp ) dappRegistry ;\n\n modifier stopInEmergency {\n require(!stopped);\n _;\n }\n\n modifier onlyRegistered(){\n assert(dappRegistry[msg.sender].provider != 0x0);\n _;\n }\n\n modifier checkCallbackPrice(){\n if(msg.value < callbackPrice){\n Error(1,\"msg.value needed for submit callback gas is too low. Check the current callbackPrice\");\n revert();\n }\n if(msg.value >= 1 ether){\n Error(2,\"msg.value needed for submit callback gas is too high. Must be lower than 1 ether\");\n revert();\n }\n _;\n }\n\n //constructor\n function IexecOracle(address _iexecOracleEscrow,uint256 _callbackPrice) public {\n iexecOracleEscrow=IexecOracleEscrow(_iexecOracleEscrow);\n callbackPrice=_callbackPrice;\n }\n\n // Circuit Breakers\n function toggleContractActive() onlyOwner public\n {\n stopped = !stopped;\n }\n\n function registerDappAndProvider(uint256 dappPrice,string dappName) stopInEmergency public returns (bool) {\n assert(dappRegistry[msg.sender].provider == 0x0);\n assert(msg.sender != tx.origin);\n dappRegistry[msg.sender].provider=tx.origin;\n dappRegistry[msg.sender].dappPrice=dappPrice;\n dappRegistry[msg.sender].dappName=dappName;\n Register(msg.sender,tx.origin,dappPrice,dappName);\n return true;\n }\n\n function getDapp(address dapp) constant public returns (string dappName, uint256 dappPrice, address provider) {\n return (\n dappRegistry[dapp].dappName,\n dappRegistry[dapp].dappPrice,\n dappRegistry[dapp].provider\n );\n }\n\n function getProvider(address dapp) constant public returns (address provider) {\n return dappRegistry[dapp].provider;\n }\n\n function getDappPrice(address dapp) constant public returns (uint256 dappPrice) {\n return dappRegistry[dapp].dappPrice;\n }\n\n function getDappName(address dapp) constant public returns (string dappName) {\n return dappRegistry[dapp].dappName;\n }\n\n function getWork(bytes32 submitTxHash) constant public returns (uint256 timestamp, IexecLib.StatusEnum status, string stdout, string stderr, string uri) {\n return (\n workRegistry[submitTxHash].timestamp,\n workRegistry[submitTxHash].status,\n workRegistry[submitTxHash].stdout,\n workRegistry[submitTxHash].stderr,\n workRegistry[submitTxHash].uri\n );\n }\n\n function getWorkTimestamp(bytes32 submitTxHash) constant public returns (uint256 timestamp) {\n return workRegistry[submitTxHash].timestamp;\n }\n\n function getWorkStatus(bytes32 submitTxHash) constant public returns (IexecLib.StatusEnum status) {\n return workRegistry[submitTxHash].status;\n }\n\n function getWorkStdout(bytes32 submitTxHash) constant public returns (string stdout) {\n return workRegistry[submitTxHash].stdout;\n }\n\n function getWorkStderr(bytes32 submitTxHash) constant public returns (string stderr) {\n return workRegistry[submitTxHash].stderr;\n }\n\n function getWorkUri(bytes32 submitTxHash) constant public returns (string uri) {\n return workRegistry[submitTxHash].uri;\n }\n\n function submit(string param) onlyRegistered checkCallbackPrice stopInEmergency public payable returns (bool){\n uint256 dappPrice=dappRegistry[msg.sender].dappPrice;\n if(dappPrice > 0 ){\n //transfert user RLC deplosit to iexecOracleEscrow\n require(iexecOracleEscrow.rlcDeposit(dappPrice));\n }\n owner.transfer(msg.value);\n Submit(tx.origin, msg.sender,dappRegistry[msg.sender].provider, param);\n return true;\n }\n\n function submitCallback(bytes32 submitTxHash, address user, address dapp, IexecLib.StatusEnum status, string stdout, string stderr, string uri) stopInEmergency public {\n assert(msg.sender == owner);\n //set StatusEnum.UNSET forbidden\n require(status != IexecLib.StatusEnum.UNSET);\n //only one call is consider if 2 bridges are up thanks to the following check\n require(workRegistry[submitTxHash].status == IexecLib.StatusEnum.UNSET);\n workRegistry[submitTxHash].timestamp=now;\n workRegistry[submitTxHash].status = status;\n workRegistry[submitTxHash].stdout = stdout;\n workRegistry[submitTxHash].stderr = stderr;\n workRegistry[submitTxHash].uri = uri;\n SubmitCallback(submitTxHash,user,stdout,uri);\n iexecSubmitCallback(submitTxHash,dapp,user,stdout,uri);\n uint256 dappPrice=dappRegistry[dapp].dappPrice;\n if(dappPrice > 0 ){\n if(status == IexecLib.StatusEnum.COMPLETED){\n require(iexecOracleEscrow.rlcPayment(dappRegistry[dapp].provider,dappPrice));\n }\n if(status == IexecLib.StatusEnum.ERROR){\n require(iexecOracleEscrow.rlcPayment(user,dappPrice));\n }\n }\n }\n\n function changeCallbackPrice(uint256 _callbackPrice) public {\n assert(msg.sender == owner);\n callbackPrice=_callbackPrice;\n }\n\n function iexecSubmitCallback(bytes32 submitTxHash, address dapp, address user, string stdout, string uri) internal {\n IexecOracleAPI iexecOracleAPI = IexecOracleAPI(dapp);\n require(iexecOracleAPI.iexecSubmitCallback(submitTxHash,user,stdout,uri));\n }\n\n /**\n * transfer to owner any tokens send by mistake on this contracts\n */\n function emergencyERC20Drain(address rlcTokenAddress, uint amount) public onlyOwner {\n RLC rlcToken = RLC(rlcTokenAddress);\n rlcToken.transfer(owner, amount);\n }\n\n}\n", + "sourcePath": "iexec-oracle-contract/contracts/IexecOracle.sol", + "ast": { + "attributes": { + "absolutePath": "iexec-oracle-contract/contracts/IexecOracle.sol", + "exportedSymbols": { + "IexecOracle": [ + 696 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".18" + ] + }, + "id": 34, + "name": "PragmaDirective", + "src": "0:24:2" + }, + { + "attributes": { + "SourceUnit": 795, + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "file": "./IexecOracleAPI.sol", + "scope": 697, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 35, + "name": "ImportDirective", + "src": "34:30:2" + }, + { + "attributes": { + "SourceUnit": 939, + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleEscrow.sol", + "file": "./IexecOracleEscrow.sol", + "scope": 697, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 36, + "name": "ImportDirective", + "src": "65:33:2" + }, + { + "attributes": { + "SourceUnit": 33, + "absolutePath": "iexec-oracle-contract/contracts/IexecLib.sol", + "file": "./IexecLib.sol", + "scope": 697, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 37, + "name": "ImportDirective", + "src": "99:24:2" + }, + { + "attributes": { + "SourceUnit": 1046, + "absolutePath": "rlc-token/contracts/Ownable.sol", + "file": "rlc-token/contracts/Ownable.sol", + "scope": 697, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 38, + "name": "ImportDirective", + "src": "124:41:2" + }, + { + "attributes": { + "SourceUnit": 1375, + "absolutePath": "rlc-token/contracts/RLC.sol", + "file": "rlc-token/contracts/RLC.sol", + "scope": 697, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 39, + "name": "ImportDirective", + "src": "166:37:2" + }, + { + "attributes": { + "contractDependencies": [ + 1045 + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 696, + 1045 + ], + "name": "IexecOracle", + "scope": 697 + }, + "children": [ + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "Ownable", + "referencedDeclaration": 1045, + "type": "contract Ownable" + }, + "id": 40, + "name": "UserDefinedTypeName", + "src": "230:7:2" + } + ], + "id": 41, + "name": "InheritanceSpecifier", + "src": "230:7:2" + }, + { + "attributes": { + "constant": false, + "name": "stopped", + "scope": 696, + "stateVariable": true, + "storageLocation": "default", + "type": "bool", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 42, + "name": "ElementaryTypeName", + "src": "246:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "66616c7365", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "false" + }, + "id": 43, + "name": "Literal", + "src": "268:5:2" + } + ], + "id": 44, + "name": "VariableDeclaration", + "src": "246:27:2" + }, + { + "attributes": { + "anonymous": false, + "name": "Submit" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": true, + "name": "user", + "scope": 54, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 45, + "name": "ElementaryTypeName", + "src": "335:7:2" + } + ], + "id": 46, + "name": "VariableDeclaration", + "src": "335:20:2" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "dapp", + "scope": 54, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 47, + "name": "ElementaryTypeName", + "src": "357:7:2" + } + ], + "id": 48, + "name": "VariableDeclaration", + "src": "357:20:2" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "provider", + "scope": 54, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 49, + "name": "ElementaryTypeName", + "src": "379:7:2" + } + ], + "id": 50, + "name": "VariableDeclaration", + "src": "379:24:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "args", + "scope": 54, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 51, + "name": "ElementaryTypeName", + "src": "405:6:2" + } + ], + "id": 52, + "name": "VariableDeclaration", + "src": "405:11:2" + } + ], + "id": 53, + "name": "ParameterList", + "src": "334:83:2" + } + ], + "id": 54, + "name": "EventDefinition", + "src": "322:96:2" + }, + { + "attributes": { + "anonymous": false, + "name": "SubmitCallback" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": false, + "name": "submitTxHash", + "scope": 64, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 55, + "name": "ElementaryTypeName", + "src": "477:7:2" + } + ], + "id": 56, + "name": "VariableDeclaration", + "src": "477:20:2" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "user", + "scope": 64, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 57, + "name": "ElementaryTypeName", + "src": "499:7:2" + } + ], + "id": 58, + "name": "VariableDeclaration", + "src": "499:20:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "stdout", + "scope": 64, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 59, + "name": "ElementaryTypeName", + "src": "521:6:2" + } + ], + "id": 60, + "name": "VariableDeclaration", + "src": "521:13:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "uri", + "scope": 64, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 61, + "name": "ElementaryTypeName", + "src": "536:6:2" + } + ], + "id": 62, + "name": "VariableDeclaration", + "src": "536:10:2" + } + ], + "id": 63, + "name": "ParameterList", + "src": "476:71:2" + } + ], + "id": 64, + "name": "EventDefinition", + "src": "456:92:2" + }, + { + "attributes": { + "anonymous": false, + "name": "Register" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": true, + "name": "dapp", + "scope": 74, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 65, + "name": "ElementaryTypeName", + "src": "568:7:2" + } + ], + "id": 66, + "name": "VariableDeclaration", + "src": "568:20:2" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "provider", + "scope": 74, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 67, + "name": "ElementaryTypeName", + "src": "590:7:2" + } + ], + "id": 68, + "name": "VariableDeclaration", + "src": "590:24:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "dappPrice", + "scope": 74, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 69, + "name": "ElementaryTypeName", + "src": "615:7:2" + } + ], + "id": 70, + "name": "VariableDeclaration", + "src": "615:17:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "dappName", + "scope": 74, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 71, + "name": "ElementaryTypeName", + "src": "634:6:2" + } + ], + "id": 72, + "name": "VariableDeclaration", + "src": "634:15:2" + } + ], + "id": 73, + "name": "ParameterList", + "src": "567:83:2" + } + ], + "id": 74, + "name": "EventDefinition", + "src": "553:98:2" + }, + { + "attributes": { + "anonymous": false, + "name": "Error" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": false, + "name": "code", + "scope": 80, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 75, + "name": "ElementaryTypeName", + "src": "668:4:2" + } + ], + "id": 76, + "name": "VariableDeclaration", + "src": "668:9:2" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "message", + "scope": 80, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 77, + "name": "ElementaryTypeName", + "src": "678:6:2" + } + ], + "id": 78, + "name": "VariableDeclaration", + "src": "678:14:2" + } + ], + "id": 79, + "name": "ParameterList", + "src": "667:26:2" + } + ], + "id": 80, + "name": "EventDefinition", + "src": "656:38:2" + }, + { + "attributes": { + "constant": false, + "name": "iexecOracleEscrow", + "scope": 696, + "stateVariable": true, + "storageLocation": "default", + "type": "contract IexecOracleEscrow", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracleEscrow", + "referencedDeclaration": 938, + "type": "contract IexecOracleEscrow" + }, + "id": 81, + "name": "UserDefinedTypeName", + "src": "700:17:2" + } + ], + "id": 82, + "name": "VariableDeclaration", + "src": "700:42:2" + }, + { + "attributes": { + "constant": false, + "name": "callbackPrice", + "scope": 696, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 83, + "name": "ElementaryTypeName", + "src": "749:7:2" + } + ], + "id": 84, + "name": "VariableDeclaration", + "src": "749:28:2" + }, + { + "attributes": { + "canonicalName": "IexecOracle.Work", + "name": "Work", + "scope": 696, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "timestamp", + "scope": 95, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 85, + "name": "ElementaryTypeName", + "src": "804:7:2" + } + ], + "id": 86, + "name": "VariableDeclaration", + "src": "804:17:2" + }, + { + "attributes": { + "constant": false, + "name": "status", + "scope": 95, + "stateVariable": false, + "storageLocation": "default", + "type": "enum IexecLib.StatusEnum", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecLib.StatusEnum", + "referencedDeclaration": 31, + "type": "enum IexecLib.StatusEnum" + }, + "id": 87, + "name": "UserDefinedTypeName", + "src": "829:19:2" + } + ], + "id": 88, + "name": "VariableDeclaration", + "src": "829:26:2" + }, + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 95, + "stateVariable": false, + "storageLocation": "default", + "type": "string storage pointer", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 89, + "name": "ElementaryTypeName", + "src": "863:6:2" + } + ], + "id": 90, + "name": "VariableDeclaration", + "src": "863:13:2" + }, + { + "attributes": { + "constant": false, + "name": "stderr", + "scope": 95, + "stateVariable": false, + "storageLocation": "default", + "type": "string storage pointer", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 91, + "name": "ElementaryTypeName", + "src": "884:6:2" + } + ], + "id": 92, + "name": "VariableDeclaration", + "src": "884:13:2" + }, + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 95, + "stateVariable": false, + "storageLocation": "default", + "type": "string storage pointer", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 93, + "name": "ElementaryTypeName", + "src": "905:6:2" + } + ], + "id": 94, + "name": "VariableDeclaration", + "src": "905:10:2" + } + ], + "id": 95, + "name": "StructDefinition", + "src": "784:138:2" + }, + { + "attributes": { + "constant": false, + "name": "workRegistry", + "scope": 696, + "stateVariable": true, + "storageLocation": "default", + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 96, + "name": "ElementaryTypeName", + "src": "987:7:2" + }, + { + "attributes": { + "contractScope": null, + "name": "Work", + "referencedDeclaration": 95, + "type": "struct IexecOracle.Work storage pointer" + }, + "id": 97, + "name": "UserDefinedTypeName", + "src": "998:4:2" + } + ], + "id": 98, + "name": "Mapping", + "src": "978:25:2" + } + ], + "id": 99, + "name": "VariableDeclaration", + "src": "978:38:2" + }, + { + "attributes": { + "canonicalName": "IexecOracle.Dapp", + "name": "Dapp", + "scope": 696, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "dappName", + "scope": 106, + "stateVariable": false, + "storageLocation": "default", + "type": "string storage pointer", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 100, + "name": "ElementaryTypeName", + "src": "1043:6:2" + } + ], + "id": 101, + "name": "VariableDeclaration", + "src": "1043:15:2" + }, + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 106, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 102, + "name": "ElementaryTypeName", + "src": "1066:7:2" + } + ], + "id": 103, + "name": "VariableDeclaration", + "src": "1066:17:2" + }, + { + "attributes": { + "constant": false, + "name": "provider", + "scope": 106, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 104, + "name": "ElementaryTypeName", + "src": "1091:7:2" + } + ], + "id": 105, + "name": "VariableDeclaration", + "src": "1091:16:2" + } + ], + "id": 106, + "name": "StructDefinition", + "src": "1023:91:2" + }, + { + "attributes": { + "constant": false, + "name": "dappRegistry", + "scope": 696, + "stateVariable": true, + "storageLocation": "default", + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "type": "mapping(address => struct IexecOracle.Dapp storage ref)" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 107, + "name": "ElementaryTypeName", + "src": "1173:7:2" + }, + { + "attributes": { + "contractScope": null, + "name": "Dapp", + "referencedDeclaration": 106, + "type": "struct IexecOracle.Dapp storage pointer" + }, + "id": 108, + "name": "UserDefinedTypeName", + "src": "1184:4:2" + } + ], + "id": 109, + "name": "Mapping", + "src": "1164:26:2" + } + ], + "id": 110, + "name": "VariableDeclaration", + "src": "1164:39:2" + }, + { + "attributes": { + "name": "stopInEmergency", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 111, + "name": "ParameterList", + "src": "1236:0:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 112, + "name": "Identifier", + "src": "1244:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!", + "prefix": true, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 44, + "type": "bool", + "value": "stopped" + }, + "id": 113, + "name": "Identifier", + "src": "1253:7:2" + } + ], + "id": 114, + "name": "UnaryOperation", + "src": "1252:8:2" + } + ], + "id": 115, + "name": "FunctionCall", + "src": "1244:17:2" + } + ], + "id": 116, + "name": "ExpressionStatement", + "src": "1244:17:2" + }, + { + "id": 117, + "name": "PlaceholderStatement", + "src": "1269:1:2" + } + ], + "id": 118, + "name": "Block", + "src": "1236:41:2" + } + ], + "id": 119, + "name": "ModifierDefinition", + "src": "1211:66:2" + }, + { + "attributes": { + "name": "onlyRegistered", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 120, + "name": "ParameterList", + "src": "1306:2:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 121, + "name": "Identifier", + "src": "1318:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 122, + "name": "Identifier", + "src": "1325:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 123, + "name": "Identifier", + "src": "1338:3:2" + } + ], + "id": 124, + "name": "MemberAccess", + "src": "1338:10:2" + } + ], + "id": 125, + "name": "IndexAccess", + "src": "1325:24:2" + } + ], + "id": 126, + "name": "MemberAccess", + "src": "1325:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "307830", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0x0" + }, + "id": 127, + "name": "Literal", + "src": "1362:3:2" + } + ], + "id": 128, + "name": "BinaryOperation", + "src": "1325:40:2" + } + ], + "id": 129, + "name": "FunctionCall", + "src": "1318:48:2" + } + ], + "id": 130, + "name": "ExpressionStatement", + "src": "1318:48:2" + }, + { + "id": 131, + "name": "PlaceholderStatement", + "src": "1376:1:2" + } + ], + "id": 132, + "name": "Block", + "src": "1308:76:2" + } + ], + "id": 133, + "name": "ModifierDefinition", + "src": "1283:101:2" + }, + { + "attributes": { + "name": "checkCallbackPrice", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 134, + "name": "ParameterList", + "src": "1417:2:2" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "<", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "value", + "referencedDeclaration": null, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 135, + "name": "Identifier", + "src": "1432:3:2" + } + ], + "id": 136, + "name": "MemberAccess", + "src": "1432:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 84, + "type": "uint256", + "value": "callbackPrice" + }, + "id": 137, + "name": "Identifier", + "src": "1444:13:2" + } + ], + "id": 138, + "name": "BinaryOperation", + "src": "1432:25:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_1_by_1", + "typeString": "int_const 1" + }, + { + "typeIdentifier": "t_stringliteral_b24802efcd92bba5e6d963c736145d36102c737a3441b8b8c8037dbe5a37b434", + "typeString": "literal_string \"msg.value needed for submit callback gas is too low. Check the current callbackPrice\"" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 80, + "type": "function (uint256,string memory)", + "value": "Error" + }, + "id": 139, + "name": "Identifier", + "src": "1470:5:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "31", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 1", + "value": "1" + }, + "id": 140, + "name": "Literal", + "src": "1476:1:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "6d73672e76616c7565206e656564656420666f72207375626d69742063616c6c6261636b2067617320697320746f6f206c6f772e20436865636b207468652063757272656e742063616c6c6261636b5072696365", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"msg.value needed for submit callback gas is too low. Check the current callbackPrice\"", + "value": "msg.value needed for submit callback gas is too low. Check the current callbackPrice" + }, + "id": 141, + "name": "Literal", + "src": "1478:86:2" + } + ], + "id": 142, + "name": "FunctionCall", + "src": "1470:95:2" + } + ], + "id": 143, + "name": "ExpressionStatement", + "src": "1470:95:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "arguments": [ + null + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + null + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1600, + "type": "function () pure", + "value": "revert" + }, + "id": 144, + "name": "Identifier", + "src": "1577:6:2" + } + ], + "id": 145, + "name": "FunctionCall", + "src": "1577:8:2" + } + ], + "id": 146, + "name": "ExpressionStatement", + "src": "1577:8:2" + } + ], + "id": 147, + "name": "Block", + "src": "1458:138:2" + } + ], + "id": 148, + "name": "IfStatement", + "src": "1429:167:2" + }, + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "value", + "referencedDeclaration": null, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 149, + "name": "Identifier", + "src": "1608:3:2" + } + ], + "id": 150, + "name": "MemberAccess", + "src": "1608:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "31", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": "ether", + "token": "number", + "type": "int_const 1000000000000000000", + "value": "1" + }, + "id": 151, + "name": "Literal", + "src": "1621:7:2" + } + ], + "id": 152, + "name": "BinaryOperation", + "src": "1608:20:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_2_by_1", + "typeString": "int_const 2" + }, + { + "typeIdentifier": "t_stringliteral_2cdd4fc0c4b5363e32c164379daa9ff456cb25eaabd6a41e0fcd8fa8eddd8c11", + "typeString": "literal_string \"msg.value needed for submit callback gas is too high. Must be lower than 1 ether\"" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 80, + "type": "function (uint256,string memory)", + "value": "Error" + }, + "id": 153, + "name": "Identifier", + "src": "1641:5:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "32", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 2", + "value": "2" + }, + "id": 154, + "name": "Literal", + "src": "1647:1:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "6d73672e76616c7565206e656564656420666f72207375626d69742063616c6c6261636b2067617320697320746f6f20686967682e204d757374206265206c6f776572207468616e2031206574686572", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"msg.value needed for submit callback gas is too high. Must be lower than 1 ether\"", + "value": "msg.value needed for submit callback gas is too high. Must be lower than 1 ether" + }, + "id": 155, + "name": "Literal", + "src": "1649:82:2" + } + ], + "id": 156, + "name": "FunctionCall", + "src": "1641:91:2" + } + ], + "id": 157, + "name": "ExpressionStatement", + "src": "1641:91:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "arguments": [ + null + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + null + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1600, + "type": "function () pure", + "value": "revert" + }, + "id": 158, + "name": "Identifier", + "src": "1744:6:2" + } + ], + "id": 159, + "name": "FunctionCall", + "src": "1744:8:2" + } + ], + "id": 160, + "name": "ExpressionStatement", + "src": "1744:8:2" + } + ], + "id": 161, + "name": "Block", + "src": "1629:134:2" + } + ], + "id": 162, + "name": "IfStatement", + "src": "1605:158:2" + }, + { + "id": 163, + "name": "PlaceholderStatement", + "src": "1772:1:2" + } + ], + "id": 164, + "name": "Block", + "src": "1419:361:2" + } + ], + "id": 165, + "name": "ModifierDefinition", + "src": "1390:390:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "modifiers": [ + null + ], + "name": "IexecOracle", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_iexecOracleEscrow", + "scope": 183, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 166, + "name": "ElementaryTypeName", + "src": "1825:7:2" + } + ], + "id": 167, + "name": "VariableDeclaration", + "src": "1825:26:2" + }, + { + "attributes": { + "constant": false, + "name": "_callbackPrice", + "scope": 183, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 168, + "name": "ElementaryTypeName", + "src": "1852:7:2" + } + ], + "id": 169, + "name": "VariableDeclaration", + "src": "1852:22:2" + } + ], + "id": 170, + "name": "ParameterList", + "src": "1824:51:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 171, + "name": "ParameterList", + "src": "1883:0:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "contract IexecOracleEscrow" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 82, + "type": "contract IexecOracleEscrow", + "value": "iexecOracleEscrow" + }, + "id": 172, + "name": "Identifier", + "src": "1893:17:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract IexecOracleEscrow", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 938, + "type": "type(contract IexecOracleEscrow)", + "value": "IexecOracleEscrow" + }, + "id": 173, + "name": "Identifier", + "src": "1911:17:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 167, + "type": "address", + "value": "_iexecOracleEscrow" + }, + "id": 174, + "name": "Identifier", + "src": "1929:18:2" + } + ], + "id": 175, + "name": "FunctionCall", + "src": "1911:37:2" + } + ], + "id": 176, + "name": "Assignment", + "src": "1893:55:2" + } + ], + "id": 177, + "name": "ExpressionStatement", + "src": "1893:55:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 84, + "type": "uint256", + "value": "callbackPrice" + }, + "id": 178, + "name": "Identifier", + "src": "1958:13:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 169, + "type": "uint256", + "value": "_callbackPrice" + }, + "id": 179, + "name": "Identifier", + "src": "1972:14:2" + } + ], + "id": 180, + "name": "Assignment", + "src": "1958:28:2" + } + ], + "id": 181, + "name": "ExpressionStatement", + "src": "1958:28:2" + } + ], + "id": 182, + "name": "Block", + "src": "1883:110:2" + } + ], + "id": 183, + "name": "FunctionDefinition", + "src": "1804:189:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "toggleContractActive", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 184, + "name": "ParameterList", + "src": "2052:2:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 187, + "name": "ParameterList", + "src": "2076:0:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 185, + "name": "Identifier", + "src": "2055:9:2" + } + ], + "id": 186, + "name": "ModifierInvocation", + "src": "2055:9:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 44, + "type": "bool", + "value": "stopped" + }, + "id": 188, + "name": "Identifier", + "src": "2086:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!", + "prefix": true, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 44, + "type": "bool", + "value": "stopped" + }, + "id": 189, + "name": "Identifier", + "src": "2097:7:2" + } + ], + "id": 190, + "name": "UnaryOperation", + "src": "2096:8:2" + } + ], + "id": 191, + "name": "Assignment", + "src": "2086:18:2" + } + ], + "id": 192, + "name": "ExpressionStatement", + "src": "2086:18:2" + } + ], + "id": 193, + "name": "Block", + "src": "2076:35:2" + } + ], + "id": 194, + "name": "FunctionDefinition", + "src": "2023:88:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "registerDappAndProvider", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 260, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 195, + "name": "ElementaryTypeName", + "src": "2150:7:2" + } + ], + "id": 196, + "name": "VariableDeclaration", + "src": "2150:17:2" + }, + { + "attributes": { + "constant": false, + "name": "dappName", + "scope": 260, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 197, + "name": "ElementaryTypeName", + "src": "2168:6:2" + } + ], + "id": 198, + "name": "VariableDeclaration", + "src": "2168:15:2" + } + ], + "id": 199, + "name": "ParameterList", + "src": "2149:35:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 260, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 202, + "name": "ElementaryTypeName", + "src": "2218:4:2" + } + ], + "id": 203, + "name": "VariableDeclaration", + "src": "2218:4:2" + } + ], + "id": 204, + "name": "ParameterList", + "src": "2217:6:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 119, + "type": "modifier ()", + "value": "stopInEmergency" + }, + "id": 200, + "name": "Identifier", + "src": "2185:15:2" + } + ], + "id": 201, + "name": "ModifierInvocation", + "src": "2185:15:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 205, + "name": "Identifier", + "src": "2234:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 206, + "name": "Identifier", + "src": "2241:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 207, + "name": "Identifier", + "src": "2254:3:2" + } + ], + "id": 208, + "name": "MemberAccess", + "src": "2254:10:2" + } + ], + "id": 209, + "name": "IndexAccess", + "src": "2241:24:2" + } + ], + "id": 210, + "name": "MemberAccess", + "src": "2241:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "307830", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0x0" + }, + "id": 211, + "name": "Literal", + "src": "2278:3:2" + } + ], + "id": 212, + "name": "BinaryOperation", + "src": "2241:40:2" + } + ], + "id": 213, + "name": "FunctionCall", + "src": "2234:48:2" + } + ], + "id": 214, + "name": "ExpressionStatement", + "src": "2234:48:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 215, + "name": "Identifier", + "src": "2292:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 216, + "name": "Identifier", + "src": "2299:3:2" + } + ], + "id": 217, + "name": "MemberAccess", + "src": "2299:10:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "origin", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1606, + "type": "tx", + "value": "tx" + }, + "id": 218, + "name": "Identifier", + "src": "2313:2:2" + } + ], + "id": 219, + "name": "MemberAccess", + "src": "2313:9:2" + } + ], + "id": 220, + "name": "BinaryOperation", + "src": "2299:23:2" + } + ], + "id": 221, + "name": "FunctionCall", + "src": "2292:31:2" + } + ], + "id": 222, + "name": "ExpressionStatement", + "src": "2292:31:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 223, + "name": "Identifier", + "src": "2333:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 224, + "name": "Identifier", + "src": "2346:3:2" + } + ], + "id": 225, + "name": "MemberAccess", + "src": "2346:10:2" + } + ], + "id": 226, + "name": "IndexAccess", + "src": "2333:24:2" + } + ], + "id": 227, + "name": "MemberAccess", + "src": "2333:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "origin", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1606, + "type": "tx", + "value": "tx" + }, + "id": 228, + "name": "Identifier", + "src": "2367:2:2" + } + ], + "id": 229, + "name": "MemberAccess", + "src": "2367:9:2" + } + ], + "id": 230, + "name": "Assignment", + "src": "2333:43:2" + } + ], + "id": 231, + "name": "ExpressionStatement", + "src": "2333:43:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "dappPrice", + "referencedDeclaration": 103, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 232, + "name": "Identifier", + "src": "2386:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 233, + "name": "Identifier", + "src": "2399:3:2" + } + ], + "id": 234, + "name": "MemberAccess", + "src": "2399:10:2" + } + ], + "id": 235, + "name": "IndexAccess", + "src": "2386:24:2" + } + ], + "id": 236, + "name": "MemberAccess", + "src": "2386:34:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 196, + "type": "uint256", + "value": "dappPrice" + }, + "id": 237, + "name": "Identifier", + "src": "2421:9:2" + } + ], + "id": 238, + "name": "Assignment", + "src": "2386:44:2" + } + ], + "id": 239, + "name": "ExpressionStatement", + "src": "2386:44:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "dappName", + "referencedDeclaration": 101, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 240, + "name": "Identifier", + "src": "2440:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 241, + "name": "Identifier", + "src": "2453:3:2" + } + ], + "id": 242, + "name": "MemberAccess", + "src": "2453:10:2" + } + ], + "id": 243, + "name": "IndexAccess", + "src": "2440:24:2" + } + ], + "id": 244, + "name": "MemberAccess", + "src": "2440:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 198, + "type": "string memory", + "value": "dappName" + }, + "id": 245, + "name": "Identifier", + "src": "2474:8:2" + } + ], + "id": 246, + "name": "Assignment", + "src": "2440:42:2" + } + ], + "id": 247, + "name": "ExpressionStatement", + "src": "2440:42:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 74, + "type": "function (address,address,uint256,string memory)", + "value": "Register" + }, + "id": 248, + "name": "Identifier", + "src": "2492:8:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 249, + "name": "Identifier", + "src": "2501:3:2" + } + ], + "id": 250, + "name": "MemberAccess", + "src": "2501:10:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "origin", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1606, + "type": "tx", + "value": "tx" + }, + "id": 251, + "name": "Identifier", + "src": "2512:2:2" + } + ], + "id": 252, + "name": "MemberAccess", + "src": "2512:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 196, + "type": "uint256", + "value": "dappPrice" + }, + "id": 253, + "name": "Identifier", + "src": "2522:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 198, + "type": "string memory", + "value": "dappName" + }, + "id": 254, + "name": "Identifier", + "src": "2532:8:2" + } + ], + "id": 255, + "name": "FunctionCall", + "src": "2492:49:2" + } + ], + "id": 256, + "name": "ExpressionStatement", + "src": "2492:49:2" + }, + { + "attributes": { + "functionReturnParameters": 204 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 257, + "name": "Literal", + "src": "2558:4:2" + } + ], + "id": 258, + "name": "Return", + "src": "2551:11:2" + } + ], + "id": 259, + "name": "Block", + "src": "2224:345:2" + } + ], + "id": 260, + "name": "FunctionDefinition", + "src": "2117:452:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getDapp", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 286, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 261, + "name": "ElementaryTypeName", + "src": "2592:7:2" + } + ], + "id": 262, + "name": "VariableDeclaration", + "src": "2592:12:2" + } + ], + "id": 263, + "name": "ParameterList", + "src": "2591:14:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dappName", + "scope": 286, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 264, + "name": "ElementaryTypeName", + "src": "2631:6:2" + } + ], + "id": 265, + "name": "VariableDeclaration", + "src": "2631:15:2" + }, + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 286, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 266, + "name": "ElementaryTypeName", + "src": "2648:7:2" + } + ], + "id": 267, + "name": "VariableDeclaration", + "src": "2648:17:2" + }, + { + "attributes": { + "constant": false, + "name": "provider", + "scope": 286, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 268, + "name": "ElementaryTypeName", + "src": "2667:7:2" + } + ], + "id": 269, + "name": "VariableDeclaration", + "src": "2667:16:2" + } + ], + "id": 270, + "name": "ParameterList", + "src": "2630:54:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 270 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isInlineArray": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "tuple(string storage ref,uint256,address)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappName", + "referencedDeclaration": 101, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 271, + "name": "Identifier", + "src": "2712:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 262, + "type": "address", + "value": "dapp" + }, + "id": 272, + "name": "Identifier", + "src": "2725:4:2" + } + ], + "id": 273, + "name": "IndexAccess", + "src": "2712:18:2" + } + ], + "id": 274, + "name": "MemberAccess", + "src": "2712:27:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappPrice", + "referencedDeclaration": 103, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 275, + "name": "Identifier", + "src": "2749:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 262, + "type": "address", + "value": "dapp" + }, + "id": 276, + "name": "Identifier", + "src": "2762:4:2" + } + ], + "id": 277, + "name": "IndexAccess", + "src": "2749:18:2" + } + ], + "id": 278, + "name": "MemberAccess", + "src": "2749:28:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 279, + "name": "Identifier", + "src": "2787:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 262, + "type": "address", + "value": "dapp" + }, + "id": 280, + "name": "Identifier", + "src": "2800:4:2" + } + ], + "id": 281, + "name": "IndexAccess", + "src": "2787:18:2" + } + ], + "id": 282, + "name": "MemberAccess", + "src": "2787:27:2" + } + ], + "id": 283, + "name": "TupleExpression", + "src": "2702:122:2" + } + ], + "id": 284, + "name": "Return", + "src": "2695:129:2" + } + ], + "id": 285, + "name": "Block", + "src": "2685:146:2" + } + ], + "id": 286, + "name": "FunctionDefinition", + "src": "2575:256:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getProvider", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 299, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 287, + "name": "ElementaryTypeName", + "src": "2858:7:2" + } + ], + "id": 288, + "name": "VariableDeclaration", + "src": "2858:12:2" + } + ], + "id": 289, + "name": "ParameterList", + "src": "2857:14:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "provider", + "scope": 299, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 290, + "name": "ElementaryTypeName", + "src": "2897:7:2" + } + ], + "id": 291, + "name": "VariableDeclaration", + "src": "2897:16:2" + } + ], + "id": 292, + "name": "ParameterList", + "src": "2896:18:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 292 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 293, + "name": "Identifier", + "src": "2932:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 288, + "type": "address", + "value": "dapp" + }, + "id": 294, + "name": "Identifier", + "src": "2945:4:2" + } + ], + "id": 295, + "name": "IndexAccess", + "src": "2932:18:2" + } + ], + "id": 296, + "name": "MemberAccess", + "src": "2932:27:2" + } + ], + "id": 297, + "name": "Return", + "src": "2925:34:2" + } + ], + "id": 298, + "name": "Block", + "src": "2915:51:2" + } + ], + "id": 299, + "name": "FunctionDefinition", + "src": "2837:129:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getDappPrice", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 312, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 300, + "name": "ElementaryTypeName", + "src": "2994:7:2" + } + ], + "id": 301, + "name": "VariableDeclaration", + "src": "2994:12:2" + } + ], + "id": 302, + "name": "ParameterList", + "src": "2993:14:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 312, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 303, + "name": "ElementaryTypeName", + "src": "3033:7:2" + } + ], + "id": 304, + "name": "VariableDeclaration", + "src": "3033:17:2" + } + ], + "id": 305, + "name": "ParameterList", + "src": "3032:19:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 305 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappPrice", + "referencedDeclaration": 103, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 306, + "name": "Identifier", + "src": "3069:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 301, + "type": "address", + "value": "dapp" + }, + "id": 307, + "name": "Identifier", + "src": "3082:4:2" + } + ], + "id": 308, + "name": "IndexAccess", + "src": "3069:18:2" + } + ], + "id": 309, + "name": "MemberAccess", + "src": "3069:28:2" + } + ], + "id": 310, + "name": "Return", + "src": "3062:35:2" + } + ], + "id": 311, + "name": "Block", + "src": "3052:52:2" + } + ], + "id": 312, + "name": "FunctionDefinition", + "src": "2972:132:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getDappName", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 325, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 313, + "name": "ElementaryTypeName", + "src": "3131:7:2" + } + ], + "id": 314, + "name": "VariableDeclaration", + "src": "3131:12:2" + } + ], + "id": 315, + "name": "ParameterList", + "src": "3130:14:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dappName", + "scope": 325, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 316, + "name": "ElementaryTypeName", + "src": "3170:6:2" + } + ], + "id": 317, + "name": "VariableDeclaration", + "src": "3170:15:2" + } + ], + "id": 318, + "name": "ParameterList", + "src": "3169:17:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 318 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappName", + "referencedDeclaration": 101, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 319, + "name": "Identifier", + "src": "3204:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 314, + "type": "address", + "value": "dapp" + }, + "id": 320, + "name": "Identifier", + "src": "3217:4:2" + } + ], + "id": 321, + "name": "IndexAccess", + "src": "3204:18:2" + } + ], + "id": 322, + "name": "MemberAccess", + "src": "3204:27:2" + } + ], + "id": 323, + "name": "Return", + "src": "3197:34:2" + } + ], + "id": 324, + "name": "Block", + "src": "3187:51:2" + } + ], + "id": 325, + "name": "FunctionDefinition", + "src": "3110:128:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWork", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 326, + "name": "ElementaryTypeName", + "src": "3261:7:2" + } + ], + "id": 327, + "name": "VariableDeclaration", + "src": "3261:20:2" + } + ], + "id": 328, + "name": "ParameterList", + "src": "3260:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "timestamp", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 329, + "name": "ElementaryTypeName", + "src": "3308:7:2" + } + ], + "id": 330, + "name": "VariableDeclaration", + "src": "3308:17:2" + }, + { + "attributes": { + "constant": false, + "name": "status", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "enum IexecLib.StatusEnum", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecLib.StatusEnum", + "referencedDeclaration": 31, + "type": "enum IexecLib.StatusEnum" + }, + "id": 331, + "name": "UserDefinedTypeName", + "src": "3327:19:2" + } + ], + "id": 332, + "name": "VariableDeclaration", + "src": "3327:26:2" + }, + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 333, + "name": "ElementaryTypeName", + "src": "3355:6:2" + } + ], + "id": 334, + "name": "VariableDeclaration", + "src": "3355:13:2" + }, + { + "attributes": { + "constant": false, + "name": "stderr", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 335, + "name": "ElementaryTypeName", + "src": "3370:6:2" + } + ], + "id": 336, + "name": "VariableDeclaration", + "src": "3370:13:2" + }, + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 363, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 337, + "name": "ElementaryTypeName", + "src": "3385:6:2" + } + ], + "id": 338, + "name": "VariableDeclaration", + "src": "3385:10:2" + } + ], + "id": 339, + "name": "ParameterList", + "src": "3307:89:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 339 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isInlineArray": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "tuple(uint256,enum IexecLib.StatusEnum,string storage ref,string storage ref,string storage ref)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "timestamp", + "referencedDeclaration": 86, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 340, + "name": "Identifier", + "src": "3424:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 327, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 341, + "name": "Identifier", + "src": "3437:12:2" + } + ], + "id": 342, + "name": "IndexAccess", + "src": "3424:26:2" + } + ], + "id": 343, + "name": "MemberAccess", + "src": "3424:36:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "status", + "referencedDeclaration": 88, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 344, + "name": "Identifier", + "src": "3470:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 327, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 345, + "name": "Identifier", + "src": "3483:12:2" + } + ], + "id": 346, + "name": "IndexAccess", + "src": "3470:26:2" + } + ], + "id": 347, + "name": "MemberAccess", + "src": "3470:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "stdout", + "referencedDeclaration": 90, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 348, + "name": "Identifier", + "src": "3513:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 327, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 349, + "name": "Identifier", + "src": "3526:12:2" + } + ], + "id": 350, + "name": "IndexAccess", + "src": "3513:26:2" + } + ], + "id": 351, + "name": "MemberAccess", + "src": "3513:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "stderr", + "referencedDeclaration": 92, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 352, + "name": "Identifier", + "src": "3556:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 327, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 353, + "name": "Identifier", + "src": "3569:12:2" + } + ], + "id": 354, + "name": "IndexAccess", + "src": "3556:26:2" + } + ], + "id": 355, + "name": "MemberAccess", + "src": "3556:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "uri", + "referencedDeclaration": 94, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 356, + "name": "Identifier", + "src": "3599:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 327, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 357, + "name": "Identifier", + "src": "3612:12:2" + } + ], + "id": 358, + "name": "IndexAccess", + "src": "3599:26:2" + } + ], + "id": 359, + "name": "MemberAccess", + "src": "3599:30:2" + } + ], + "id": 360, + "name": "TupleExpression", + "src": "3414:225:2" + } + ], + "id": 361, + "name": "Return", + "src": "3407:232:2" + } + ], + "id": 362, + "name": "Block", + "src": "3397:249:2" + } + ], + "id": 363, + "name": "FunctionDefinition", + "src": "3244:402:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWorkTimestamp", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 376, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 364, + "name": "ElementaryTypeName", + "src": "3678:7:2" + } + ], + "id": 365, + "name": "VariableDeclaration", + "src": "3678:20:2" + } + ], + "id": 366, + "name": "ParameterList", + "src": "3677:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "timestamp", + "scope": 376, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 367, + "name": "ElementaryTypeName", + "src": "3725:7:2" + } + ], + "id": 368, + "name": "VariableDeclaration", + "src": "3725:17:2" + } + ], + "id": 369, + "name": "ParameterList", + "src": "3724:19:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 369 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "timestamp", + "referencedDeclaration": 86, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 370, + "name": "Identifier", + "src": "3761:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 365, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 371, + "name": "Identifier", + "src": "3774:12:2" + } + ], + "id": 372, + "name": "IndexAccess", + "src": "3761:26:2" + } + ], + "id": 373, + "name": "MemberAccess", + "src": "3761:36:2" + } + ], + "id": 374, + "name": "Return", + "src": "3754:43:2" + } + ], + "id": 375, + "name": "Block", + "src": "3744:60:2" + } + ], + "id": 376, + "name": "FunctionDefinition", + "src": "3652:152:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWorkStatus", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 389, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 377, + "name": "ElementaryTypeName", + "src": "3833:7:2" + } + ], + "id": 378, + "name": "VariableDeclaration", + "src": "3833:20:2" + } + ], + "id": 379, + "name": "ParameterList", + "src": "3832:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "status", + "scope": 389, + "stateVariable": false, + "storageLocation": "default", + "type": "enum IexecLib.StatusEnum", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecLib.StatusEnum", + "referencedDeclaration": 31, + "type": "enum IexecLib.StatusEnum" + }, + "id": 380, + "name": "UserDefinedTypeName", + "src": "3880:19:2" + } + ], + "id": 381, + "name": "VariableDeclaration", + "src": "3880:26:2" + } + ], + "id": 382, + "name": "ParameterList", + "src": "3879:28:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 382 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "status", + "referencedDeclaration": 88, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 383, + "name": "Identifier", + "src": "3925:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 378, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 384, + "name": "Identifier", + "src": "3938:12:2" + } + ], + "id": 385, + "name": "IndexAccess", + "src": "3925:26:2" + } + ], + "id": 386, + "name": "MemberAccess", + "src": "3925:33:2" + } + ], + "id": 387, + "name": "Return", + "src": "3918:40:2" + } + ], + "id": 388, + "name": "Block", + "src": "3908:57:2" + } + ], + "id": 389, + "name": "FunctionDefinition", + "src": "3810:155:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWorkStdout", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 402, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 390, + "name": "ElementaryTypeName", + "src": "3994:7:2" + } + ], + "id": 391, + "name": "VariableDeclaration", + "src": "3994:20:2" + } + ], + "id": 392, + "name": "ParameterList", + "src": "3993:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 402, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 393, + "name": "ElementaryTypeName", + "src": "4041:6:2" + } + ], + "id": 394, + "name": "VariableDeclaration", + "src": "4041:13:2" + } + ], + "id": 395, + "name": "ParameterList", + "src": "4040:15:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 395 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "stdout", + "referencedDeclaration": 90, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 396, + "name": "Identifier", + "src": "4073:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 391, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 397, + "name": "Identifier", + "src": "4086:12:2" + } + ], + "id": 398, + "name": "IndexAccess", + "src": "4073:26:2" + } + ], + "id": 399, + "name": "MemberAccess", + "src": "4073:33:2" + } + ], + "id": 400, + "name": "Return", + "src": "4066:40:2" + } + ], + "id": 401, + "name": "Block", + "src": "4056:57:2" + } + ], + "id": 402, + "name": "FunctionDefinition", + "src": "3971:142:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWorkStderr", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 415, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 403, + "name": "ElementaryTypeName", + "src": "4142:7:2" + } + ], + "id": 404, + "name": "VariableDeclaration", + "src": "4142:20:2" + } + ], + "id": 405, + "name": "ParameterList", + "src": "4141:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "stderr", + "scope": 415, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 406, + "name": "ElementaryTypeName", + "src": "4189:6:2" + } + ], + "id": 407, + "name": "VariableDeclaration", + "src": "4189:13:2" + } + ], + "id": 408, + "name": "ParameterList", + "src": "4188:15:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 408 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "stderr", + "referencedDeclaration": 92, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 409, + "name": "Identifier", + "src": "4221:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 404, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 410, + "name": "Identifier", + "src": "4234:12:2" + } + ], + "id": 411, + "name": "IndexAccess", + "src": "4221:26:2" + } + ], + "id": 412, + "name": "MemberAccess", + "src": "4221:33:2" + } + ], + "id": 413, + "name": "Return", + "src": "4214:40:2" + } + ], + "id": 414, + "name": "Block", + "src": "4204:57:2" + } + ], + "id": 415, + "name": "FunctionDefinition", + "src": "4119:142:2" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "getWorkUri", + "payable": false, + "scope": 696, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 428, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 416, + "name": "ElementaryTypeName", + "src": "4287:7:2" + } + ], + "id": 417, + "name": "VariableDeclaration", + "src": "4287:20:2" + } + ], + "id": 418, + "name": "ParameterList", + "src": "4286:22:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 428, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 419, + "name": "ElementaryTypeName", + "src": "4334:6:2" + } + ], + "id": 420, + "name": "VariableDeclaration", + "src": "4334:10:2" + } + ], + "id": 421, + "name": "ParameterList", + "src": "4333:12:2" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 421 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "uri", + "referencedDeclaration": 94, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 422, + "name": "Identifier", + "src": "4363:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 417, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 423, + "name": "Identifier", + "src": "4376:12:2" + } + ], + "id": 424, + "name": "IndexAccess", + "src": "4363:26:2" + } + ], + "id": 425, + "name": "MemberAccess", + "src": "4363:30:2" + } + ], + "id": 426, + "name": "Return", + "src": "4356:37:2" + } + ], + "id": 427, + "name": "Block", + "src": "4346:54:2" + } + ], + "id": 428, + "name": "FunctionDefinition", + "src": "4267:133:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "submit", + "payable": true, + "scope": 696, + "stateMutability": "payable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "param", + "scope": 484, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 429, + "name": "ElementaryTypeName", + "src": "4422:6:2" + } + ], + "id": 430, + "name": "VariableDeclaration", + "src": "4422:12:2" + } + ], + "id": 431, + "name": "ParameterList", + "src": "4421:14:2" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 484, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 438, + "name": "ElementaryTypeName", + "src": "4511:4:2" + } + ], + "id": 439, + "name": "VariableDeclaration", + "src": "4511:4:2" + } + ], + "id": 440, + "name": "ParameterList", + "src": "4510:6:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 133, + "type": "modifier ()", + "value": "onlyRegistered" + }, + "id": 432, + "name": "Identifier", + "src": "4436:14:2" + } + ], + "id": 433, + "name": "ModifierInvocation", + "src": "4436:14:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 165, + "type": "modifier ()", + "value": "checkCallbackPrice" + }, + "id": 434, + "name": "Identifier", + "src": "4452:18:2" + } + ], + "id": 435, + "name": "ModifierInvocation", + "src": "4452:18:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 119, + "type": "modifier ()", + "value": "stopInEmergency" + }, + "id": 436, + "name": "Identifier", + "src": "4471:15:2" + } + ], + "id": 437, + "name": "ModifierInvocation", + "src": "4471:15:2" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 442 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 484, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 441, + "name": "ElementaryTypeName", + "src": "4526:7:2" + } + ], + "id": 442, + "name": "VariableDeclaration", + "src": "4526:17:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappPrice", + "referencedDeclaration": 103, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 443, + "name": "Identifier", + "src": "4544:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 444, + "name": "Identifier", + "src": "4557:3:2" + } + ], + "id": 445, + "name": "MemberAccess", + "src": "4557:10:2" + } + ], + "id": 446, + "name": "IndexAccess", + "src": "4544:24:2" + } + ], + "id": 447, + "name": "MemberAccess", + "src": "4544:34:2" + } + ], + "id": 448, + "name": "VariableDeclarationStatement", + "src": "4526:52:2" + }, + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 442, + "type": "uint256", + "value": "dappPrice" + }, + "id": 449, + "name": "Identifier", + "src": "4591:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 450, + "name": "Literal", + "src": "4603:1:2" + } + ], + "id": 451, + "name": "BinaryOperation", + "src": "4591:13:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 452, + "name": "Identifier", + "src": "4683:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "rlcDeposit", + "referencedDeclaration": 903, + "type": "function (uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 82, + "type": "contract IexecOracleEscrow", + "value": "iexecOracleEscrow" + }, + "id": 453, + "name": "Identifier", + "src": "4691:17:2" + } + ], + "id": 454, + "name": "MemberAccess", + "src": "4691:28:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 442, + "type": "uint256", + "value": "dappPrice" + }, + "id": 455, + "name": "Identifier", + "src": "4720:9:2" + } + ], + "id": 456, + "name": "FunctionCall", + "src": "4691:39:2" + } + ], + "id": 457, + "name": "FunctionCall", + "src": "4683:48:2" + } + ], + "id": 458, + "name": "ExpressionStatement", + "src": "4683:48:2" + } + ], + "id": 459, + "name": "Block", + "src": "4606:136:2" + } + ], + "id": 460, + "name": "IfStatement", + "src": "4588:154:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "transfer", + "referencedDeclaration": null, + "type": "function (uint256)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 461, + "name": "Identifier", + "src": "4751:5:2" + } + ], + "id": 463, + "name": "MemberAccess", + "src": "4751:14:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "value", + "referencedDeclaration": null, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 464, + "name": "Identifier", + "src": "4766:3:2" + } + ], + "id": 465, + "name": "MemberAccess", + "src": "4766:9:2" + } + ], + "id": 466, + "name": "FunctionCall", + "src": "4751:25:2" + } + ], + "id": 467, + "name": "ExpressionStatement", + "src": "4751:25:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 54, + "type": "function (address,address,address,string memory)", + "value": "Submit" + }, + "id": 468, + "name": "Identifier", + "src": "4786:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "origin", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1606, + "type": "tx", + "value": "tx" + }, + "id": 469, + "name": "Identifier", + "src": "4793:2:2" + } + ], + "id": 470, + "name": "MemberAccess", + "src": "4793:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 471, + "name": "Identifier", + "src": "4804:3:2" + } + ], + "id": 472, + "name": "MemberAccess", + "src": "4804:10:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 473, + "name": "Identifier", + "src": "4815:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 474, + "name": "Identifier", + "src": "4828:3:2" + } + ], + "id": 475, + "name": "MemberAccess", + "src": "4828:10:2" + } + ], + "id": 476, + "name": "IndexAccess", + "src": "4815:24:2" + } + ], + "id": 477, + "name": "MemberAccess", + "src": "4815:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 430, + "type": "string memory", + "value": "param" + }, + "id": 478, + "name": "Identifier", + "src": "4850:5:2" + } + ], + "id": 479, + "name": "FunctionCall", + "src": "4786:70:2" + } + ], + "id": 480, + "name": "ExpressionStatement", + "src": "4786:70:2" + }, + { + "attributes": { + "functionReturnParameters": 440 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 481, + "name": "Literal", + "src": "4873:4:2" + } + ], + "id": 482, + "name": "Return", + "src": "4866:11:2" + } + ], + "id": 483, + "name": "Block", + "src": "4516:368:2" + } + ], + "id": 484, + "name": "FunctionDefinition", + "src": "4406:478:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "submitCallback", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 485, + "name": "ElementaryTypeName", + "src": "4914:7:2" + } + ], + "id": 486, + "name": "VariableDeclaration", + "src": "4914:20:2" + }, + { + "attributes": { + "constant": false, + "name": "user", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 487, + "name": "ElementaryTypeName", + "src": "4936:7:2" + } + ], + "id": 488, + "name": "VariableDeclaration", + "src": "4936:12:2" + }, + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 489, + "name": "ElementaryTypeName", + "src": "4950:7:2" + } + ], + "id": 490, + "name": "VariableDeclaration", + "src": "4950:12:2" + }, + { + "attributes": { + "constant": false, + "name": "status", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "enum IexecLib.StatusEnum", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecLib.StatusEnum", + "referencedDeclaration": 31, + "type": "enum IexecLib.StatusEnum" + }, + "id": 491, + "name": "UserDefinedTypeName", + "src": "4964:19:2" + } + ], + "id": 492, + "name": "VariableDeclaration", + "src": "4964:26:2" + }, + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 493, + "name": "ElementaryTypeName", + "src": "4992:6:2" + } + ], + "id": 494, + "name": "VariableDeclaration", + "src": "4992:13:2" + }, + { + "attributes": { + "constant": false, + "name": "stderr", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 495, + "name": "ElementaryTypeName", + "src": "5007:6:2" + } + ], + "id": 496, + "name": "VariableDeclaration", + "src": "5007:13:2" + }, + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 497, + "name": "ElementaryTypeName", + "src": "5022:6:2" + } + ], + "id": 498, + "name": "VariableDeclaration", + "src": "5022:10:2" + } + ], + "id": 499, + "name": "ParameterList", + "src": "4913:120:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 502, + "name": "ParameterList", + "src": "5057:0:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 119, + "type": "modifier ()", + "value": "stopInEmergency" + }, + "id": 500, + "name": "Identifier", + "src": "5034:15:2" + } + ], + "id": 501, + "name": "ModifierInvocation", + "src": "5034:15:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 503, + "name": "Identifier", + "src": "5067:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 504, + "name": "Identifier", + "src": "5074:3:2" + } + ], + "id": 505, + "name": "MemberAccess", + "src": "5074:10:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 506, + "name": "Identifier", + "src": "5088:5:2" + } + ], + "id": 507, + "name": "BinaryOperation", + "src": "5074:19:2" + } + ], + "id": 508, + "name": "FunctionCall", + "src": "5067:27:2" + } + ], + "id": 509, + "name": "ExpressionStatement", + "src": "5067:27:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 510, + "name": "Identifier", + "src": "5145:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_enum$_StatusEnum_$31", + "typeString": "enum IexecLib.StatusEnum" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 492, + "type": "enum IexecLib.StatusEnum", + "value": "status" + }, + "id": 511, + "name": "Identifier", + "src": "5153:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "member_name": "UNSET", + "referencedDeclaration": null, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "StatusEnum", + "referencedDeclaration": 31, + "type": "type(enum IexecLib.StatusEnum)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 32, + "type": "type(library IexecLib)", + "value": "IexecLib" + }, + "id": 512, + "name": "Identifier", + "src": "5163:8:2" + } + ], + "id": 513, + "name": "MemberAccess", + "src": "5163:19:2" + } + ], + "id": 514, + "name": "MemberAccess", + "src": "5163:25:2" + } + ], + "id": 515, + "name": "BinaryOperation", + "src": "5153:35:2" + } + ], + "id": 516, + "name": "FunctionCall", + "src": "5145:44:2" + } + ], + "id": 517, + "name": "ExpressionStatement", + "src": "5145:44:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 518, + "name": "Identifier", + "src": "5285:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_enum$_StatusEnum_$31", + "typeString": "enum IexecLib.StatusEnum" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "status", + "referencedDeclaration": 88, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 519, + "name": "Identifier", + "src": "5293:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 520, + "name": "Identifier", + "src": "5306:12:2" + } + ], + "id": 521, + "name": "IndexAccess", + "src": "5293:26:2" + } + ], + "id": 522, + "name": "MemberAccess", + "src": "5293:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "member_name": "UNSET", + "referencedDeclaration": null, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "StatusEnum", + "referencedDeclaration": 31, + "type": "type(enum IexecLib.StatusEnum)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 32, + "type": "type(library IexecLib)", + "value": "IexecLib" + }, + "id": 523, + "name": "Identifier", + "src": "5330:8:2" + } + ], + "id": 524, + "name": "MemberAccess", + "src": "5330:19:2" + } + ], + "id": 525, + "name": "MemberAccess", + "src": "5330:25:2" + } + ], + "id": 526, + "name": "BinaryOperation", + "src": "5293:62:2" + } + ], + "id": 527, + "name": "FunctionCall", + "src": "5285:71:2" + } + ], + "id": 528, + "name": "ExpressionStatement", + "src": "5285:71:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "timestamp", + "referencedDeclaration": 86, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 529, + "name": "Identifier", + "src": "5366:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 530, + "name": "Identifier", + "src": "5379:12:2" + } + ], + "id": 531, + "name": "IndexAccess", + "src": "5366:26:2" + } + ], + "id": 532, + "name": "MemberAccess", + "src": "5366:36:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1598, + "type": "uint256", + "value": "now" + }, + "id": 533, + "name": "Identifier", + "src": "5403:3:2" + } + ], + "id": 534, + "name": "Assignment", + "src": "5366:40:2" + } + ], + "id": 535, + "name": "ExpressionStatement", + "src": "5366:40:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "status", + "referencedDeclaration": 88, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 536, + "name": "Identifier", + "src": "5416:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 537, + "name": "Identifier", + "src": "5429:12:2" + } + ], + "id": 538, + "name": "IndexAccess", + "src": "5416:26:2" + } + ], + "id": 539, + "name": "MemberAccess", + "src": "5416:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 492, + "type": "enum IexecLib.StatusEnum", + "value": "status" + }, + "id": 540, + "name": "Identifier", + "src": "5452:6:2" + } + ], + "id": 541, + "name": "Assignment", + "src": "5416:42:2" + } + ], + "id": 542, + "name": "ExpressionStatement", + "src": "5416:42:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "stdout", + "referencedDeclaration": 90, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 543, + "name": "Identifier", + "src": "5468:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 544, + "name": "Identifier", + "src": "5481:12:2" + } + ], + "id": 545, + "name": "IndexAccess", + "src": "5468:26:2" + } + ], + "id": 546, + "name": "MemberAccess", + "src": "5468:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 494, + "type": "string memory", + "value": "stdout" + }, + "id": 547, + "name": "Identifier", + "src": "5504:6:2" + } + ], + "id": 548, + "name": "Assignment", + "src": "5468:42:2" + } + ], + "id": 549, + "name": "ExpressionStatement", + "src": "5468:42:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "stderr", + "referencedDeclaration": 92, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 550, + "name": "Identifier", + "src": "5520:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 551, + "name": "Identifier", + "src": "5533:12:2" + } + ], + "id": 552, + "name": "IndexAccess", + "src": "5520:26:2" + } + ], + "id": 553, + "name": "MemberAccess", + "src": "5520:33:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 496, + "type": "string memory", + "value": "stderr" + }, + "id": 554, + "name": "Identifier", + "src": "5556:6:2" + } + ], + "id": 555, + "name": "Assignment", + "src": "5520:42:2" + } + ], + "id": 556, + "name": "ExpressionStatement", + "src": "5520:42:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "member_name": "uri", + "referencedDeclaration": 94, + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Work storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 99, + "type": "mapping(bytes32 => struct IexecOracle.Work storage ref)", + "value": "workRegistry" + }, + "id": 557, + "name": "Identifier", + "src": "5572:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 558, + "name": "Identifier", + "src": "5585:12:2" + } + ], + "id": 559, + "name": "IndexAccess", + "src": "5572:26:2" + } + ], + "id": 560, + "name": "MemberAccess", + "src": "5572:30:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 498, + "type": "string memory", + "value": "uri" + }, + "id": 561, + "name": "Identifier", + "src": "5605:3:2" + } + ], + "id": 562, + "name": "Assignment", + "src": "5572:36:2" + } + ], + "id": 563, + "name": "ExpressionStatement", + "src": "5572:36:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 64, + "type": "function (bytes32,address,string memory,string memory)", + "value": "SubmitCallback" + }, + "id": 564, + "name": "Identifier", + "src": "5618:14:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 565, + "name": "Identifier", + "src": "5633:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 488, + "type": "address", + "value": "user" + }, + "id": 566, + "name": "Identifier", + "src": "5646:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 494, + "type": "string memory", + "value": "stdout" + }, + "id": 567, + "name": "Identifier", + "src": "5651:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 498, + "type": "string memory", + "value": "uri" + }, + "id": 568, + "name": "Identifier", + "src": "5658:3:2" + } + ], + "id": 569, + "name": "FunctionCall", + "src": "5618:44:2" + } + ], + "id": 570, + "name": "ExpressionStatement", + "src": "5618:44:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 672, + "type": "function (bytes32,address,address,string memory,string memory)", + "value": "iexecSubmitCallback" + }, + "id": 571, + "name": "Identifier", + "src": "5672:19:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 486, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 572, + "name": "Identifier", + "src": "5692:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 490, + "type": "address", + "value": "dapp" + }, + "id": 573, + "name": "Identifier", + "src": "5705:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 488, + "type": "address", + "value": "user" + }, + "id": 574, + "name": "Identifier", + "src": "5710:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 494, + "type": "string memory", + "value": "stdout" + }, + "id": 575, + "name": "Identifier", + "src": "5715:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 498, + "type": "string memory", + "value": "uri" + }, + "id": 576, + "name": "Identifier", + "src": "5722:3:2" + } + ], + "id": 577, + "name": "FunctionCall", + "src": "5672:54:2" + } + ], + "id": 578, + "name": "ExpressionStatement", + "src": "5672:54:2" + }, + { + "attributes": { + "assignments": [ + 580 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 625, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 579, + "name": "ElementaryTypeName", + "src": "5736:7:2" + } + ], + "id": 580, + "name": "VariableDeclaration", + "src": "5736:17:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "dappPrice", + "referencedDeclaration": 103, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 581, + "name": "Identifier", + "src": "5754:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 490, + "type": "address", + "value": "dapp" + }, + "id": 582, + "name": "Identifier", + "src": "5767:4:2" + } + ], + "id": 583, + "name": "IndexAccess", + "src": "5754:18:2" + } + ], + "id": 584, + "name": "MemberAccess", + "src": "5754:28:2" + } + ], + "id": 585, + "name": "VariableDeclarationStatement", + "src": "5736:46:2" + }, + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 580, + "type": "uint256", + "value": "dappPrice" + }, + "id": 586, + "name": "Identifier", + "src": "5795:9:2" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 587, + "name": "Literal", + "src": "5807:1:2" + } + ], + "id": 588, + "name": "BinaryOperation", + "src": "5795:13:2" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_enum$_StatusEnum_$31", + "typeString": "enum IexecLib.StatusEnum" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 492, + "type": "enum IexecLib.StatusEnum", + "value": "status" + }, + "id": 589, + "name": "Identifier", + "src": "5827:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "member_name": "COMPLETED", + "referencedDeclaration": null, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "StatusEnum", + "referencedDeclaration": 31, + "type": "type(enum IexecLib.StatusEnum)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 32, + "type": "type(library IexecLib)", + "value": "IexecLib" + }, + "id": 590, + "name": "Identifier", + "src": "5837:8:2" + } + ], + "id": 591, + "name": "MemberAccess", + "src": "5837:19:2" + } + ], + "id": 592, + "name": "MemberAccess", + "src": "5837:29:2" + } + ], + "id": 593, + "name": "BinaryOperation", + "src": "5827:39:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 594, + "name": "Identifier", + "src": "5885:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "rlcPayment", + "referencedDeclaration": 925, + "type": "function (address,uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 82, + "type": "contract IexecOracleEscrow", + "value": "iexecOracleEscrow" + }, + "id": 595, + "name": "Identifier", + "src": "5893:17:2" + } + ], + "id": 596, + "name": "MemberAccess", + "src": "5893:28:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "member_name": "provider", + "referencedDeclaration": 105, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "struct IexecOracle.Dapp storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 110, + "type": "mapping(address => struct IexecOracle.Dapp storage ref)", + "value": "dappRegistry" + }, + "id": 597, + "name": "Identifier", + "src": "5922:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 490, + "type": "address", + "value": "dapp" + }, + "id": 598, + "name": "Identifier", + "src": "5935:4:2" + } + ], + "id": 599, + "name": "IndexAccess", + "src": "5922:18:2" + } + ], + "id": 600, + "name": "MemberAccess", + "src": "5922:27:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 580, + "type": "uint256", + "value": "dappPrice" + }, + "id": 601, + "name": "Identifier", + "src": "5950:9:2" + } + ], + "id": 602, + "name": "FunctionCall", + "src": "5893:67:2" + } + ], + "id": 603, + "name": "FunctionCall", + "src": "5885:76:2" + } + ], + "id": 604, + "name": "ExpressionStatement", + "src": "5885:76:2" + } + ], + "id": 605, + "name": "Block", + "src": "5867:109:2" + } + ], + "id": 606, + "name": "IfStatement", + "src": "5824:152:2" + }, + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_enum$_StatusEnum_$31", + "typeString": "enum IexecLib.StatusEnum" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 492, + "type": "enum IexecLib.StatusEnum", + "value": "status" + }, + "id": 607, + "name": "Identifier", + "src": "5992:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "member_name": "ERROR", + "referencedDeclaration": null, + "type": "enum IexecLib.StatusEnum" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "StatusEnum", + "referencedDeclaration": 31, + "type": "type(enum IexecLib.StatusEnum)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 32, + "type": "type(library IexecLib)", + "value": "IexecLib" + }, + "id": 608, + "name": "Identifier", + "src": "6002:8:2" + } + ], + "id": 609, + "name": "MemberAccess", + "src": "6002:19:2" + } + ], + "id": 610, + "name": "MemberAccess", + "src": "6002:25:2" + } + ], + "id": 611, + "name": "BinaryOperation", + "src": "5992:35:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 612, + "name": "Identifier", + "src": "6046:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "rlcPayment", + "referencedDeclaration": 925, + "type": "function (address,uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 82, + "type": "contract IexecOracleEscrow", + "value": "iexecOracleEscrow" + }, + "id": 613, + "name": "Identifier", + "src": "6054:17:2" + } + ], + "id": 614, + "name": "MemberAccess", + "src": "6054:28:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 488, + "type": "address", + "value": "user" + }, + "id": 615, + "name": "Identifier", + "src": "6083:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 580, + "type": "uint256", + "value": "dappPrice" + }, + "id": 616, + "name": "Identifier", + "src": "6088:9:2" + } + ], + "id": 617, + "name": "FunctionCall", + "src": "6054:44:2" + } + ], + "id": 618, + "name": "FunctionCall", + "src": "6046:53:2" + } + ], + "id": 619, + "name": "ExpressionStatement", + "src": "6046:53:2" + } + ], + "id": 620, + "name": "Block", + "src": "6028:86:2" + } + ], + "id": 621, + "name": "IfStatement", + "src": "5989:125:2" + } + ], + "id": 622, + "name": "Block", + "src": "5810:314:2" + } + ], + "id": 623, + "name": "IfStatement", + "src": "5792:332:2" + } + ], + "id": 624, + "name": "Block", + "src": "5057:1073:2" + } + ], + "id": 625, + "name": "FunctionDefinition", + "src": "4890:1240:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "changeCallbackPrice", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_callbackPrice", + "scope": 642, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 626, + "name": "ElementaryTypeName", + "src": "6165:7:2" + } + ], + "id": 627, + "name": "VariableDeclaration", + "src": "6165:22:2" + } + ], + "id": 628, + "name": "ParameterList", + "src": "6164:24:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 629, + "name": "ParameterList", + "src": "6196:0:2" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 630, + "name": "Identifier", + "src": "6206:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 631, + "name": "Identifier", + "src": "6213:3:2" + } + ], + "id": 632, + "name": "MemberAccess", + "src": "6213:10:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 633, + "name": "Identifier", + "src": "6227:5:2" + } + ], + "id": 634, + "name": "BinaryOperation", + "src": "6213:19:2" + } + ], + "id": 635, + "name": "FunctionCall", + "src": "6206:27:2" + } + ], + "id": 636, + "name": "ExpressionStatement", + "src": "6206:27:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 84, + "type": "uint256", + "value": "callbackPrice" + }, + "id": 637, + "name": "Identifier", + "src": "6243:13:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 627, + "type": "uint256", + "value": "_callbackPrice" + }, + "id": 638, + "name": "Identifier", + "src": "6257:14:2" + } + ], + "id": 639, + "name": "Assignment", + "src": "6243:28:2" + } + ], + "id": 640, + "name": "ExpressionStatement", + "src": "6243:28:2" + } + ], + "id": 641, + "name": "Block", + "src": "6196:82:2" + } + ], + "id": 642, + "name": "FunctionDefinition", + "src": "6136:142:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "iexecSubmitCallback", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 643, + "name": "ElementaryTypeName", + "src": "6313:7:2" + } + ], + "id": 644, + "name": "VariableDeclaration", + "src": "6313:20:2" + }, + { + "attributes": { + "constant": false, + "name": "dapp", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 645, + "name": "ElementaryTypeName", + "src": "6335:7:2" + } + ], + "id": 646, + "name": "VariableDeclaration", + "src": "6335:12:2" + }, + { + "attributes": { + "constant": false, + "name": "user", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 647, + "name": "ElementaryTypeName", + "src": "6349:7:2" + } + ], + "id": 648, + "name": "VariableDeclaration", + "src": "6349:12:2" + }, + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 649, + "name": "ElementaryTypeName", + "src": "6363:6:2" + } + ], + "id": 650, + "name": "VariableDeclaration", + "src": "6363:13:2" + }, + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 651, + "name": "ElementaryTypeName", + "src": "6378:6:2" + } + ], + "id": 652, + "name": "VariableDeclaration", + "src": "6378:10:2" + } + ], + "id": 653, + "name": "ParameterList", + "src": "6312:77:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 654, + "name": "ParameterList", + "src": "6399:0:2" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 656 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "iexecOracleAPI", + "scope": 672, + "stateVariable": false, + "storageLocation": "default", + "type": "contract IexecOracleAPI", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracleAPI", + "referencedDeclaration": 794, + "type": "contract IexecOracleAPI" + }, + "id": 655, + "name": "UserDefinedTypeName", + "src": "6409:14:2" + } + ], + "id": 656, + "name": "VariableDeclaration", + "src": "6409:29:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract IexecOracleAPI", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 794, + "type": "type(contract IexecOracleAPI)", + "value": "IexecOracleAPI" + }, + "id": 657, + "name": "Identifier", + "src": "6441:14:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 646, + "type": "address", + "value": "dapp" + }, + "id": 658, + "name": "Identifier", + "src": "6456:4:2" + } + ], + "id": 659, + "name": "FunctionCall", + "src": "6441:20:2" + } + ], + "id": 660, + "name": "VariableDeclarationStatement", + "src": "6409:52:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 661, + "name": "Identifier", + "src": "6471:7:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "iexecSubmitCallback", + "referencedDeclaration": 793, + "type": "function (bytes32,address,string memory,string memory) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 656, + "type": "contract IexecOracleAPI", + "value": "iexecOracleAPI" + }, + "id": 662, + "name": "Identifier", + "src": "6479:14:2" + } + ], + "id": 663, + "name": "MemberAccess", + "src": "6479:34:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 644, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 664, + "name": "Identifier", + "src": "6514:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 648, + "type": "address", + "value": "user" + }, + "id": 665, + "name": "Identifier", + "src": "6527:4:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 650, + "type": "string memory", + "value": "stdout" + }, + "id": 666, + "name": "Identifier", + "src": "6532:6:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 652, + "type": "string memory", + "value": "uri" + }, + "id": 667, + "name": "Identifier", + "src": "6539:3:2" + } + ], + "id": 668, + "name": "FunctionCall", + "src": "6479:64:2" + } + ], + "id": 669, + "name": "FunctionCall", + "src": "6471:73:2" + } + ], + "id": 670, + "name": "ExpressionStatement", + "src": "6471:73:2" + } + ], + "id": 671, + "name": "Block", + "src": "6399:152:2" + } + ], + "id": 672, + "name": "FunctionDefinition", + "src": "6284:267:2" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "emergencyERC20Drain", + "payable": false, + "scope": 696, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "rlcTokenAddress", + "scope": 695, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 673, + "name": "ElementaryTypeName", + "src": "6670:7:2" + } + ], + "id": 674, + "name": "VariableDeclaration", + "src": "6670:23:2" + }, + { + "attributes": { + "constant": false, + "name": "amount", + "scope": 695, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 675, + "name": "ElementaryTypeName", + "src": "6695:4:2" + } + ], + "id": 676, + "name": "VariableDeclaration", + "src": "6695:11:2" + } + ], + "id": 677, + "name": "ParameterList", + "src": "6669:38:2" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 680, + "name": "ParameterList", + "src": "6725:0:2" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 678, + "name": "Identifier", + "src": "6715:9:2" + } + ], + "id": 679, + "name": "ModifierInvocation", + "src": "6715:9:2" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 682 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "rlcToken", + "scope": 695, + "stateVariable": false, + "storageLocation": "default", + "type": "contract RLC", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "RLC", + "referencedDeclaration": 1374, + "type": "contract RLC" + }, + "id": 681, + "name": "UserDefinedTypeName", + "src": "6735:3:2" + } + ], + "id": 682, + "name": "VariableDeclaration", + "src": "6735:12:2" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract RLC", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1374, + "type": "type(contract RLC)", + "value": "RLC" + }, + "id": 683, + "name": "Identifier", + "src": "6750:3:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 674, + "type": "address", + "value": "rlcTokenAddress" + }, + "id": 684, + "name": "Identifier", + "src": "6754:15:2" + } + ], + "id": 685, + "name": "FunctionCall", + "src": "6750:20:2" + } + ], + "id": 686, + "name": "VariableDeclarationStatement", + "src": "6735:35:2" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "transfer", + "referencedDeclaration": 1221, + "type": "function (address,uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 682, + "type": "contract RLC", + "value": "rlcToken" + }, + "id": 687, + "name": "Identifier", + "src": "6780:8:2" + } + ], + "id": 689, + "name": "MemberAccess", + "src": "6780:17:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 690, + "name": "Identifier", + "src": "6798:5:2" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 676, + "type": "uint256", + "value": "amount" + }, + "id": 691, + "name": "Identifier", + "src": "6805:6:2" + } + ], + "id": 692, + "name": "FunctionCall", + "src": "6780:32:2" + } + ], + "id": 693, + "name": "ExpressionStatement", + "src": "6780:32:2" + } + ], + "id": 694, + "name": "Block", + "src": "6725:94:2" + } + ], + "id": 695, + "name": "FunctionDefinition", + "src": "6641:178:2" + } + ], + "id": 696, + "name": "ContractDefinition", + "src": "206:6616:2" + } + ], + "id": 697, + "name": "SourceUnit", + "src": "0:6823:2" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.800Z" +} \ No newline at end of file diff --git a/build/contracts/IexecOracleAPI.json b/build/contracts/IexecOracleAPI.json new file mode 100644 index 0000000..ae6f050 --- /dev/null +++ b/build/contracts/IexecOracleAPI.json @@ -0,0 +1,1522 @@ +{ + "contractName": "IexecOracleAPI", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + }, + { + "name": "user", + "type": "address" + }, + { + "name": "stdout", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ], + "name": "iexecSubmitCallback", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "param", + "type": "string" + } + ], + "name": "iexecSubmit", + "outputs": [], + "payable": true, + "stateMutability": "payable", + "type": "function" + }, + { + "inputs": [ + { + "name": "_iexecOracleAddress", + "type": "address" + }, + { + "name": "dappPrice", + "type": "uint256" + }, + { + "name": "dappName", + "type": "string" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "submitTxHash", + "type": "bytes32" + }, + { + "indexed": true, + "name": "user", + "type": "address" + }, + { + "indexed": false, + "name": "stdout", + "type": "string" + }, + { + "indexed": false, + "name": "uri", + "type": "string" + } + ], + "name": "IexecSubmitCallback", + "type": "event" + } + ], + "bytecode": "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", + "deployedBytecode": "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", + "sourceMap": "88:927:3:-;;;272:292;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;426:23;397:19;378:18;;:38;;;;;;;;;;;;;;;;;;464:18;;;;;;;;;;;426:57;;501:11;:35;;;537:9;547:8;501:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;493:64:3;;;;;;;;272:292;;;;88:927;;;;;;", + "deployedSourceMap": "88:927:3:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;570:185;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252;870:4;907:18;;;;;;;;;;;893:32;;:10;:32;;;885:41;;;;;;;;969:4;936:49;;;956:12;974:6;981:3;936:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1002:4:3;995:11;;761:252;;;;;;:::o;570:185::-;630:23;668:18;;;;;;;;;;;630:57;;705:11;:18;;;730:9;741:5;705:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;697:51:3;;;;;;;;570:185;;:::o", + "source": "pragma solidity ^0.4.18;\n//v1.1.1\nimport \"./IexecOracle.sol\";\nimport './IexecLib.sol';\n\ncontract IexecOracleAPI{\n\n\n address iexecOracleAddress;\n event IexecSubmitCallback(bytes32 submitTxHash, address indexed user, string stdout, string uri);\n\n //constructor\n function IexecOracleAPI(address _iexecOracleAddress, uint256 dappPrice, string dappName) public {\n iexecOracleAddress=_iexecOracleAddress;\n IexecOracle iexecOracle = IexecOracle(iexecOracleAddress);\n require(iexecOracle.registerDappAndProvider(dappPrice,dappName));\n }\n\n function iexecSubmit(string param) payable public {\n IexecOracle iexecOracle = IexecOracle(iexecOracleAddress);\n require(iexecOracle.submit.value(msg.value)(param));\n }\n\n function iexecSubmitCallback(bytes32 submitTxHash, address user, string stdout, string uri) public returns (bool){\n require(msg.sender == iexecOracleAddress);\n IexecSubmitCallback(submitTxHash,user,stdout,uri);\n return true;\n }\n}\n", + "sourcePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "ast": { + "attributes": { + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "exportedSymbols": { + "IexecOracleAPI": [ + 794 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".18" + ] + }, + "id": 698, + "name": "PragmaDirective", + "src": "0:24:3" + }, + { + "attributes": { + "SourceUnit": 697, + "absolutePath": "iexec-oracle-contract/contracts/IexecOracle.sol", + "file": "./IexecOracle.sol", + "scope": 795, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 699, + "name": "ImportDirective", + "src": "34:27:3" + }, + { + "attributes": { + "SourceUnit": 33, + "absolutePath": "iexec-oracle-contract/contracts/IexecLib.sol", + "file": "./IexecLib.sol", + "scope": 795, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 700, + "name": "ImportDirective", + "src": "62:24:3" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 794 + ], + "name": "IexecOracleAPI", + "scope": 795 + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "iexecOracleAddress", + "scope": 794, + "stateVariable": true, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 701, + "name": "ElementaryTypeName", + "src": "119:7:3" + } + ], + "id": 702, + "name": "VariableDeclaration", + "src": "119:26:3" + }, + { + "attributes": { + "anonymous": false, + "name": "IexecSubmitCallback" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "indexed": false, + "name": "submitTxHash", + "scope": 712, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 703, + "name": "ElementaryTypeName", + "src": "177:7:3" + } + ], + "id": 704, + "name": "VariableDeclaration", + "src": "177:20:3" + }, + { + "attributes": { + "constant": false, + "indexed": true, + "name": "user", + "scope": 712, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 705, + "name": "ElementaryTypeName", + "src": "199:7:3" + } + ], + "id": 706, + "name": "VariableDeclaration", + "src": "199:20:3" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "stdout", + "scope": 712, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 707, + "name": "ElementaryTypeName", + "src": "221:6:3" + } + ], + "id": 708, + "name": "VariableDeclaration", + "src": "221:13:3" + }, + { + "attributes": { + "constant": false, + "indexed": false, + "name": "uri", + "scope": 712, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 709, + "name": "ElementaryTypeName", + "src": "236:6:3" + } + ], + "id": 710, + "name": "VariableDeclaration", + "src": "236:10:3" + } + ], + "id": 711, + "name": "ParameterList", + "src": "176:71:3" + } + ], + "id": 712, + "name": "EventDefinition", + "src": "151:97:3" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "modifiers": [ + null + ], + "name": "IexecOracleAPI", + "payable": false, + "scope": 794, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_iexecOracleAddress", + "scope": 740, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 713, + "name": "ElementaryTypeName", + "src": "296:7:3" + } + ], + "id": 714, + "name": "VariableDeclaration", + "src": "296:27:3" + }, + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 740, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 715, + "name": "ElementaryTypeName", + "src": "325:7:3" + } + ], + "id": 716, + "name": "VariableDeclaration", + "src": "325:17:3" + }, + { + "attributes": { + "constant": false, + "name": "dappName", + "scope": 740, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 717, + "name": "ElementaryTypeName", + "src": "344:6:3" + } + ], + "id": 718, + "name": "VariableDeclaration", + "src": "344:15:3" + } + ], + "id": 719, + "name": "ParameterList", + "src": "295:65:3" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 720, + "name": "ParameterList", + "src": "368:0:3" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 702, + "type": "address", + "value": "iexecOracleAddress" + }, + "id": 721, + "name": "Identifier", + "src": "378:18:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 714, + "type": "address", + "value": "_iexecOracleAddress" + }, + "id": 722, + "name": "Identifier", + "src": "397:19:3" + } + ], + "id": 723, + "name": "Assignment", + "src": "378:38:3" + } + ], + "id": 724, + "name": "ExpressionStatement", + "src": "378:38:3" + }, + { + "attributes": { + "assignments": [ + 726 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "iexecOracle", + "scope": 740, + "stateVariable": false, + "storageLocation": "default", + "type": "contract IexecOracle", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracle", + "referencedDeclaration": 696, + "type": "contract IexecOracle" + }, + "id": 725, + "name": "UserDefinedTypeName", + "src": "426:11:3" + } + ], + "id": 726, + "name": "VariableDeclaration", + "src": "426:23:3" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract IexecOracle", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 696, + "type": "type(contract IexecOracle)", + "value": "IexecOracle" + }, + "id": 727, + "name": "Identifier", + "src": "452:11:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 702, + "type": "address", + "value": "iexecOracleAddress" + }, + "id": 728, + "name": "Identifier", + "src": "464:18:3" + } + ], + "id": 729, + "name": "FunctionCall", + "src": "452:31:3" + } + ], + "id": 730, + "name": "VariableDeclarationStatement", + "src": "426:57:3" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 731, + "name": "Identifier", + "src": "493:7:3" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "registerDappAndProvider", + "referencedDeclaration": 260, + "type": "function (uint256,string memory) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 726, + "type": "contract IexecOracle", + "value": "iexecOracle" + }, + "id": 732, + "name": "Identifier", + "src": "501:11:3" + } + ], + "id": 733, + "name": "MemberAccess", + "src": "501:35:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 716, + "type": "uint256", + "value": "dappPrice" + }, + "id": 734, + "name": "Identifier", + "src": "537:9:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 718, + "type": "string memory", + "value": "dappName" + }, + "id": 735, + "name": "Identifier", + "src": "547:8:3" + } + ], + "id": 736, + "name": "FunctionCall", + "src": "501:55:3" + } + ], + "id": 737, + "name": "FunctionCall", + "src": "493:64:3" + } + ], + "id": 738, + "name": "ExpressionStatement", + "src": "493:64:3" + } + ], + "id": 739, + "name": "Block", + "src": "368:196:3" + } + ], + "id": 740, + "name": "FunctionDefinition", + "src": "272:292:3" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "iexecSubmit", + "payable": true, + "scope": 794, + "stateMutability": "payable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "param", + "scope": 763, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 741, + "name": "ElementaryTypeName", + "src": "591:6:3" + } + ], + "id": 742, + "name": "VariableDeclaration", + "src": "591:12:3" + } + ], + "id": 743, + "name": "ParameterList", + "src": "590:14:3" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 744, + "name": "ParameterList", + "src": "620:0:3" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 746 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "iexecOracle", + "scope": 763, + "stateVariable": false, + "storageLocation": "default", + "type": "contract IexecOracle", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracle", + "referencedDeclaration": 696, + "type": "contract IexecOracle" + }, + "id": 745, + "name": "UserDefinedTypeName", + "src": "630:11:3" + } + ], + "id": 746, + "name": "VariableDeclaration", + "src": "630:23:3" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract IexecOracle", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 696, + "type": "type(contract IexecOracle)", + "value": "IexecOracle" + }, + "id": 747, + "name": "Identifier", + "src": "656:11:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 702, + "type": "address", + "value": "iexecOracleAddress" + }, + "id": 748, + "name": "Identifier", + "src": "668:18:3" + } + ], + "id": 749, + "name": "FunctionCall", + "src": "656:31:3" + } + ], + "id": 750, + "name": "VariableDeclarationStatement", + "src": "630:57:3" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 751, + "name": "Identifier", + "src": "697:7:3" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "function (string memory) payable external returns (bool)", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "value", + "referencedDeclaration": null, + "type": "function (uint256) returns (function (string memory) payable external returns (bool))" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "submit", + "referencedDeclaration": 484, + "type": "function (string memory) payable external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 746, + "type": "contract IexecOracle", + "value": "iexecOracle" + }, + "id": 752, + "name": "Identifier", + "src": "705:11:3" + } + ], + "id": 753, + "name": "MemberAccess", + "src": "705:18:3" + } + ], + "id": 754, + "name": "MemberAccess", + "src": "705:24:3" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "value", + "referencedDeclaration": null, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 755, + "name": "Identifier", + "src": "730:3:3" + } + ], + "id": 756, + "name": "MemberAccess", + "src": "730:9:3" + } + ], + "id": 757, + "name": "FunctionCall", + "src": "705:35:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 742, + "type": "string memory", + "value": "param" + }, + "id": 758, + "name": "Identifier", + "src": "741:5:3" + } + ], + "id": 759, + "name": "FunctionCall", + "src": "705:42:3" + } + ], + "id": 760, + "name": "FunctionCall", + "src": "697:51:3" + } + ], + "id": 761, + "name": "ExpressionStatement", + "src": "697:51:3" + } + ], + "id": 762, + "name": "Block", + "src": "620:135:3" + } + ], + "id": 763, + "name": "FunctionDefinition", + "src": "570:185:3" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "iexecSubmitCallback", + "payable": false, + "scope": 794, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "submitTxHash", + "scope": 793, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes32", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes32", + "type": "bytes32" + }, + "id": 764, + "name": "ElementaryTypeName", + "src": "790:7:3" + } + ], + "id": 765, + "name": "VariableDeclaration", + "src": "790:20:3" + }, + { + "attributes": { + "constant": false, + "name": "user", + "scope": 793, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 766, + "name": "ElementaryTypeName", + "src": "812:7:3" + } + ], + "id": 767, + "name": "VariableDeclaration", + "src": "812:12:3" + }, + { + "attributes": { + "constant": false, + "name": "stdout", + "scope": 793, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 768, + "name": "ElementaryTypeName", + "src": "826:6:3" + } + ], + "id": 769, + "name": "VariableDeclaration", + "src": "826:13:3" + }, + { + "attributes": { + "constant": false, + "name": "uri", + "scope": 793, + "stateVariable": false, + "storageLocation": "default", + "type": "string memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 770, + "name": "ElementaryTypeName", + "src": "841:6:3" + } + ], + "id": 771, + "name": "VariableDeclaration", + "src": "841:10:3" + } + ], + "id": 772, + "name": "ParameterList", + "src": "789:63:3" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 793, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 773, + "name": "ElementaryTypeName", + "src": "870:4:3" + } + ], + "id": 774, + "name": "VariableDeclaration", + "src": "870:4:3" + } + ], + "id": 775, + "name": "ParameterList", + "src": "869:6:3" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 776, + "name": "Identifier", + "src": "885:7:3" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 777, + "name": "Identifier", + "src": "893:3:3" + } + ], + "id": 778, + "name": "MemberAccess", + "src": "893:10:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 702, + "type": "address", + "value": "iexecOracleAddress" + }, + "id": 779, + "name": "Identifier", + "src": "907:18:3" + } + ], + "id": 780, + "name": "BinaryOperation", + "src": "893:32:3" + } + ], + "id": 781, + "name": "FunctionCall", + "src": "885:41:3" + } + ], + "id": 782, + "name": "ExpressionStatement", + "src": "885:41:3" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bytes32", + "typeString": "bytes32" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + }, + { + "typeIdentifier": "t_string_memory_ptr", + "typeString": "string memory" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 712, + "type": "function (bytes32,address,string memory,string memory)", + "value": "IexecSubmitCallback" + }, + "id": 783, + "name": "Identifier", + "src": "936:19:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 765, + "type": "bytes32", + "value": "submitTxHash" + }, + "id": 784, + "name": "Identifier", + "src": "956:12:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 767, + "type": "address", + "value": "user" + }, + "id": 785, + "name": "Identifier", + "src": "969:4:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 769, + "type": "string memory", + "value": "stdout" + }, + "id": 786, + "name": "Identifier", + "src": "974:6:3" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 771, + "type": "string memory", + "value": "uri" + }, + "id": 787, + "name": "Identifier", + "src": "981:3:3" + } + ], + "id": 788, + "name": "FunctionCall", + "src": "936:49:3" + } + ], + "id": 789, + "name": "ExpressionStatement", + "src": "936:49:3" + }, + { + "attributes": { + "functionReturnParameters": 775 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 790, + "name": "Literal", + "src": "1002:4:3" + } + ], + "id": 791, + "name": "Return", + "src": "995:11:3" + } + ], + "id": 792, + "name": "Block", + "src": "875:138:3" + } + ], + "id": 793, + "name": "FunctionDefinition", + "src": "761:252:3" + } + ], + "id": 794, + "name": "ContractDefinition", + "src": "88:927:3" + } + ], + "id": 795, + "name": "SourceUnit", + "src": "0:1016:3" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.802Z" +} \ No newline at end of file diff --git a/build/contracts/IexecOracleEscrow.json b/build/contracts/IexecOracleEscrow.json new file mode 100644 index 0000000..f5bd8d3 --- /dev/null +++ b/build/contracts/IexecOracleEscrow.json @@ -0,0 +1,2125 @@ +{ + "contractName": "IexecOracleEscrow", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "targets", + "type": "address[]" + }, + { + "name": "isRegistered", + "type": "bool" + } + ], + "name": "changeIexecOracleRegistrationStatuses", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "rlcToken", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "owner", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "", + "type": "address" + } + ], + "name": "iexecOracleRegistered", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "target", + "type": "address" + }, + { + "name": "isRegistered", + "type": "bool" + } + ], + "name": "changeIexecOracleRegistrationStatus", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "target", + "type": "address" + } + ], + "name": "isIexecOracleRegistered", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "dappPrice", + "type": "uint256" + } + ], + "name": "rlcDeposit", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "beneficiary", + "type": "address" + }, + { + "name": "dappPrice", + "type": "uint256" + } + ], + "name": "rlcPayment", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { + "name": "_tokenAddress", + "type": "address" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + } + ], + "bytecode": "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", + "deployedBytecode": "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", + "sourceMap": "116:1334:4:-;;;402:103;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;104:10:6;96:5;;:18;;;;;;;;;;;;;;;;;;484:13:4;469:8;;:29;;;;;;;;;;;;;;;;;;402:103;116:1334;;;;;;", + "deployedSourceMap": "116:1334:4:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;675:246;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;161:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46:20:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;187:51:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;511:158;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1317:130;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;927:182;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1115:196;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;191:110:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;675:246:4;792:6;168:5:6;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;801:1:4;792:10;;787:128;808:7;:14;804:1;:18;787:128;;;843:61;879:7;887:1;879:10;;;;;;;;;;;;;;;;;;891:12;843:35;:61::i;:::-;824:3;;;;;;;787:128;;;150:32:6;675:246:4;;;:::o;161:19::-;;;;;;;;;;;;;:::o;46:20:6:-;;;;;;;;;;;;;:::o;187:51:4:-;;;;;;;;;;;;;;;;;;;;;;:::o;511:158::-;168:5:6;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;650:12:4;618:21;:29;640:6;618:29;;;;;;;;;;;;;;;;:44;;;;;;;;;;;;;;;;;;150:32:6;511:158:4;;:::o;1317:130::-;1391:4;1411:21;:29;1433:6;1411:29;;;;;;;;;;;;;;;;;;;;;;;;;1404:36;;1317:130;;;:::o;927:182::-;1010:4;301:21;:33;323:10;301:33;;;;;;;;;;;;;;;;;;;;;;;;;:57;;;;353:5;;;;;;;;;;;339:19;;:10;:19;;;301:57;293:67;;;;;;1033:8;;;;;;;;;;;:21;;;1055:9;1065:4;1070:9;1033:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1025:56;;;;;;;;1098:4;1091:11;;927:182;;;:::o;1115:196::-;1219:4;301:21;:33;323:10;301:33;;;;;;;;;;;;;;;;;;;;;;;;;:57;;;;353:5;;;;;;;;;;;339:19;;:10;:19;;;301:57;293:67;;;;;;1242:8;;;;;;;;;;;:17;;;1260:11;1272:9;1242:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1234:49;;;;;;;;1300:4;1293:11;;1115:196;;;;:::o;191:110:6:-;168:5;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;276:1;256:22;;:8;:22;;;;252:44;;;288:8;280:5;;:16;;;;;;;;;;;;;;;;;;252:44;150:32;191:110;:::o", + "source": "pragma solidity ^0.4.18;\n//v1.1.1\nimport \"rlc-token/contracts/RLC.sol\";\nimport \"rlc-token/contracts/Ownable.sol\";\n\n\ncontract IexecOracleEscrow is Ownable {\n\n RLC public rlcToken;\n\n mapping(address=>bool) public iexecOracleRegistered;\n\n modifier onlyOwnerOrOracleRegistered(){\n assert( iexecOracleRegistered[msg.sender] || msg.sender == owner );\n _;\n }\n\n //constructor\n function IexecOracleEscrow(address _tokenAddress) public {\n rlcToken = RLC(_tokenAddress);\n }\n\n function changeIexecOracleRegistrationStatus(address target, bool isRegistered) public onlyOwner {\n iexecOracleRegistered[target] = isRegistered;\n }\n\n function changeIexecOracleRegistrationStatuses(address[] targets, bool isRegistered) public onlyOwner {\n for (uint i = 0; i < targets.length; i++) {\n changeIexecOracleRegistrationStatus(targets[i], isRegistered);\n }\n }\n\n function rlcDeposit(uint256 dappPrice) public onlyOwnerOrOracleRegistered returns (bool){\n require(rlcToken.transferFrom(tx.origin,this,dappPrice));\n return true;\n }\n\n function rlcPayment(address beneficiary ,uint256 dappPrice) public onlyOwnerOrOracleRegistered returns (bool){\n require(rlcToken.transfer(beneficiary,dappPrice));\n return true;\n }\n\n function isIexecOracleRegistered(address target) constant public returns (bool){\n return iexecOracleRegistered[target];\n }\n\n}\n", + "sourcePath": "iexec-oracle-contract/contracts/IexecOracleEscrow.sol", + "ast": { + "attributes": { + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleEscrow.sol", + "exportedSymbols": { + "IexecOracleEscrow": [ + 938 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".18" + ] + }, + "id": 796, + "name": "PragmaDirective", + "src": "0:24:4" + }, + { + "attributes": { + "SourceUnit": 1375, + "absolutePath": "rlc-token/contracts/RLC.sol", + "file": "rlc-token/contracts/RLC.sol", + "scope": 939, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 797, + "name": "ImportDirective", + "src": "34:37:4" + }, + { + "attributes": { + "SourceUnit": 1046, + "absolutePath": "rlc-token/contracts/Ownable.sol", + "file": "rlc-token/contracts/Ownable.sol", + "scope": 939, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 798, + "name": "ImportDirective", + "src": "72:41:4" + }, + { + "attributes": { + "contractDependencies": [ + 1045 + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 938, + 1045 + ], + "name": "IexecOracleEscrow", + "scope": 939 + }, + "children": [ + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "Ownable", + "referencedDeclaration": 1045, + "type": "contract Ownable" + }, + "id": 799, + "name": "UserDefinedTypeName", + "src": "146:7:4" + } + ], + "id": 800, + "name": "InheritanceSpecifier", + "src": "146:7:4" + }, + { + "attributes": { + "constant": false, + "name": "rlcToken", + "scope": 938, + "stateVariable": true, + "storageLocation": "default", + "type": "contract RLC", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "RLC", + "referencedDeclaration": 1374, + "type": "contract RLC" + }, + "id": 801, + "name": "UserDefinedTypeName", + "src": "161:3:4" + } + ], + "id": 802, + "name": "VariableDeclaration", + "src": "161:19:4" + }, + { + "attributes": { + "constant": false, + "name": "iexecOracleRegistered", + "scope": 938, + "stateVariable": true, + "storageLocation": "default", + "type": "mapping(address => bool)", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "type": "mapping(address => bool)" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 803, + "name": "ElementaryTypeName", + "src": "195:7:4" + }, + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 804, + "name": "ElementaryTypeName", + "src": "204:4:4" + } + ], + "id": 805, + "name": "Mapping", + "src": "187:22:4" + } + ], + "id": 806, + "name": "VariableDeclaration", + "src": "187:51:4" + }, + { + "attributes": { + "name": "onlyOwnerOrOracleRegistered", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 807, + "name": "ParameterList", + "src": "281:2:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1587, + "type": "function (bool) pure", + "value": "assert" + }, + "id": 808, + "name": "Identifier", + "src": "293:6:4" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "||", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 806, + "type": "mapping(address => bool)", + "value": "iexecOracleRegistered" + }, + "id": 809, + "name": "Identifier", + "src": "301:21:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 810, + "name": "Identifier", + "src": "323:3:4" + } + ], + "id": 811, + "name": "MemberAccess", + "src": "323:10:4" + } + ], + "id": 812, + "name": "IndexAccess", + "src": "301:33:4" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 813, + "name": "Identifier", + "src": "339:3:4" + } + ], + "id": 814, + "name": "MemberAccess", + "src": "339:10:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 815, + "name": "Identifier", + "src": "353:5:4" + } + ], + "id": 816, + "name": "BinaryOperation", + "src": "339:19:4" + } + ], + "id": 817, + "name": "BinaryOperation", + "src": "301:57:4" + } + ], + "id": 818, + "name": "FunctionCall", + "src": "293:67:4" + } + ], + "id": 819, + "name": "ExpressionStatement", + "src": "293:67:4" + }, + { + "id": 820, + "name": "PlaceholderStatement", + "src": "370:1:4" + } + ], + "id": 821, + "name": "Block", + "src": "283:95:4" + } + ], + "id": 822, + "name": "ModifierDefinition", + "src": "245:133:4" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "modifiers": [ + null + ], + "name": "IexecOracleEscrow", + "payable": false, + "scope": 938, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_tokenAddress", + "scope": 834, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 823, + "name": "ElementaryTypeName", + "src": "429:7:4" + } + ], + "id": 824, + "name": "VariableDeclaration", + "src": "429:21:4" + } + ], + "id": 825, + "name": "ParameterList", + "src": "428:23:4" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 826, + "name": "ParameterList", + "src": "459:0:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "contract RLC" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 802, + "type": "contract RLC", + "value": "rlcToken" + }, + "id": 827, + "name": "Identifier", + "src": "469:8:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract RLC", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1374, + "type": "type(contract RLC)", + "value": "RLC" + }, + "id": 828, + "name": "Identifier", + "src": "480:3:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 824, + "type": "address", + "value": "_tokenAddress" + }, + "id": 829, + "name": "Identifier", + "src": "484:13:4" + } + ], + "id": 830, + "name": "FunctionCall", + "src": "480:18:4" + } + ], + "id": 831, + "name": "Assignment", + "src": "469:29:4" + } + ], + "id": 832, + "name": "ExpressionStatement", + "src": "469:29:4" + } + ], + "id": 833, + "name": "Block", + "src": "459:46:4" + } + ], + "id": 834, + "name": "FunctionDefinition", + "src": "402:103:4" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "changeIexecOracleRegistrationStatus", + "payable": false, + "scope": 938, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "target", + "scope": 850, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 835, + "name": "ElementaryTypeName", + "src": "556:7:4" + } + ], + "id": 836, + "name": "VariableDeclaration", + "src": "556:14:4" + }, + { + "attributes": { + "constant": false, + "name": "isRegistered", + "scope": 850, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 837, + "name": "ElementaryTypeName", + "src": "572:4:4" + } + ], + "id": 838, + "name": "VariableDeclaration", + "src": "572:17:4" + } + ], + "id": 839, + "name": "ParameterList", + "src": "555:35:4" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 842, + "name": "ParameterList", + "src": "608:0:4" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 840, + "name": "Identifier", + "src": "598:9:4" + } + ], + "id": 841, + "name": "ModifierInvocation", + "src": "598:9:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 806, + "type": "mapping(address => bool)", + "value": "iexecOracleRegistered" + }, + "id": 843, + "name": "Identifier", + "src": "618:21:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 836, + "type": "address", + "value": "target" + }, + "id": 844, + "name": "Identifier", + "src": "640:6:4" + } + ], + "id": 845, + "name": "IndexAccess", + "src": "618:29:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 838, + "type": "bool", + "value": "isRegistered" + }, + "id": 846, + "name": "Identifier", + "src": "650:12:4" + } + ], + "id": 847, + "name": "Assignment", + "src": "618:44:4" + } + ], + "id": 848, + "name": "ExpressionStatement", + "src": "618:44:4" + } + ], + "id": 849, + "name": "Block", + "src": "608:61:4" + } + ], + "id": 850, + "name": "FunctionDefinition", + "src": "511:158:4" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "changeIexecOracleRegistrationStatuses", + "payable": false, + "scope": 938, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "targets", + "scope": 881, + "stateVariable": false, + "storageLocation": "default", + "type": "address[] memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "length": null, + "type": "address[] storage pointer" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 851, + "name": "ElementaryTypeName", + "src": "722:7:4" + } + ], + "id": 852, + "name": "ArrayTypeName", + "src": "722:9:4" + } + ], + "id": 853, + "name": "VariableDeclaration", + "src": "722:17:4" + }, + { + "attributes": { + "constant": false, + "name": "isRegistered", + "scope": 881, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 854, + "name": "ElementaryTypeName", + "src": "741:4:4" + } + ], + "id": 855, + "name": "VariableDeclaration", + "src": "741:17:4" + } + ], + "id": 856, + "name": "ParameterList", + "src": "721:38:4" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 859, + "name": "ParameterList", + "src": "777:0:4" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 857, + "name": "Identifier", + "src": "767:9:4" + } + ], + "id": 858, + "name": "ModifierInvocation", + "src": "767:9:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "assignments": [ + 861 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "i", + "scope": 881, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 860, + "name": "ElementaryTypeName", + "src": "792:4:4" + } + ], + "id": 861, + "name": "VariableDeclaration", + "src": "792:6:4" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 862, + "name": "Literal", + "src": "801:1:4" + } + ], + "id": 863, + "name": "VariableDeclarationStatement", + "src": "792:10:4" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "<", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 861, + "type": "uint256", + "value": "i" + }, + "id": 864, + "name": "Identifier", + "src": "804:1:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "length", + "referencedDeclaration": null, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 853, + "type": "address[] memory", + "value": "targets" + }, + "id": 865, + "name": "Identifier", + "src": "808:7:4" + } + ], + "id": 866, + "name": "MemberAccess", + "src": "808:14:4" + } + ], + "id": 867, + "name": "BinaryOperation", + "src": "804:18:4" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "++", + "prefix": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 861, + "type": "uint256", + "value": "i" + }, + "id": 868, + "name": "Identifier", + "src": "824:1:4" + } + ], + "id": 869, + "name": "UnaryOperation", + "src": "824:3:4" + } + ], + "id": 870, + "name": "ExpressionStatement", + "src": "824:3:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 850, + "type": "function (address,bool)", + "value": "changeIexecOracleRegistrationStatus" + }, + "id": 871, + "name": "Identifier", + "src": "843:35:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 853, + "type": "address[] memory", + "value": "targets" + }, + "id": 872, + "name": "Identifier", + "src": "879:7:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 861, + "type": "uint256", + "value": "i" + }, + "id": 873, + "name": "Identifier", + "src": "887:1:4" + } + ], + "id": 874, + "name": "IndexAccess", + "src": "879:10:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 855, + "type": "bool", + "value": "isRegistered" + }, + "id": 875, + "name": "Identifier", + "src": "891:12:4" + } + ], + "id": 876, + "name": "FunctionCall", + "src": "843:61:4" + } + ], + "id": 877, + "name": "ExpressionStatement", + "src": "843:61:4" + } + ], + "id": 878, + "name": "Block", + "src": "829:86:4" + } + ], + "id": 879, + "name": "ForStatement", + "src": "787:128:4" + } + ], + "id": 880, + "name": "Block", + "src": "777:144:4" + } + ], + "id": 881, + "name": "FunctionDefinition", + "src": "675:246:4" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "rlcDeposit", + "payable": false, + "scope": 938, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 903, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 882, + "name": "ElementaryTypeName", + "src": "947:7:4" + } + ], + "id": 883, + "name": "VariableDeclaration", + "src": "947:17:4" + } + ], + "id": 884, + "name": "ParameterList", + "src": "946:19:4" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 903, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 887, + "name": "ElementaryTypeName", + "src": "1010:4:4" + } + ], + "id": 888, + "name": "VariableDeclaration", + "src": "1010:4:4" + } + ], + "id": 889, + "name": "ParameterList", + "src": "1009:6:4" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 822, + "type": "modifier ()", + "value": "onlyOwnerOrOracleRegistered" + }, + "id": 885, + "name": "Identifier", + "src": "973:27:4" + } + ], + "id": 886, + "name": "ModifierInvocation", + "src": "973:27:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 890, + "name": "Identifier", + "src": "1025:7:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_contract$_IexecOracleEscrow_$938", + "typeString": "contract IexecOracleEscrow" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "transferFrom", + "referencedDeclaration": 1285, + "type": "function (address,address,uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 802, + "type": "contract RLC", + "value": "rlcToken" + }, + "id": 891, + "name": "Identifier", + "src": "1033:8:4" + } + ], + "id": 892, + "name": "MemberAccess", + "src": "1033:21:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "origin", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1606, + "type": "tx", + "value": "tx" + }, + "id": 893, + "name": "Identifier", + "src": "1055:2:4" + } + ], + "id": 894, + "name": "MemberAccess", + "src": "1055:9:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1617, + "type": "contract IexecOracleEscrow", + "value": "this" + }, + "id": 895, + "name": "Identifier", + "src": "1065:4:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 883, + "type": "uint256", + "value": "dappPrice" + }, + "id": 896, + "name": "Identifier", + "src": "1070:9:4" + } + ], + "id": 897, + "name": "FunctionCall", + "src": "1033:47:4" + } + ], + "id": 898, + "name": "FunctionCall", + "src": "1025:56:4" + } + ], + "id": 899, + "name": "ExpressionStatement", + "src": "1025:56:4" + }, + { + "attributes": { + "functionReturnParameters": 889 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 900, + "name": "Literal", + "src": "1098:4:4" + } + ], + "id": 901, + "name": "Return", + "src": "1091:11:4" + } + ], + "id": 902, + "name": "Block", + "src": "1015:94:4" + } + ], + "id": 903, + "name": "FunctionDefinition", + "src": "927:182:4" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "rlcPayment", + "payable": false, + "scope": 938, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "beneficiary", + "scope": 925, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 904, + "name": "ElementaryTypeName", + "src": "1135:7:4" + } + ], + "id": 905, + "name": "VariableDeclaration", + "src": "1135:19:4" + }, + { + "attributes": { + "constant": false, + "name": "dappPrice", + "scope": 925, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 906, + "name": "ElementaryTypeName", + "src": "1156:7:4" + } + ], + "id": 907, + "name": "VariableDeclaration", + "src": "1156:17:4" + } + ], + "id": 908, + "name": "ParameterList", + "src": "1134:40:4" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 925, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 911, + "name": "ElementaryTypeName", + "src": "1219:4:4" + } + ], + "id": 912, + "name": "VariableDeclaration", + "src": "1219:4:4" + } + ], + "id": 913, + "name": "ParameterList", + "src": "1218:6:4" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 822, + "type": "modifier ()", + "value": "onlyOwnerOrOracleRegistered" + }, + "id": 909, + "name": "Identifier", + "src": "1182:27:4" + } + ], + "id": 910, + "name": "ModifierInvocation", + "src": "1182:27:4" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1599, + "type": "function (bool) pure", + "value": "require" + }, + "id": 914, + "name": "Identifier", + "src": "1234:7:4" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "transfer", + "referencedDeclaration": 1221, + "type": "function (address,uint256) external returns (bool)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 802, + "type": "contract RLC", + "value": "rlcToken" + }, + "id": 915, + "name": "Identifier", + "src": "1242:8:4" + } + ], + "id": 916, + "name": "MemberAccess", + "src": "1242:17:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 905, + "type": "address", + "value": "beneficiary" + }, + "id": 917, + "name": "Identifier", + "src": "1260:11:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 907, + "type": "uint256", + "value": "dappPrice" + }, + "id": 918, + "name": "Identifier", + "src": "1272:9:4" + } + ], + "id": 919, + "name": "FunctionCall", + "src": "1242:40:4" + } + ], + "id": 920, + "name": "FunctionCall", + "src": "1234:49:4" + } + ], + "id": 921, + "name": "ExpressionStatement", + "src": "1234:49:4" + }, + { + "attributes": { + "functionReturnParameters": 913 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 922, + "name": "Literal", + "src": "1300:4:4" + } + ], + "id": 923, + "name": "Return", + "src": "1293:11:4" + } + ], + "id": 924, + "name": "Block", + "src": "1224:87:4" + } + ], + "id": 925, + "name": "FunctionDefinition", + "src": "1115:196:4" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "isIexecOracleRegistered", + "payable": false, + "scope": 938, + "stateMutability": "view", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "target", + "scope": 937, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 926, + "name": "ElementaryTypeName", + "src": "1350:7:4" + } + ], + "id": 927, + "name": "VariableDeclaration", + "src": "1350:14:4" + } + ], + "id": 928, + "name": "ParameterList", + "src": "1349:16:4" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 937, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 929, + "name": "ElementaryTypeName", + "src": "1391:4:4" + } + ], + "id": 930, + "name": "VariableDeclaration", + "src": "1391:4:4" + } + ], + "id": 931, + "name": "ParameterList", + "src": "1390:6:4" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 931 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 806, + "type": "mapping(address => bool)", + "value": "iexecOracleRegistered" + }, + "id": 932, + "name": "Identifier", + "src": "1411:21:4" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 927, + "type": "address", + "value": "target" + }, + "id": 933, + "name": "Identifier", + "src": "1433:6:4" + } + ], + "id": 934, + "name": "IndexAccess", + "src": "1411:29:4" + } + ], + "id": 935, + "name": "Return", + "src": "1404:36:4" + } + ], + "id": 936, + "name": "Block", + "src": "1396:51:4" + } + ], + "id": 937, + "name": "FunctionDefinition", + "src": "1317:130:4" + } + ], + "id": 938, + "name": "ContractDefinition", + "src": "116:1334:4" + } + ], + "id": 939, + "name": "SourceUnit", + "src": "0:1451:4" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.802Z" +} \ No newline at end of file diff --git a/build/contracts/OpenMOLEPi.json b/build/contracts/OpenMOLEPi.json new file mode 100644 index 0000000..925222a --- /dev/null +++ b/build/contracts/OpenMOLEPi.json @@ -0,0 +1,440 @@ +{ + "contractName": "OpenMOLEPi", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "submitTxHash", + "type": "bytes32" + }, + { + "name": "user", + "type": "address" + }, + { + "name": "stdout", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ], + "name": "iexecSubmitCallback", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "DAPP_PRICE", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "param", + "type": "string" + } + ], + "name": "iexecSubmit", + "outputs": [], + "payable": true, + "stateMutability": "payable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "DAPP_NAME", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "_iexecOracleAddress", + "type": "address" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": false, + "name": "submitTxHash", + "type": "bytes32" + }, + { + "indexed": true, + "name": "user", + "type": "address" + }, + { + "indexed": false, + "name": "stdout", + "type": "string" + }, + { + "indexed": false, + "name": "uri", + "type": "string" + } + ], + "name": "IexecSubmitCallback", + "type": "event" + } + ], + "bytecode": "0x6060604052341561000f57600080fd5b60405160208061076c833981016040528080519060200190919050508060006040805190810160405280600a81526020017f6f70656e6d6f6c657069000000000000000000000000000000000000000000008152506000836000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508073ffffffffffffffffffffffffffffffffffffffff16635993ef5384846000604051602001526040518363ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018083815260200180602001828103825283818151815260200191508051906020019080838360005b83811015610162578082015181840152602081019050610147565b50505050905090810190601f16801561018f5780820380516001836020036101000a031916815260200191505b509350505050602060405180830381600087803b15156101ae57600080fd5b6102c65a03f115156101bf57600080fd5b5050506040518051905015156101d457600080fd5b5050505050610584806101e86000396000f300606060405260043610610062576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806310a9f201146100675780633c0aef301461014b5780638cd213b914610174578063c878f958146101c6575b600080fd5b341561007257600080fd5b61013160048080356000191690602001909190803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803590602001908201803590602001908080601f0160208091040260200160405190810160405280939291908181526020018383808284378201915050505050509190803590602001908201803590602001908080601f01602080910402602001604051908101604052809392919081815260200183838082843782019150505050505091905050610254565b604051808215151515815260200191505060405180910390f35b341561015657600080fd5b61015e6103ed565b6040518082815260200191505060405180910390f35b6101c4600480803590602001908201803590602001908080601f016020809104026020016040519081016040528093929190818152602001838380828437820191505050505050919050506103f2565b005b34156101d157600080fd5b6101d961051f565b6040518080602001828103825283818151815260200191508051906020019080838360005b838110156102195780820151818401526020810190506101fe565b50505050905090810190601f1680156102465780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415156102b157600080fd5b8373ffffffffffffffffffffffffffffffffffffffff167f68d2eaa37ea3e53bbe55f11eb038084f280086b8f4c4552dbca1b5692efeb9138685856040518084600019166000191681526020018060200180602001838103835285818151815260200191508051906020019080838360005b8381101561033e578082015181840152602081019050610323565b50505050905090810190601f16801561036b5780820380516001836020036101000a031916815260200191505b50838103825284818151815260200191508051906020019080838360005b838110156103a4578082015181840152602081019050610389565b50505050905090810190601f1680156103d15780820380516001836020036101000a031916815260200191505b509550505050505060405180910390a260019050949350505050565b600081565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1690508073ffffffffffffffffffffffffffffffffffffffff1663d99a8dc334846000604051602001526040518363ffffffff167c01000000000000000000000000000000000000000000000000000000000281526004018080602001828103825283818151815260200191508051906020019080838360005b838110156104aa57808201518184015260208101905061048f565b50505050905090810190601f1680156104d75780820380516001836020036101000a031916815260200191505b50925050506020604051808303818588803b15156104f457600080fd5b6125ee5a03f1151561050557600080fd5b5050505060405180519050151561051b57600080fd5b5050565b6040805190810160405280600a81526020017f6f70656e6d6f6c65706900000000000000000000000000000000000000000000815250815600a165627a7a723058204c46b02fd40c309719d0e8a635e19bc87185be654f5bf214e09715855e74639e0029", + "deployedBytecode": "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", + "sourceMap": "86:260:0:-;;;229:114;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;294:19;164:1;325:9;;;;;;;;;;;;;;;;;;426:23:3;397:19;378:18;;:38;;;;;;;;;;;;;;;;;;464:18;;;;;;;;;;;426:57;;501:11;:35;;;537:9;547:8;501:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;493:64:3;;;;;;;;272:292;;;;229:114:0;86:260;;;;;;", + "deployedSourceMap": "86:260:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;570:185:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;171:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;761:252:3;870:4;907:18;;;;;;;;;;;893:32;;:10;:32;;;885:41;;;;;;;;969:4;936:49;;;956:12;974:6;981:3;936:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1002:4:3;995:11;;761:252;;;;;;:::o;130:35:0:-;164:1;130:35;:::o;570:185:3:-;630:23;668:18;;;;;;;;;;;630:57;;705:11;:18;;;730:9;741:5;705:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;697:51:3;;;;;;;;570:185;;:::o;171:47:0:-;;;;;;;;;;;;;;;;;;;;:::o", + "source": "pragma solidity ^0.4.11;\nimport \"iexec-oracle-contract/contracts/IexecOracleAPI.sol\";\ncontract OpenMOLEPi is IexecOracleAPI{\n\n uint public constant DAPP_PRICE = 0;\n string public constant DAPP_NAME = \"openmolepi\";\n \n function OpenMOLEPi (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){\n\n }\n\n}\n", + "sourcePath": "/home/jopasserat/workspace/iexec-dapp-samples/contracts/OpenMOLEPi.sol", + "ast": { + "attributes": { + "absolutePath": "/home/jopasserat/workspace/iexec-dapp-samples/contracts/OpenMOLEPi.sol", + "exportedSymbols": { + "OpenMOLEPi": [ + 22 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".11" + ] + }, + "id": 1, + "name": "PragmaDirective", + "src": "0:24:0" + }, + { + "attributes": { + "SourceUnit": 795, + "absolutePath": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "file": "iexec-oracle-contract/contracts/IexecOracleAPI.sol", + "scope": 23, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 2, + "name": "ImportDirective", + "src": "25:60:0" + }, + { + "attributes": { + "contractDependencies": [ + 794 + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 22, + 794 + ], + "name": "OpenMOLEPi", + "scope": 23 + }, + "children": [ + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "IexecOracleAPI", + "referencedDeclaration": 794, + "type": "contract IexecOracleAPI" + }, + "id": 3, + "name": "UserDefinedTypeName", + "src": "109:14:0" + } + ], + "id": 4, + "name": "InheritanceSpecifier", + "src": "109:14:0" + }, + { + "attributes": { + "constant": true, + "name": "DAPP_PRICE", + "scope": 22, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 5, + "name": "ElementaryTypeName", + "src": "130:4:0" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 6, + "name": "Literal", + "src": "164:1:0" + } + ], + "id": 7, + "name": "VariableDeclaration", + "src": "130:35:0" + }, + { + "attributes": { + "constant": true, + "name": "DAPP_NAME", + "scope": 22, + "stateVariable": true, + "storageLocation": "default", + "type": "string memory", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 8, + "name": "ElementaryTypeName", + "src": "171:6:0" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "6f70656e6d6f6c657069", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"openmolepi\"", + "value": "openmolepi" + }, + "id": 9, + "name": "Literal", + "src": "206:12:0" + } + ], + "id": 10, + "name": "VariableDeclaration", + "src": "171:47:0" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "name": "OpenMOLEPi", + "payable": false, + "scope": 22, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_iexecOracleAddress", + "scope": 21, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 11, + "name": "ElementaryTypeName", + "src": "250:7:0" + } + ], + "id": 12, + "name": "VariableDeclaration", + "src": "250:27:0" + } + ], + "id": 13, + "name": "ParameterList", + "src": "249:29:0" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 19, + "name": "ParameterList", + "src": "335:0:0" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 794, + "type": "type(contract IexecOracleAPI)", + "value": "IexecOracleAPI" + }, + "id": 14, + "name": "Identifier", + "src": "279:14:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 12, + "type": "address", + "value": "_iexecOracleAddress" + }, + "id": 15, + "name": "Identifier", + "src": "294:19:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 7, + "type": "uint256", + "value": "DAPP_PRICE" + }, + "id": 16, + "name": "Identifier", + "src": "314:10:0" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 10, + "type": "string memory", + "value": "DAPP_NAME" + }, + "id": 17, + "name": "Identifier", + "src": "325:9:0" + } + ], + "id": 18, + "name": "ModifierInvocation", + "src": "279:56:0" + }, + { + "attributes": { + "statements": [ + null + ] + }, + "children": [], + "id": 20, + "name": "Block", + "src": "335:8:0" + } + ], + "id": 21, + "name": "FunctionDefinition", + "src": "229:114:0" + } + ], + "id": 22, + "name": "ContractDefinition", + "src": "86:260:0" + } + ], + "id": 23, + "name": "SourceUnit", + "src": "0:347:0" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": { + "3": { + "address": "0x5445dd04c7ed17690f3ec2480782cee44122f044" + } + }, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.800Z" +} \ No newline at end of file diff --git a/build/contracts/Ownable.json b/build/contracts/Ownable.json new file mode 100644 index 0000000..d6125c0 --- /dev/null +++ b/build/contracts/Ownable.json @@ -0,0 +1,602 @@ +{ + "contractName": "Ownable", + "abi": [ + { + "constant": true, + "inputs": [], + "name": "owner", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + } + ], + "bytecode": "0x6060604052341561000f57600080fd5b336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506102008061005e6000396000f30060606040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680638da5cb5b14610051578063f2fde38b146100a6575b600080fd5b341561005c57600080fd5b6100646100df565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34156100b157600080fd5b6100dd600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610104565b005b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156101d157600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415156101d057806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b5b505600a165627a7a723058201a240d5589456740a31e312bf3bd22de14abff3304abb2c28f675efa7267c4510029", + "deployedBytecode": "0x60606040526004361061004c576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff1680638da5cb5b14610051578063f2fde38b146100a6575b600080fd5b341561005c57600080fd5b6100646100df565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b34156100b157600080fd5b6100dd600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610104565b005b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156101d157600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415156101d057806000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b5b505600a165627a7a723058201a240d5589456740a31e312bf3bd22de14abff3304abb2c28f675efa7267c4510029", + "sourceMap": "25:279:6:-;;;71:48;;;;;;;;104:10;96:5;;:18;;;;;;;;;;;;;;;;;;25:279;;;;;;", + "deployedSourceMap": "25:279:6:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;191:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;46:20;;;;;;;;;;;;;:::o;191:110::-;168:5;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;276:1;256:22;;:8;:22;;;;252:44;;;288:8;280:5;;:16;;;;;;;;;;;;;;;;;;252:44;150:32;191:110;:::o", + "source": "pragma solidity ^0.4.8;\n\ncontract Ownable {\n address public owner;\n\n function Ownable() {\n owner = msg.sender;\n }\n\n modifier onlyOwner() {\n if (msg.sender == owner)\n _;\n }\n\n function transferOwnership(address newOwner) onlyOwner {\n if (newOwner != address(0)) owner = newOwner;\n }\n\n}", + "sourcePath": "rlc-token/contracts/Ownable.sol", + "ast": { + "attributes": { + "absolutePath": "rlc-token/contracts/Ownable.sol", + "exportedSymbols": { + "Ownable": [ + 1045 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".8" + ] + }, + "id": 1006, + "name": "PragmaDirective", + "src": "0:23:6" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 1045 + ], + "name": "Ownable", + "scope": 1046 + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "owner", + "scope": 1045, + "stateVariable": true, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1007, + "name": "ElementaryTypeName", + "src": "46:7:6" + } + ], + "id": 1008, + "name": "VariableDeclaration", + "src": "46:20:6" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "modifiers": [ + null + ], + "name": "Ownable", + "payable": false, + "scope": 1045, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1009, + "name": "ParameterList", + "src": "87:2:6" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1010, + "name": "ParameterList", + "src": "90:0:6" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 1011, + "name": "Identifier", + "src": "96:5:6" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1012, + "name": "Identifier", + "src": "104:3:6" + } + ], + "id": 1013, + "name": "MemberAccess", + "src": "104:10:6" + } + ], + "id": 1014, + "name": "Assignment", + "src": "96:18:6" + } + ], + "id": 1015, + "name": "ExpressionStatement", + "src": "96:18:6" + } + ], + "id": 1016, + "name": "Block", + "src": "90:29:6" + } + ], + "id": 1017, + "name": "FunctionDefinition", + "src": "71:48:6" + }, + { + "attributes": { + "name": "onlyOwner", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1018, + "name": "ParameterList", + "src": "141:2:6" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1019, + "name": "Identifier", + "src": "154:3:6" + } + ], + "id": 1020, + "name": "MemberAccess", + "src": "154:10:6" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 1021, + "name": "Identifier", + "src": "168:5:6" + } + ], + "id": 1022, + "name": "BinaryOperation", + "src": "154:19:6" + }, + { + "id": 1023, + "name": "PlaceholderStatement", + "src": "181:1:6" + } + ], + "id": 1024, + "name": "IfStatement", + "src": "150:32:6" + } + ], + "id": 1025, + "name": "Block", + "src": "144:43:6" + } + ], + "id": 1026, + "name": "ModifierDefinition", + "src": "123:64:6" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "transferOwnership", + "payable": false, + "scope": 1045, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "newOwner", + "scope": 1044, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1027, + "name": "ElementaryTypeName", + "src": "218:7:6" + } + ], + "id": 1028, + "name": "VariableDeclaration", + "src": "218:16:6" + } + ], + "id": 1029, + "name": "ParameterList", + "src": "217:18:6" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1032, + "name": "ParameterList", + "src": "246:0:6" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 1030, + "name": "Identifier", + "src": "236:9:6" + } + ], + "id": 1031, + "name": "ModifierInvocation", + "src": "236:9:6" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1028, + "type": "address", + "value": "newOwner" + }, + "id": 1033, + "name": "Identifier", + "src": "256:8:6" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": true, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "address", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "type": "type(address)", + "value": "address" + }, + "id": 1034, + "name": "ElementaryTypeNameExpression", + "src": "268:7:6" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 1035, + "name": "Literal", + "src": "276:1:6" + } + ], + "id": 1036, + "name": "FunctionCall", + "src": "268:10:6" + } + ], + "id": 1037, + "name": "BinaryOperation", + "src": "256:22:6" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 1038, + "name": "Identifier", + "src": "280:5:6" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1028, + "type": "address", + "value": "newOwner" + }, + "id": 1039, + "name": "Identifier", + "src": "288:8:6" + } + ], + "id": 1040, + "name": "Assignment", + "src": "280:16:6" + } + ], + "id": 1041, + "name": "ExpressionStatement", + "src": "280:16:6" + } + ], + "id": 1042, + "name": "IfStatement", + "src": "252:44:6" + } + ], + "id": 1043, + "name": "Block", + "src": "246:55:6" + } + ], + "id": 1044, + "name": "FunctionDefinition", + "src": "191:110:6" + } + ], + "id": 1045, + "name": "ContractDefinition", + "src": "25:279:6" + } + ], + "id": 1046, + "name": "SourceUnit", + "src": "0:304:6" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.802Z" +} \ No newline at end of file diff --git a/build/contracts/RLC.json b/build/contracts/RLC.json new file mode 100644 index 0000000..a2fcd77 --- /dev/null +++ b/build/contracts/RLC.json @@ -0,0 +1,4899 @@ +{ + "contractName": "RLC", + "abi": [ + { + "constant": true, + "inputs": [], + "name": "name", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_spender", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "approve", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "totalSupply", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_from", + "type": "address" + }, + { + "name": "_to", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "transferFrom", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "decimals", + "outputs": [ + { + "name": "", + "type": "uint8" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "initialSupply", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_value", + "type": "uint256" + } + ], + "name": "burn", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "version", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "_owner", + "type": "address" + } + ], + "name": "balanceOf", + "outputs": [ + { + "name": "balance", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "owner", + "outputs": [ + { + "name": "", + "type": "address" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "symbol", + "outputs": [ + { + "name": "", + "type": "string" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [], + "name": "unlock", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_to", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + } + ], + "name": "transfer", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "_spender", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + }, + { + "name": "_extraData", + "type": "bytes" + } + ], + "name": "approveAndCall", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": true, + "inputs": [], + "name": "locked", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "_owner", + "type": "address" + }, + { + "name": "_spender", + "type": "address" + } + ], + "name": "allowance", + "outputs": [ + { + "name": "remaining", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "newOwner", + "type": "address" + } + ], + "name": "transferOwnership", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "constructor" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "from", + "type": "address" + }, + { + "indexed": true, + "name": "to", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "name": "spender", + "type": "address" + }, + { + "indexed": false, + "name": "value", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + } + ], + "bytecode": "0x60606040526040805190810160405280600481526020017f76302e31000000000000000000000000000000000000000000000000000000008152506005908051906020019062000051929190620001d6565b5034156200005e57600080fd5b33600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506001600860006101000a81548160ff0219169083151502179055506701351609ff758000600681905550600654600781905550600654600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506040805190810160405280601481526020017f6945782e6563204e6574776f726b20546f6b656e0000000000000000000000008152506002908051906020019062000165929190620001d6565b506040805190810160405280600381526020017f524c43000000000000000000000000000000000000000000000000000000000081525060039080519060200190620001b3929190620001d6565b506009600460006101000a81548160ff021916908360ff16021790555062000285565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106200021957805160ff19168380011785556200024a565b828001600101855582156200024a579182015b82811115620002495782518255916020019190600101906200022c565b5b5090506200025991906200025d565b5090565b6200028291905b808211156200027e57600081600090555060010162000264565b5090565b90565b6113c080620002956000396000f3006060604052600436106100f1576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806306fdde03146100f6578063095ea7b31461018457806318160ddd146101de57806323b872dd14610207578063313ce56714610280578063378dc3dc146102af57806342966c68146102d857806354fd4d501461031357806370a08231146103a15780638da5cb5b146103ee57806395d89b4114610443578063a69df4b5146104d1578063a9059cbb146104e6578063cae9ca5114610540578063cf309012146105c5578063dd62ed3e146105f2578063f2fde38b1461065e575b600080fd5b341561010157600080fd5b610109610697565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561014957808201518184015260208101905061012e565b50505050905090810190601f1680156101765780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b341561018f57600080fd5b6101c4600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091908035906020019091905050610735565b604051808215151515815260200191505060405180910390f35b34156101e957600080fd5b6101f1610827565b6040518082815260200191505060405180910390f35b341561021257600080fd5b610266600480803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803590602001909190505061082d565b604051808215151515815260200191505060405180910390f35b341561028b57600080fd5b610293610b36565b604051808260ff1660ff16815260200191505060405180910390f35b34156102ba57600080fd5b6102c2610b49565b6040518082815260200191505060405180910390f35b34156102e357600080fd5b6102f96004808035906020019091905050610b4f565b604051808215151515815260200191505060405180910390f35b341561031e57600080fd5b610326610c48565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561036657808201518184015260208101905061034b565b50505050905090810190601f1680156103935780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34156103ac57600080fd5b6103d8600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050610ce6565b6040518082815260200191505060405180910390f35b34156103f957600080fd5b610401610d2f565b604051808273ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b341561044e57600080fd5b610456610d55565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561049657808201518184015260208101905061047b565b50505050905090810190601f1680156104c35780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34156104dc57600080fd5b6104e4610df3565b005b34156104f157600080fd5b610526600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091908035906020019091905050610e67565b604051808215151515815260200191505060405180910390f35b341561054b57600080fd5b6105c3600480803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803590602001909190803590602001908201803590602001908080601f01602080910402602001604051908101604052809392919081815260200183838082843782019150505050505091905050611064565b005b34156105d057600080fd5b6105d86111d6565b604051808215151515815260200191505060405180910390f35b34156105fd57600080fd5b610648600480803573ffffffffffffffffffffffffffffffffffffffff1690602001909190803573ffffffffffffffffffffffffffffffffffffffff169060200190919050506111e9565b6040518082815260200191505060405180910390f35b341561066957600080fd5b610695600480803573ffffffffffffffffffffffffffffffffffffffff16906020019091905050611270565b005b60028054600181600116156101000203166002900480601f01602080910402602001604051908101604052809291908181526020018280546001816001161561010002031660029004801561072d5780601f106107025761010080835404028352916020019161072d565b820191906000526020600020905b81548152906001019060200180831161071057829003601f168201915b505050505081565b600081600a60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925846040518082815260200191505060405180910390a36001905092915050565b60075481565b600080600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415801561089a5750600860009054906101000a900460ff165b156108a457600080fd5b600a60008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905061096c600960008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205484611342565b600960008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055506109f8600960008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548461136c565b600960008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610a45818461136c565b600a60008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508373ffffffffffffffffffffffffffffffffffffffff168573ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef856040518082815260200191505060405180910390a360019150509392505050565b600460009054906101000a900460ff1681565b60065481565b6000610b9a600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548361136c565b600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610be96007548361136c565b60078190555060003373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a360019050919050565b60058054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610cde5780601f10610cb357610100808354040283529160200191610cde565b820191906000526020600020905b815481529060010190602001808311610cc157829003601f168201915b505050505081565b6000600960008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60038054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610deb5780601f10610dc057610100808354040283529160200191610deb565b820191906000526020600020905b815481529060010190602001808311610dce57829003601f168201915b505050505081565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161415610e65576000600860006101000a81548160ff0219169083151502179055505b565b6000600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614158015610ed35750600860009054906101000a900460ff165b15610edd57600080fd5b610f26600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548361136c565b600960003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002081905550610fb2600960008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205483611342565b600960008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef846040518082815260200191505060405180910390a36001905092915050565b60008390506110738484610735565b156111d0578073ffffffffffffffffffffffffffffffffffffffff16638f4ffcb1338530866040518563ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020018481526020018373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561116d578082015181840152602081019050611152565b50505050905090810190601f16801561119a5780820380516001836020036101000a031916815260200191505b5095505050505050600060405180830381600087803b15156111bb57600080fd5b6102c65a03f115156111cc57600080fd5b5050505b50505050565b600860009054906101000a900460ff1681565b6000600a60008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16141561133f57600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614151561133e5780600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505b5b50565b600080828401905061136284821015801561135d5750838210155b611385565b8091505092915050565b600061137a83831115611385565b818303905092915050565b80151561139157600080fd5b505600a165627a7a723058206a4fe8f71faad786eec9cf19f82e6a772e410fbe6cafb1ea3a84cafa64bf5f9f0029", + "deployedBytecode": "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", + "sourceMap": "125:2917:7:-;;;333:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;773:601;;;;;;;;104:10:6;96:5;;:18;;;;;;;;;;;;;;;;;;858:4:7;849:6;;:13;;;;;;;;;;;;;;;;;;968:17;952:13;:33;;;;1005:13;;991:11;:27;;;;1047:13;;1024:8;:20;1033:10;1024:20;;;;;;;;;;;;;;;:36;;;;1124:29;;;;;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;:::i;:::-;;1208:14;;;;;;;;;;;;;;;;;;:6;:14;;;;;;;;;;;;:::i;:::-;;1302:1;1291:8;;:12;;;;;;;;;;;;;;;;;;125:2917;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;", + "deployedSourceMap": "125:2917:7:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;211:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2394:173:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;397:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1914:371;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;276:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;368:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1435:220;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;333:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2289:101:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46:20:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;252::7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1378:53:7;;;;;;;;;;;;;;1659:251;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2646:257;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;424:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2907:130;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;191:110:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;211:18:7;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2394:173::-;2451:4;2495:6;2463:7;:19;2471:10;2463:19;;;;;;;;;;;;;;;:29;2483:8;2463:29;;;;;;;;;;;;;;;:38;;;;2528:8;2507:38;;2516:10;2507:38;;;2538:6;2507:38;;;;;;;;;;;;;;;;;;2558:4;2551:11;;2394:173;;;;:::o;397:23::-;;;;:::o;1914:371::-;1999:4;2011:14;654:5;;;;;;;;;;;640:19;;:10;:19;;;;:29;;;;;663:6;;;;;;;;;;;640:29;636:40;;;671:5;;;636:40;2028:7;:14;2036:5;2028:14;;;;;;;;;;;;;;;:26;2043:10;2028:26;;;;;;;;;;;;;;;;2011:43;;2081:30;2089:8;:13;2098:3;2089:13;;;;;;;;;;;;;;;;2104:6;2081:7;:30::i;:::-;2065:8;:13;2074:3;2065:13;;;;;;;;;;;;;;;:46;;;;2135:32;2143:8;:15;2152:5;2143:15;;;;;;;;;;;;;;;;2160:6;2135:7;:32::i;:::-;2117:8;:15;2126:5;2117:15;;;;;;;;;;;;;;;:50;;;;2202:27;2210:10;2222:6;2202:7;:27::i;:::-;2173:7;:14;2181:5;2173:14;;;;;;;;;;;;;;;:26;2188:10;2173:26;;;;;;;;;;;;;;;:56;;;;2251:3;2235:28;;2244:5;2235:28;;;2256:6;2235:28;;;;;;;;;;;;;;;;;;2276:4;2269:11;;1914:371;;;;;;:::o;276:21::-;;;;;;;;;;;;;:::o;368:25::-;;;;:::o;1435:220::-;1474:4;1508:37;1516:8;:20;1525:10;1516:20;;;;;;;;;;;;;;;;1538:6;1508:7;:37::i;:::-;1485:8;:20;1494:10;1485:20;;;;;;;;;;;;;;;:60;;;;1566:28;1574:11;;1587:6;1566:7;:28::i;:::-;1552:11;:42;;;;1621:3;1609:10;1600:33;;;1626:6;1600:33;;;;;;;;;;;;;;;;;;1646:4;1639:11;;1435:220;;;:::o;333:30::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2289:101::-;2342:12;2369:8;:16;2378:6;2369:16;;;;;;;;;;;;;;;;2362:23;;2289:101;;;:::o;46:20:6:-;;;;;;;;;;;;;:::o;252::7:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;1378:53::-;168:5:6;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;1421:5:7;1412:6;;:14;;;;;;;;;;;;;;;;;;150:32:6;1378:53:7:o;1659:251::-;1725:4;654:5;;;;;;;;;;;640:19;;:10;:19;;;;:29;;;;;663:6;;;;;;;;;;;640:29;636:40;;;671:5;;;636:40;1760:37;1768:8;:20;1777:10;1768:20;;;;;;;;;;;;;;;;1790:6;1760:7;:37::i;:::-;1737:8;:20;1746:10;1737:20;;;;;;;;;;;;;;;:60;;;;1819:30;1827:8;:13;1836:3;1827:13;;;;;;;;;;;;;;;;1842:6;1819:7;:30::i;:::-;1803:8;:13;1812:3;1803:13;;;;;;;;;;;;;;;:46;;;;1876:3;1855:33;;1864:10;1855:33;;;1881:6;1855:33;;;;;;;;;;;;;;;;;;1901:4;1894:11;;1659:251;;;;:::o;2646:257::-;2733:20;2769:8;2733:45;;2790:25;2798:8;2808:6;2790:7;:25::i;:::-;2786:113;;;2829:7;:23;;;2853:10;2865:6;2873:4;2879:10;2829:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:2;8:100;;;99:1;94:3;90;84:5;80:1;75:3;71;64:6;52:2;49:1;45:3;40:15;;8:100;;;12:14;3:109;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2786:113:7;2646:257;;;;:::o;424:18::-;;;;;;;;;;;;;:::o;2907:130::-;2978:14;3007:7;:15;3015:6;3007:15;;;;;;;;;;;;;;;:25;3023:8;3007:25;;;;;;;;;;;;;;;;3000:32;;2907:130;;;;:::o;191:110:6:-;168:5;;;;;;;;;;;154:19;;:10;:19;;;150:32;;;276:1;256:22;;:8;:22;;;;252:44;;;288:8;280:5;;:16;;;;;;;;;;;;;;;;;;252:44;150:32;191:110;:::o;436:122:8:-;487:4;499:6;512:1;508;:5;499:14;;519:20;529:1;526;:4;;:12;;;;;537:1;534;:4;;526:12;519:6;:20::i;:::-;552:1;545:8;;436:122;;;;;:::o;332:100::-;383:4;395:14;407:1;402;:6;;395;:14::i;:::-;426:1;422;:5;415:12;;332:100;;;;:::o;992:87::-;1044:9;1043:10;1039:36;;;1063:5;;;1039:36;992:87;:::o", + "source": "pragma solidity ^0.4.8;\n\nimport \"./Ownable.sol\";\nimport \"./SafeMath.sol\";\nimport \"./ERC20.sol\";\nimport \"./TokenSpender.sol\";\ncontract RLC is ERC20, SafeMath, Ownable {\n\n /* Public variables of the token */\n string public name; //fancy name\n string public symbol;\n uint8 public decimals; //How many decimals to show.\n string public version = 'v0.1'; \n uint public initialSupply;\n uint public totalSupply;\n bool public locked;\n //uint public unlockBlock;\n\n mapping(address => uint) balances;\n mapping (address => mapping (address => uint)) allowed;\n\n // lock transfer during the ICO\n modifier onlyUnlocked() {\n if (msg.sender != owner && locked) throw;\n _;\n }\n\n /*\n * The RLC Token created with the time at which the crowdsale end\n */\n\n function RLC() {\n // lock the transfer function during the crowdsale\n locked = true;\n //unlockBlock= now + 45 days; // (testnet) - for mainnet put the block number\n\n initialSupply = 87000000000000000;\n totalSupply = initialSupply;\n balances[msg.sender] = initialSupply;// Give the creator all initial tokens \n name = 'iEx.ec Network Token'; // Set the name for display purposes \n symbol = 'RLC'; // Set the symbol for display purposes \n decimals = 9; // Amount of decimals for display purposes\n }\n\n function unlock() onlyOwner {\n locked = false;\n }\n\n function burn(uint256 _value) returns (bool){\n balances[msg.sender] = safeSub(balances[msg.sender], _value) ;\n totalSupply = safeSub(totalSupply, _value);\n Transfer(msg.sender, 0x0, _value);\n return true;\n }\n\n function transfer(address _to, uint _value) onlyUnlocked returns (bool) {\n balances[msg.sender] = safeSub(balances[msg.sender], _value);\n balances[_to] = safeAdd(balances[_to], _value);\n Transfer(msg.sender, _to, _value);\n return true;\n }\n\n function transferFrom(address _from, address _to, uint _value) onlyUnlocked returns (bool) {\n var _allowance = allowed[_from][msg.sender];\n \n balances[_to] = safeAdd(balances[_to], _value);\n balances[_from] = safeSub(balances[_from], _value);\n allowed[_from][msg.sender] = safeSub(_allowance, _value);\n Transfer(_from, _to, _value);\n return true;\n }\n\n function balanceOf(address _owner) constant returns (uint balance) {\n return balances[_owner];\n }\n\n function approve(address _spender, uint _value) returns (bool) {\n allowed[msg.sender][_spender] = _value;\n Approval(msg.sender, _spender, _value);\n return true;\n }\n\n /* Approve and then comunicate the approved contract in a single tx */\n function approveAndCall(address _spender, uint256 _value, bytes _extraData){ \n TokenSpender spender = TokenSpender(_spender);\n if (approve(_spender, _value)) {\n spender.receiveApproval(msg.sender, _value, this, _extraData);\n }\n }\n\n function allowance(address _owner, address _spender) constant returns (uint remaining) {\n return allowed[_owner][_spender];\n }\n \n}\n\n", + "sourcePath": "rlc-token/contracts/RLC.sol", + "ast": { + "attributes": { + "absolutePath": "rlc-token/contracts/RLC.sol", + "exportedSymbols": { + "RLC": [ + 1374 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".8" + ] + }, + "id": 1047, + "name": "PragmaDirective", + "src": "0:23:7" + }, + { + "attributes": { + "SourceUnit": 1046, + "absolutePath": "rlc-token/contracts/Ownable.sol", + "file": "./Ownable.sol", + "scope": 1375, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 1048, + "name": "ImportDirective", + "src": "25:23:7" + }, + { + "attributes": { + "SourceUnit": 1571, + "absolutePath": "rlc-token/contracts/SafeMath.sol", + "file": "./SafeMath.sol", + "scope": 1375, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 1049, + "name": "ImportDirective", + "src": "49:24:7" + }, + { + "attributes": { + "SourceUnit": 1005, + "absolutePath": "rlc-token/contracts/ERC20.sol", + "file": "./ERC20.sol", + "scope": 1375, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 1050, + "name": "ImportDirective", + "src": "74:21:7" + }, + { + "attributes": { + "SourceUnit": 1585, + "absolutePath": "rlc-token/contracts/TokenSpender.sol", + "file": "./TokenSpender.sol", + "scope": 1375, + "symbolAliases": [ + null + ], + "unitAlias": "" + }, + "id": 1051, + "name": "ImportDirective", + "src": "96:28:7" + }, + { + "attributes": { + "contractDependencies": [ + 1004, + 1045, + 1570 + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 1374, + 1045, + 1570, + 1004 + ], + "name": "RLC", + "scope": 1375 + }, + "children": [ + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "ERC20", + "referencedDeclaration": 1004, + "type": "contract ERC20" + }, + "id": 1052, + "name": "UserDefinedTypeName", + "src": "141:5:7" + } + ], + "id": 1053, + "name": "InheritanceSpecifier", + "src": "141:5:7" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "SafeMath", + "referencedDeclaration": 1570, + "type": "contract SafeMath" + }, + "id": 1054, + "name": "UserDefinedTypeName", + "src": "148:8:7" + } + ], + "id": 1055, + "name": "InheritanceSpecifier", + "src": "148:8:7" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "Ownable", + "referencedDeclaration": 1045, + "type": "contract Ownable" + }, + "id": 1056, + "name": "UserDefinedTypeName", + "src": "158:7:7" + } + ], + "id": 1057, + "name": "InheritanceSpecifier", + "src": "158:7:7" + }, + { + "attributes": { + "constant": false, + "name": "name", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "string storage ref", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 1058, + "name": "ElementaryTypeName", + "src": "211:6:7" + } + ], + "id": 1059, + "name": "VariableDeclaration", + "src": "211:18:7" + }, + { + "attributes": { + "constant": false, + "name": "symbol", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "string storage ref", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 1060, + "name": "ElementaryTypeName", + "src": "252:6:7" + } + ], + "id": 1061, + "name": "VariableDeclaration", + "src": "252:20:7" + }, + { + "attributes": { + "constant": false, + "name": "decimals", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "uint8", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint8", + "type": "uint8" + }, + "id": 1062, + "name": "ElementaryTypeName", + "src": "276:5:7" + } + ], + "id": 1063, + "name": "VariableDeclaration", + "src": "276:21:7" + }, + { + "attributes": { + "constant": false, + "name": "version", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "string storage ref", + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "string", + "type": "string storage pointer" + }, + "id": 1064, + "name": "ElementaryTypeName", + "src": "333:6:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "76302e31", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"v0.1\"", + "value": "v0.1" + }, + "id": 1065, + "name": "Literal", + "src": "357:6:7" + } + ], + "id": 1066, + "name": "VariableDeclaration", + "src": "333:30:7" + }, + { + "attributes": { + "constant": false, + "name": "initialSupply", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1067, + "name": "ElementaryTypeName", + "src": "368:4:7" + } + ], + "id": 1068, + "name": "VariableDeclaration", + "src": "368:25:7" + }, + { + "attributes": { + "constant": false, + "name": "totalSupply", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1069, + "name": "ElementaryTypeName", + "src": "397:4:7" + } + ], + "id": 1070, + "name": "VariableDeclaration", + "src": "397:23:7" + }, + { + "attributes": { + "constant": false, + "name": "locked", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1071, + "name": "ElementaryTypeName", + "src": "424:4:7" + } + ], + "id": 1072, + "name": "VariableDeclaration", + "src": "424:18:7" + }, + { + "attributes": { + "constant": false, + "name": "balances", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "mapping(address => uint256)", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1073, + "name": "ElementaryTypeName", + "src": "484:7:7" + }, + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1074, + "name": "ElementaryTypeName", + "src": "495:4:7" + } + ], + "id": 1075, + "name": "Mapping", + "src": "476:24:7" + } + ], + "id": 1076, + "name": "VariableDeclaration", + "src": "476:33:7" + }, + { + "attributes": { + "constant": false, + "name": "allowed", + "scope": 1374, + "stateVariable": true, + "storageLocation": "default", + "type": "mapping(address => mapping(address => uint256))", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "type": "mapping(address => mapping(address => uint256))" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1077, + "name": "ElementaryTypeName", + "src": "522:7:7" + }, + { + "attributes": { + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1078, + "name": "ElementaryTypeName", + "src": "542:7:7" + }, + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1079, + "name": "ElementaryTypeName", + "src": "553:4:7" + } + ], + "id": 1080, + "name": "Mapping", + "src": "533:25:7" + } + ], + "id": 1081, + "name": "Mapping", + "src": "513:46:7" + } + ], + "id": 1082, + "name": "VariableDeclaration", + "src": "513:54:7" + }, + { + "attributes": { + "name": "onlyUnlocked", + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1083, + "name": "ParameterList", + "src": "627:2:7" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "&&", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_address", + "typeString": "address" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1084, + "name": "Identifier", + "src": "640:3:7" + } + ], + "id": 1085, + "name": "MemberAccess", + "src": "640:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1008, + "type": "address", + "value": "owner" + }, + "id": 1086, + "name": "Identifier", + "src": "654:5:7" + } + ], + "id": 1087, + "name": "BinaryOperation", + "src": "640:19:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1072, + "type": "bool", + "value": "locked" + }, + "id": 1088, + "name": "Identifier", + "src": "663:6:7" + } + ], + "id": 1089, + "name": "BinaryOperation", + "src": "640:29:7" + }, + { + "children": [], + "id": 1090, + "name": "Throw", + "src": "671:5:7" + } + ], + "id": 1091, + "name": "IfStatement", + "src": "636:40:7" + }, + { + "id": 1092, + "name": "PlaceholderStatement", + "src": "682:1:7" + } + ], + "id": 1093, + "name": "Block", + "src": "630:58:7" + } + ], + "id": 1094, + "name": "ModifierDefinition", + "src": "606:82:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": true, + "modifiers": [ + null + ], + "name": "RLC", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1095, + "name": "ParameterList", + "src": "785:2:7" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1096, + "name": "ParameterList", + "src": "788:0:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1072, + "type": "bool", + "value": "locked" + }, + "id": 1097, + "name": "Identifier", + "src": "849:6:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 1098, + "name": "Literal", + "src": "858:4:7" + } + ], + "id": 1099, + "name": "Assignment", + "src": "849:13:7" + } + ], + "id": 1100, + "name": "ExpressionStatement", + "src": "849:13:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1068, + "type": "uint256", + "value": "initialSupply" + }, + "id": 1101, + "name": "Identifier", + "src": "952:13:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "3837303030303030303030303030303030", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 87000000000000000", + "value": "87000000000000000" + }, + "id": 1102, + "name": "Literal", + "src": "968:17:7" + } + ], + "id": 1103, + "name": "Assignment", + "src": "952:33:7" + } + ], + "id": 1104, + "name": "ExpressionStatement", + "src": "952:33:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1070, + "type": "uint256", + "value": "totalSupply" + }, + "id": 1105, + "name": "Identifier", + "src": "991:11:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1068, + "type": "uint256", + "value": "initialSupply" + }, + "id": 1106, + "name": "Identifier", + "src": "1005:13:7" + } + ], + "id": 1107, + "name": "Assignment", + "src": "991:27:7" + } + ], + "id": 1108, + "name": "ExpressionStatement", + "src": "991:27:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1109, + "name": "Identifier", + "src": "1024:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1110, + "name": "Identifier", + "src": "1033:3:7" + } + ], + "id": 1111, + "name": "MemberAccess", + "src": "1033:10:7" + } + ], + "id": 1112, + "name": "IndexAccess", + "src": "1024:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1068, + "type": "uint256", + "value": "initialSupply" + }, + "id": 1113, + "name": "Identifier", + "src": "1047:13:7" + } + ], + "id": 1114, + "name": "Assignment", + "src": "1024:36:7" + } + ], + "id": 1115, + "name": "ExpressionStatement", + "src": "1024:36:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1059, + "type": "string storage ref", + "value": "name" + }, + "id": 1116, + "name": "Identifier", + "src": "1124:4:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "6945782e6563204e6574776f726b20546f6b656e", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"iEx.ec Network Token\"", + "value": "iEx.ec Network Token" + }, + "id": 1117, + "name": "Literal", + "src": "1131:22:7" + } + ], + "id": 1118, + "name": "Assignment", + "src": "1124:29:7" + } + ], + "id": 1119, + "name": "ExpressionStatement", + "src": "1124:29:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "string storage ref" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1061, + "type": "string storage ref", + "value": "symbol" + }, + "id": 1120, + "name": "Identifier", + "src": "1208:6:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "524c43", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "string", + "type": "literal_string \"RLC\"", + "value": "RLC" + }, + "id": 1121, + "name": "Literal", + "src": "1217:5:7" + } + ], + "id": 1122, + "name": "Assignment", + "src": "1208:14:7" + } + ], + "id": 1123, + "name": "ExpressionStatement", + "src": "1208:14:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint8" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1063, + "type": "uint8", + "value": "decimals" + }, + "id": 1124, + "name": "Identifier", + "src": "1291:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "39", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 9", + "value": "9" + }, + "id": 1125, + "name": "Literal", + "src": "1302:1:7" + } + ], + "id": 1126, + "name": "Assignment", + "src": "1291:12:7" + } + ], + "id": 1127, + "name": "ExpressionStatement", + "src": "1291:12:7" + } + ], + "id": 1128, + "name": "Block", + "src": "788:586:7" + } + ], + "id": 1129, + "name": "FunctionDefinition", + "src": "773:601:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "unlock", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1130, + "name": "ParameterList", + "src": "1393:2:7" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1133, + "name": "ParameterList", + "src": "1406:0:7" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1026, + "type": "modifier ()", + "value": "onlyOwner" + }, + "id": 1131, + "name": "Identifier", + "src": "1396:9:7" + } + ], + "id": 1132, + "name": "ModifierInvocation", + "src": "1396:9:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1072, + "type": "bool", + "value": "locked" + }, + "id": 1134, + "name": "Identifier", + "src": "1412:6:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "66616c7365", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "false" + }, + "id": 1135, + "name": "Literal", + "src": "1421:5:7" + } + ], + "id": 1136, + "name": "Assignment", + "src": "1412:14:7" + } + ], + "id": 1137, + "name": "ExpressionStatement", + "src": "1412:14:7" + } + ], + "id": 1138, + "name": "Block", + "src": "1406:25:7" + } + ], + "id": 1139, + "name": "FunctionDefinition", + "src": "1378:53:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "burn", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1176, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1140, + "name": "ElementaryTypeName", + "src": "1449:7:7" + } + ], + "id": 1141, + "name": "VariableDeclaration", + "src": "1449:14:7" + } + ], + "id": 1142, + "name": "ParameterList", + "src": "1448:16:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1176, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1143, + "name": "ElementaryTypeName", + "src": "1474:4:7" + } + ], + "id": 1144, + "name": "VariableDeclaration", + "src": "1474:4:7" + } + ], + "id": 1145, + "name": "ParameterList", + "src": "1473:6:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1146, + "name": "Identifier", + "src": "1485:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1147, + "name": "Identifier", + "src": "1494:3:7" + } + ], + "id": 1148, + "name": "MemberAccess", + "src": "1494:10:7" + } + ], + "id": 1149, + "name": "IndexAccess", + "src": "1485:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1462, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeSub" + }, + "id": 1150, + "name": "Identifier", + "src": "1508:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1151, + "name": "Identifier", + "src": "1516:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1152, + "name": "Identifier", + "src": "1525:3:7" + } + ], + "id": 1153, + "name": "MemberAccess", + "src": "1525:10:7" + } + ], + "id": 1154, + "name": "IndexAccess", + "src": "1516:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1141, + "type": "uint256", + "value": "_value" + }, + "id": 1155, + "name": "Identifier", + "src": "1538:6:7" + } + ], + "id": 1156, + "name": "FunctionCall", + "src": "1508:37:7" + } + ], + "id": 1157, + "name": "Assignment", + "src": "1485:60:7" + } + ], + "id": 1158, + "name": "ExpressionStatement", + "src": "1485:60:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1070, + "type": "uint256", + "value": "totalSupply" + }, + "id": 1159, + "name": "Identifier", + "src": "1552:11:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1462, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeSub" + }, + "id": 1160, + "name": "Identifier", + "src": "1566:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1070, + "type": "uint256", + "value": "totalSupply" + }, + "id": 1161, + "name": "Identifier", + "src": "1574:11:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1141, + "type": "uint256", + "value": "_value" + }, + "id": 1162, + "name": "Identifier", + "src": "1587:6:7" + } + ], + "id": 1163, + "name": "FunctionCall", + "src": "1566:28:7" + } + ], + "id": 1164, + "name": "Assignment", + "src": "1552:42:7" + } + ], + "id": 1165, + "name": "ExpressionStatement", + "src": "1552:42:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_rational_0_by_1", + "typeString": "int_const 0" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 995, + "type": "function (address,address,uint256)", + "value": "Transfer" + }, + "id": 1166, + "name": "Identifier", + "src": "1600:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1167, + "name": "Identifier", + "src": "1609:3:7" + } + ], + "id": 1168, + "name": "MemberAccess", + "src": "1609:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "307830", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0x0" + }, + "id": 1169, + "name": "Literal", + "src": "1621:3:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1141, + "type": "uint256", + "value": "_value" + }, + "id": 1170, + "name": "Identifier", + "src": "1626:6:7" + } + ], + "id": 1171, + "name": "FunctionCall", + "src": "1600:33:7" + } + ], + "id": 1172, + "name": "ExpressionStatement", + "src": "1600:33:7" + }, + { + "attributes": { + "functionReturnParameters": 1145 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 1173, + "name": "Literal", + "src": "1646:4:7" + } + ], + "id": 1174, + "name": "Return", + "src": "1639:11:7" + } + ], + "id": 1175, + "name": "Block", + "src": "1479:176:7" + } + ], + "id": 1176, + "name": "FunctionDefinition", + "src": "1435:220:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "transfer", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": 967, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_to", + "scope": 1221, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1177, + "name": "ElementaryTypeName", + "src": "1677:7:7" + } + ], + "id": 1178, + "name": "VariableDeclaration", + "src": "1677:11:7" + }, + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1221, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1179, + "name": "ElementaryTypeName", + "src": "1690:4:7" + } + ], + "id": 1180, + "name": "VariableDeclaration", + "src": "1690:11:7" + } + ], + "id": 1181, + "name": "ParameterList", + "src": "1676:26:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1221, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1184, + "name": "ElementaryTypeName", + "src": "1725:4:7" + } + ], + "id": 1185, + "name": "VariableDeclaration", + "src": "1725:4:7" + } + ], + "id": 1186, + "name": "ParameterList", + "src": "1724:6:7" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1094, + "type": "modifier ()", + "value": "onlyUnlocked" + }, + "id": 1182, + "name": "Identifier", + "src": "1703:12:7" + } + ], + "id": 1183, + "name": "ModifierInvocation", + "src": "1703:12:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1187, + "name": "Identifier", + "src": "1737:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1188, + "name": "Identifier", + "src": "1746:3:7" + } + ], + "id": 1189, + "name": "MemberAccess", + "src": "1746:10:7" + } + ], + "id": 1190, + "name": "IndexAccess", + "src": "1737:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1462, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeSub" + }, + "id": 1191, + "name": "Identifier", + "src": "1760:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1192, + "name": "Identifier", + "src": "1768:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1193, + "name": "Identifier", + "src": "1777:3:7" + } + ], + "id": 1194, + "name": "MemberAccess", + "src": "1777:10:7" + } + ], + "id": 1195, + "name": "IndexAccess", + "src": "1768:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1180, + "type": "uint256", + "value": "_value" + }, + "id": 1196, + "name": "Identifier", + "src": "1790:6:7" + } + ], + "id": 1197, + "name": "FunctionCall", + "src": "1760:37:7" + } + ], + "id": 1198, + "name": "Assignment", + "src": "1737:60:7" + } + ], + "id": 1199, + "name": "ExpressionStatement", + "src": "1737:60:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1200, + "name": "Identifier", + "src": "1803:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1178, + "type": "address", + "value": "_to" + }, + "id": 1201, + "name": "Identifier", + "src": "1812:3:7" + } + ], + "id": 1202, + "name": "IndexAccess", + "src": "1803:13:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1490, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeAdd" + }, + "id": 1203, + "name": "Identifier", + "src": "1819:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1204, + "name": "Identifier", + "src": "1827:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1178, + "type": "address", + "value": "_to" + }, + "id": 1205, + "name": "Identifier", + "src": "1836:3:7" + } + ], + "id": 1206, + "name": "IndexAccess", + "src": "1827:13:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1180, + "type": "uint256", + "value": "_value" + }, + "id": 1207, + "name": "Identifier", + "src": "1842:6:7" + } + ], + "id": 1208, + "name": "FunctionCall", + "src": "1819:30:7" + } + ], + "id": 1209, + "name": "Assignment", + "src": "1803:46:7" + } + ], + "id": 1210, + "name": "ExpressionStatement", + "src": "1803:46:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 995, + "type": "function (address,address,uint256)", + "value": "Transfer" + }, + "id": 1211, + "name": "Identifier", + "src": "1855:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1212, + "name": "Identifier", + "src": "1864:3:7" + } + ], + "id": 1213, + "name": "MemberAccess", + "src": "1864:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1178, + "type": "address", + "value": "_to" + }, + "id": 1214, + "name": "Identifier", + "src": "1876:3:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1180, + "type": "uint256", + "value": "_value" + }, + "id": 1215, + "name": "Identifier", + "src": "1881:6:7" + } + ], + "id": 1216, + "name": "FunctionCall", + "src": "1855:33:7" + } + ], + "id": 1217, + "name": "ExpressionStatement", + "src": "1855:33:7" + }, + { + "attributes": { + "functionReturnParameters": 1186 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 1218, + "name": "Literal", + "src": "1901:4:7" + } + ], + "id": 1219, + "name": "Return", + "src": "1894:11:7" + } + ], + "id": 1220, + "name": "Block", + "src": "1731:179:7" + } + ], + "id": 1221, + "name": "FunctionDefinition", + "src": "1659:251:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "name": "transferFrom", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": 978, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_from", + "scope": 1285, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1222, + "name": "ElementaryTypeName", + "src": "1936:7:7" + } + ], + "id": 1223, + "name": "VariableDeclaration", + "src": "1936:13:7" + }, + { + "attributes": { + "constant": false, + "name": "_to", + "scope": 1285, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1224, + "name": "ElementaryTypeName", + "src": "1951:7:7" + } + ], + "id": 1225, + "name": "VariableDeclaration", + "src": "1951:11:7" + }, + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1285, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1226, + "name": "ElementaryTypeName", + "src": "1964:4:7" + } + ], + "id": 1227, + "name": "VariableDeclaration", + "src": "1964:11:7" + } + ], + "id": 1228, + "name": "ParameterList", + "src": "1935:41:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1285, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1231, + "name": "ElementaryTypeName", + "src": "1999:4:7" + } + ], + "id": 1232, + "name": "VariableDeclaration", + "src": "1999:4:7" + } + ], + "id": 1233, + "name": "ParameterList", + "src": "1998:6:7" + }, + { + "attributes": { + "arguments": [ + null + ] + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1094, + "type": "modifier ()", + "value": "onlyUnlocked" + }, + "id": 1229, + "name": "Identifier", + "src": "1977:12:7" + } + ], + "id": 1230, + "name": "ModifierInvocation", + "src": "1977:12:7" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 1234 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "_allowance", + "scope": 1285, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "typeName": null, + "value": null, + "visibility": "internal" + }, + "children": [], + "id": 1234, + "name": "VariableDeclaration", + "src": "2011:14:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1082, + "type": "mapping(address => mapping(address => uint256))", + "value": "allowed" + }, + "id": 1235, + "name": "Identifier", + "src": "2028:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1223, + "type": "address", + "value": "_from" + }, + "id": 1236, + "name": "Identifier", + "src": "2036:5:7" + } + ], + "id": 1237, + "name": "IndexAccess", + "src": "2028:14:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1238, + "name": "Identifier", + "src": "2043:3:7" + } + ], + "id": 1239, + "name": "MemberAccess", + "src": "2043:10:7" + } + ], + "id": 1240, + "name": "IndexAccess", + "src": "2028:26:7" + } + ], + "id": 1241, + "name": "VariableDeclarationStatement", + "src": "2011:43:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1242, + "name": "Identifier", + "src": "2065:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1225, + "type": "address", + "value": "_to" + }, + "id": 1243, + "name": "Identifier", + "src": "2074:3:7" + } + ], + "id": 1244, + "name": "IndexAccess", + "src": "2065:13:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1490, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeAdd" + }, + "id": 1245, + "name": "Identifier", + "src": "2081:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1246, + "name": "Identifier", + "src": "2089:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1225, + "type": "address", + "value": "_to" + }, + "id": 1247, + "name": "Identifier", + "src": "2098:3:7" + } + ], + "id": 1248, + "name": "IndexAccess", + "src": "2089:13:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1227, + "type": "uint256", + "value": "_value" + }, + "id": 1249, + "name": "Identifier", + "src": "2104:6:7" + } + ], + "id": 1250, + "name": "FunctionCall", + "src": "2081:30:7" + } + ], + "id": 1251, + "name": "Assignment", + "src": "2065:46:7" + } + ], + "id": 1252, + "name": "ExpressionStatement", + "src": "2065:46:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1253, + "name": "Identifier", + "src": "2117:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1223, + "type": "address", + "value": "_from" + }, + "id": 1254, + "name": "Identifier", + "src": "2126:5:7" + } + ], + "id": 1255, + "name": "IndexAccess", + "src": "2117:15:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1462, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeSub" + }, + "id": 1256, + "name": "Identifier", + "src": "2135:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1257, + "name": "Identifier", + "src": "2143:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1223, + "type": "address", + "value": "_from" + }, + "id": 1258, + "name": "Identifier", + "src": "2152:5:7" + } + ], + "id": 1259, + "name": "IndexAccess", + "src": "2143:15:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1227, + "type": "uint256", + "value": "_value" + }, + "id": 1260, + "name": "Identifier", + "src": "2160:6:7" + } + ], + "id": 1261, + "name": "FunctionCall", + "src": "2135:32:7" + } + ], + "id": 1262, + "name": "Assignment", + "src": "2117:50:7" + } + ], + "id": 1263, + "name": "ExpressionStatement", + "src": "2117:50:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1082, + "type": "mapping(address => mapping(address => uint256))", + "value": "allowed" + }, + "id": 1264, + "name": "Identifier", + "src": "2173:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1223, + "type": "address", + "value": "_from" + }, + "id": 1265, + "name": "Identifier", + "src": "2181:5:7" + } + ], + "id": 1268, + "name": "IndexAccess", + "src": "2173:14:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1266, + "name": "Identifier", + "src": "2188:3:7" + } + ], + "id": 1267, + "name": "MemberAccess", + "src": "2188:10:7" + } + ], + "id": 1269, + "name": "IndexAccess", + "src": "2173:26:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "uint256", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1462, + "type": "function (uint256,uint256) returns (uint256)", + "value": "safeSub" + }, + "id": 1270, + "name": "Identifier", + "src": "2202:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1234, + "type": "uint256", + "value": "_allowance" + }, + "id": 1271, + "name": "Identifier", + "src": "2210:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1227, + "type": "uint256", + "value": "_value" + }, + "id": 1272, + "name": "Identifier", + "src": "2222:6:7" + } + ], + "id": 1273, + "name": "FunctionCall", + "src": "2202:27:7" + } + ], + "id": 1274, + "name": "Assignment", + "src": "2173:56:7" + } + ], + "id": 1275, + "name": "ExpressionStatement", + "src": "2173:56:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 995, + "type": "function (address,address,uint256)", + "value": "Transfer" + }, + "id": 1276, + "name": "Identifier", + "src": "2235:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1223, + "type": "address", + "value": "_from" + }, + "id": 1277, + "name": "Identifier", + "src": "2244:5:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1225, + "type": "address", + "value": "_to" + }, + "id": 1278, + "name": "Identifier", + "src": "2251:3:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1227, + "type": "uint256", + "value": "_value" + }, + "id": 1279, + "name": "Identifier", + "src": "2256:6:7" + } + ], + "id": 1280, + "name": "FunctionCall", + "src": "2235:28:7" + } + ], + "id": 1281, + "name": "ExpressionStatement", + "src": "2235:28:7" + }, + { + "attributes": { + "functionReturnParameters": 1233 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 1282, + "name": "Literal", + "src": "2276:4:7" + } + ], + "id": 1283, + "name": "Return", + "src": "2269:11:7" + } + ], + "id": 1284, + "name": "Block", + "src": "2005:280:7" + } + ], + "id": 1285, + "name": "FunctionDefinition", + "src": "1914:371:7" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "balanceOf", + "payable": false, + "scope": 1374, + "stateMutability": "view", + "superFunction": 949, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_owner", + "scope": 1297, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1286, + "name": "ElementaryTypeName", + "src": "2308:7:7" + } + ], + "id": 1287, + "name": "VariableDeclaration", + "src": "2308:14:7" + } + ], + "id": 1288, + "name": "ParameterList", + "src": "2307:16:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "balance", + "scope": 1297, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1289, + "name": "ElementaryTypeName", + "src": "2342:4:7" + } + ], + "id": 1290, + "name": "VariableDeclaration", + "src": "2342:12:7" + } + ], + "id": 1291, + "name": "ParameterList", + "src": "2341:14:7" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1291 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1076, + "type": "mapping(address => uint256)", + "value": "balances" + }, + "id": 1292, + "name": "Identifier", + "src": "2369:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1287, + "type": "address", + "value": "_owner" + }, + "id": 1293, + "name": "Identifier", + "src": "2378:6:7" + } + ], + "id": 1294, + "name": "IndexAccess", + "src": "2369:16:7" + } + ], + "id": 1295, + "name": "Return", + "src": "2362:23:7" + } + ], + "id": 1296, + "name": "Block", + "src": "2356:34:7" + } + ], + "id": 1297, + "name": "FunctionDefinition", + "src": "2289:101:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "approve", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": 987, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_spender", + "scope": 1325, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1298, + "name": "ElementaryTypeName", + "src": "2411:7:7" + } + ], + "id": 1299, + "name": "VariableDeclaration", + "src": "2411:16:7" + }, + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1325, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1300, + "name": "ElementaryTypeName", + "src": "2429:4:7" + } + ], + "id": 1301, + "name": "VariableDeclaration", + "src": "2429:11:7" + } + ], + "id": 1302, + "name": "ParameterList", + "src": "2410:31:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1325, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1303, + "name": "ElementaryTypeName", + "src": "2451:4:7" + } + ], + "id": 1304, + "name": "VariableDeclaration", + "src": "2451:4:7" + } + ], + "id": 1305, + "name": "ParameterList", + "src": "2450:6:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "=", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": true, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1082, + "type": "mapping(address => mapping(address => uint256))", + "value": "allowed" + }, + "id": 1306, + "name": "Identifier", + "src": "2463:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1307, + "name": "Identifier", + "src": "2471:3:7" + } + ], + "id": 1308, + "name": "MemberAccess", + "src": "2471:10:7" + } + ], + "id": 1310, + "name": "IndexAccess", + "src": "2463:19:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1299, + "type": "address", + "value": "_spender" + }, + "id": 1309, + "name": "Identifier", + "src": "2483:8:7" + } + ], + "id": 1311, + "name": "IndexAccess", + "src": "2463:29:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1301, + "type": "uint256", + "value": "_value" + }, + "id": 1312, + "name": "Identifier", + "src": "2495:6:7" + } + ], + "id": 1313, + "name": "Assignment", + "src": "2463:38:7" + } + ], + "id": 1314, + "name": "ExpressionStatement", + "src": "2463:38:7" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1003, + "type": "function (address,address,uint256)", + "value": "Approval" + }, + "id": 1315, + "name": "Identifier", + "src": "2507:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1316, + "name": "Identifier", + "src": "2516:3:7" + } + ], + "id": 1317, + "name": "MemberAccess", + "src": "2516:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1299, + "type": "address", + "value": "_spender" + }, + "id": 1318, + "name": "Identifier", + "src": "2528:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1301, + "type": "uint256", + "value": "_value" + }, + "id": 1319, + "name": "Identifier", + "src": "2538:6:7" + } + ], + "id": 1320, + "name": "FunctionCall", + "src": "2507:38:7" + } + ], + "id": 1321, + "name": "ExpressionStatement", + "src": "2507:38:7" + }, + { + "attributes": { + "functionReturnParameters": 1305 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "hexvalue": "74727565", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "bool", + "type": "bool", + "value": "true" + }, + "id": 1322, + "name": "Literal", + "src": "2558:4:7" + } + ], + "id": 1323, + "name": "Return", + "src": "2551:11:7" + } + ], + "id": 1324, + "name": "Block", + "src": "2457:110:7" + } + ], + "id": 1325, + "name": "FunctionDefinition", + "src": "2394:173:7" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "approveAndCall", + "payable": false, + "scope": 1374, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_spender", + "scope": 1357, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1326, + "name": "ElementaryTypeName", + "src": "2670:7:7" + } + ], + "id": 1327, + "name": "VariableDeclaration", + "src": "2670:16:7" + }, + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1357, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1328, + "name": "ElementaryTypeName", + "src": "2688:7:7" + } + ], + "id": 1329, + "name": "VariableDeclaration", + "src": "2688:14:7" + }, + { + "attributes": { + "constant": false, + "name": "_extraData", + "scope": 1357, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes", + "type": "bytes storage pointer" + }, + "id": 1330, + "name": "ElementaryTypeName", + "src": "2704:5:7" + } + ], + "id": 1331, + "name": "VariableDeclaration", + "src": "2704:16:7" + } + ], + "id": 1332, + "name": "ParameterList", + "src": "2669:52:7" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1333, + "name": "ParameterList", + "src": "2721:0:7" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 1335 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "spender", + "scope": 1357, + "stateVariable": false, + "storageLocation": "default", + "type": "contract TokenSpender", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "contractScope": null, + "name": "TokenSpender", + "referencedDeclaration": 1584, + "type": "contract TokenSpender" + }, + "id": 1334, + "name": "UserDefinedTypeName", + "src": "2733:12:7" + } + ], + "id": 1335, + "name": "VariableDeclaration", + "src": "2733:20:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "contract TokenSpender", + "type_conversion": true + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1584, + "type": "type(contract TokenSpender)", + "value": "TokenSpender" + }, + "id": 1336, + "name": "Identifier", + "src": "2756:12:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1327, + "type": "address", + "value": "_spender" + }, + "id": 1337, + "name": "Identifier", + "src": "2769:8:7" + } + ], + "id": 1338, + "name": "FunctionCall", + "src": "2756:22:7" + } + ], + "id": 1339, + "name": "VariableDeclarationStatement", + "src": "2733:45:7" + }, + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "bool", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + ], + "overloadedDeclarations": [ + 1325 + ], + "referencedDeclaration": 1325, + "type": "function (address,uint256) returns (bool)", + "value": "approve" + }, + "id": 1340, + "name": "Identifier", + "src": "2790:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1327, + "type": "address", + "value": "_spender" + }, + "id": 1341, + "name": "Identifier", + "src": "2798:8:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1329, + "type": "uint256", + "value": "_value" + }, + "id": 1342, + "name": "Identifier", + "src": "2808:6:7" + } + ], + "id": 1343, + "name": "FunctionCall", + "src": "2790:25:7" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_address", + "typeString": "address" + }, + { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + { + "typeIdentifier": "t_contract$_RLC_$1374", + "typeString": "contract RLC" + }, + { + "typeIdentifier": "t_bytes_memory_ptr", + "typeString": "bytes memory" + } + ], + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "receiveApproval", + "referencedDeclaration": 1583, + "type": "function (address,uint256,address,bytes memory) external" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1335, + "type": "contract TokenSpender", + "value": "spender" + }, + "id": 1344, + "name": "Identifier", + "src": "2829:7:7" + } + ], + "id": 1346, + "name": "MemberAccess", + "src": "2829:23:7" + }, + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "member_name": "sender", + "referencedDeclaration": null, + "type": "address" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1596, + "type": "msg", + "value": "msg" + }, + "id": 1347, + "name": "Identifier", + "src": "2853:3:7" + } + ], + "id": 1348, + "name": "MemberAccess", + "src": "2853:10:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1329, + "type": "uint256", + "value": "_value" + }, + "id": 1349, + "name": "Identifier", + "src": "2865:6:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1615, + "type": "contract RLC", + "value": "this" + }, + "id": 1350, + "name": "Identifier", + "src": "2873:4:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1331, + "type": "bytes memory", + "value": "_extraData" + }, + "id": 1351, + "name": "Identifier", + "src": "2879:10:7" + } + ], + "id": 1352, + "name": "FunctionCall", + "src": "2829:61:7" + } + ], + "id": 1353, + "name": "ExpressionStatement", + "src": "2829:61:7" + } + ], + "id": 1354, + "name": "Block", + "src": "2817:82:7" + } + ], + "id": 1355, + "name": "IfStatement", + "src": "2786:113:7" + } + ], + "id": 1356, + "name": "Block", + "src": "2721:182:7" + } + ], + "id": 1357, + "name": "FunctionDefinition", + "src": "2646:257:7" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "allowance", + "payable": false, + "scope": 1374, + "stateMutability": "view", + "superFunction": 958, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_owner", + "scope": 1373, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1358, + "name": "ElementaryTypeName", + "src": "2926:7:7" + } + ], + "id": 1359, + "name": "VariableDeclaration", + "src": "2926:14:7" + }, + { + "attributes": { + "constant": false, + "name": "_spender", + "scope": 1373, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1360, + "name": "ElementaryTypeName", + "src": "2942:7:7" + } + ], + "id": 1361, + "name": "VariableDeclaration", + "src": "2942:16:7" + } + ], + "id": 1362, + "name": "ParameterList", + "src": "2925:34:7" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "remaining", + "scope": 1373, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1363, + "name": "ElementaryTypeName", + "src": "2978:4:7" + } + ], + "id": 1364, + "name": "VariableDeclaration", + "src": "2978:14:7" + } + ], + "id": 1365, + "name": "ParameterList", + "src": "2977:16:7" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1365 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": true, + "isPure": false, + "lValueRequested": false, + "type": "mapping(address => uint256)" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1082, + "type": "mapping(address => mapping(address => uint256))", + "value": "allowed" + }, + "id": 1366, + "name": "Identifier", + "src": "3007:7:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1359, + "type": "address", + "value": "_owner" + }, + "id": 1367, + "name": "Identifier", + "src": "3015:6:7" + } + ], + "id": 1368, + "name": "IndexAccess", + "src": "3007:15:7" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1361, + "type": "address", + "value": "_spender" + }, + "id": 1369, + "name": "Identifier", + "src": "3023:8:7" + } + ], + "id": 1370, + "name": "IndexAccess", + "src": "3007:25:7" + } + ], + "id": 1371, + "name": "Return", + "src": "3000:32:7" + } + ], + "id": 1372, + "name": "Block", + "src": "2994:43:7" + } + ], + "id": 1373, + "name": "FunctionDefinition", + "src": "2907:130:7" + } + ], + "id": 1374, + "name": "ContractDefinition", + "src": "125:2917:7" + } + ], + "id": 1375, + "name": "SourceUnit", + "src": "0:3044:7" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.802Z" +} \ No newline at end of file diff --git a/build/contracts/SafeMath.json b/build/contracts/SafeMath.json new file mode 100644 index 0000000..92eb447 --- /dev/null +++ b/build/contracts/SafeMath.json @@ -0,0 +1,2694 @@ +{ + "contractName": "SafeMath", + "abi": [], + "bytecode": "0x60606040523415600e57600080fd5b603580601b6000396000f3006060604052600080fd00a165627a7a723058200a92dfbff50f3579312bc0747a90124e83c060292fe7bd7a1b3809f470e320d30029", + "deployedBytecode": "0x6060604052600080fd00a165627a7a723058200a92dfbff50f3579312bc0747a90124e83c060292fe7bd7a1b3809f470e320d30029", + "sourceMap": "25:1056:8:-;;;;;;;;;;;;;;;;;", + "deployedSourceMap": "25:1056:8:-;;;;;", + "source": "pragma solidity ^0.4.8;\n\ncontract SafeMath {\n function safeMul(uint a, uint b) internal returns (uint) {\n uint c = a * b;\n assert(a == 0 || c / a == b);\n return c;\n }\n\n function safeDiv(uint a, uint b) internal returns (uint) {\n assert(b > 0);\n uint c = a / b;\n assert(a == b * c + a % b);\n return c;\n }\n\n function safeSub(uint a, uint b) internal returns (uint) {\n assert(b <= a);\n return a - b;\n }\n\n function safeAdd(uint a, uint b) internal returns (uint) {\n uint c = a + b;\n assert(c>=a && c>=b);\n return c;\n }\n\n function max64(uint64 a, uint64 b) internal constant returns (uint64) {\n return a >= b ? a : b;\n }\n\n function min64(uint64 a, uint64 b) internal constant returns (uint64) {\n return a < b ? a : b;\n }\n\n function max256(uint256 a, uint256 b) internal constant returns (uint256) {\n return a >= b ? a : b;\n }\n\n function min256(uint256 a, uint256 b) internal constant returns (uint256) {\n return a < b ? a : b;\n }\n\n function assert(bool assertion) internal {\n if (!assertion) {\n throw;\n }\n }\n}", + "sourcePath": "rlc-token/contracts/SafeMath.sol", + "ast": { + "attributes": { + "absolutePath": "rlc-token/contracts/SafeMath.sol", + "exportedSymbols": { + "SafeMath": [ + 1570 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".8" + ] + }, + "id": 1376, + "name": "PragmaDirective", + "src": "0:23:8" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": true, + "linearizedBaseContracts": [ + 1570 + ], + "name": "SafeMath", + "scope": 1571 + }, + "children": [ + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "safeMul", + "payable": false, + "scope": 1570, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1406, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1377, + "name": "ElementaryTypeName", + "src": "64:4:8" + } + ], + "id": 1378, + "name": "VariableDeclaration", + "src": "64:6:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1406, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1379, + "name": "ElementaryTypeName", + "src": "72:4:8" + } + ], + "id": 1380, + "name": "VariableDeclaration", + "src": "72:6:8" + } + ], + "id": 1381, + "name": "ParameterList", + "src": "63:16:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1406, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1382, + "name": "ElementaryTypeName", + "src": "98:4:8" + } + ], + "id": 1383, + "name": "VariableDeclaration", + "src": "98:4:8" + } + ], + "id": 1384, + "name": "ParameterList", + "src": "97:6:8" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 1386 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "c", + "scope": 1406, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1385, + "name": "ElementaryTypeName", + "src": "110:4:8" + } + ], + "id": 1386, + "name": "VariableDeclaration", + "src": "110:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "*", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1378, + "type": "uint256", + "value": "a" + }, + "id": 1387, + "name": "Identifier", + "src": "119:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1380, + "type": "uint256", + "value": "b" + }, + "id": 1388, + "name": "Identifier", + "src": "123:1:8" + } + ], + "id": 1389, + "name": "BinaryOperation", + "src": "119:5:8" + } + ], + "id": 1390, + "name": "VariableDeclarationStatement", + "src": "110:14:8" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1569, + "type": "function (bool)", + "value": "assert" + }, + "id": 1391, + "name": "Identifier", + "src": "130:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "||", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1378, + "type": "uint256", + "value": "a" + }, + "id": 1392, + "name": "Identifier", + "src": "137:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 1393, + "name": "Literal", + "src": "142:1:8" + } + ], + "id": 1394, + "name": "BinaryOperation", + "src": "137:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "/", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1386, + "type": "uint256", + "value": "c" + }, + "id": 1395, + "name": "Identifier", + "src": "147:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1378, + "type": "uint256", + "value": "a" + }, + "id": 1396, + "name": "Identifier", + "src": "151:1:8" + } + ], + "id": 1397, + "name": "BinaryOperation", + "src": "147:5:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1380, + "type": "uint256", + "value": "b" + }, + "id": 1398, + "name": "Identifier", + "src": "156:1:8" + } + ], + "id": 1399, + "name": "BinaryOperation", + "src": "147:10:8" + } + ], + "id": 1400, + "name": "BinaryOperation", + "src": "137:20:8" + } + ], + "id": 1401, + "name": "FunctionCall", + "src": "130:28:8" + } + ], + "id": 1402, + "name": "ExpressionStatement", + "src": "130:28:8" + }, + { + "attributes": { + "functionReturnParameters": 1384 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1386, + "type": "uint256", + "value": "c" + }, + "id": 1403, + "name": "Identifier", + "src": "171:1:8" + } + ], + "id": 1404, + "name": "Return", + "src": "164:8:8" + } + ], + "id": 1405, + "name": "Block", + "src": "104:73:8" + } + ], + "id": 1406, + "name": "FunctionDefinition", + "src": "47:130:8" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "safeDiv", + "payable": false, + "scope": 1570, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1442, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1407, + "name": "ElementaryTypeName", + "src": "198:4:8" + } + ], + "id": 1408, + "name": "VariableDeclaration", + "src": "198:6:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1442, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1409, + "name": "ElementaryTypeName", + "src": "206:4:8" + } + ], + "id": 1410, + "name": "VariableDeclaration", + "src": "206:6:8" + } + ], + "id": 1411, + "name": "ParameterList", + "src": "197:16:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1442, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1412, + "name": "ElementaryTypeName", + "src": "232:4:8" + } + ], + "id": 1413, + "name": "VariableDeclaration", + "src": "232:4:8" + } + ], + "id": 1414, + "name": "ParameterList", + "src": "231:6:8" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1569, + "type": "function (bool)", + "value": "assert" + }, + "id": 1415, + "name": "Identifier", + "src": "244:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1410, + "type": "uint256", + "value": "b" + }, + "id": 1416, + "name": "Identifier", + "src": "251:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "hexvalue": "30", + "isConstant": false, + "isLValue": false, + "isPure": true, + "lValueRequested": false, + "subdenomination": null, + "token": "number", + "type": "int_const 0", + "value": "0" + }, + "id": 1417, + "name": "Literal", + "src": "255:1:8" + } + ], + "id": 1418, + "name": "BinaryOperation", + "src": "251:5:8" + } + ], + "id": 1419, + "name": "FunctionCall", + "src": "244:13:8" + } + ], + "id": 1420, + "name": "ExpressionStatement", + "src": "244:13:8" + }, + { + "attributes": { + "assignments": [ + 1422 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "c", + "scope": 1442, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1421, + "name": "ElementaryTypeName", + "src": "263:4:8" + } + ], + "id": 1422, + "name": "VariableDeclaration", + "src": "263:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "/", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1408, + "type": "uint256", + "value": "a" + }, + "id": 1423, + "name": "Identifier", + "src": "272:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1410, + "type": "uint256", + "value": "b" + }, + "id": 1424, + "name": "Identifier", + "src": "276:1:8" + } + ], + "id": 1425, + "name": "BinaryOperation", + "src": "272:5:8" + } + ], + "id": 1426, + "name": "VariableDeclarationStatement", + "src": "263:14:8" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1569, + "type": "function (bool)", + "value": "assert" + }, + "id": 1427, + "name": "Identifier", + "src": "283:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "==", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1408, + "type": "uint256", + "value": "a" + }, + "id": 1428, + "name": "Identifier", + "src": "290:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "+", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "*", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1410, + "type": "uint256", + "value": "b" + }, + "id": 1429, + "name": "Identifier", + "src": "295:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1422, + "type": "uint256", + "value": "c" + }, + "id": 1430, + "name": "Identifier", + "src": "299:1:8" + } + ], + "id": 1431, + "name": "BinaryOperation", + "src": "295:5:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "%", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1408, + "type": "uint256", + "value": "a" + }, + "id": 1432, + "name": "Identifier", + "src": "303:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1410, + "type": "uint256", + "value": "b" + }, + "id": 1433, + "name": "Identifier", + "src": "307:1:8" + } + ], + "id": 1434, + "name": "BinaryOperation", + "src": "303:5:8" + } + ], + "id": 1435, + "name": "BinaryOperation", + "src": "295:13:8" + } + ], + "id": 1436, + "name": "BinaryOperation", + "src": "290:18:8" + } + ], + "id": 1437, + "name": "FunctionCall", + "src": "283:26:8" + } + ], + "id": 1438, + "name": "ExpressionStatement", + "src": "283:26:8" + }, + { + "attributes": { + "functionReturnParameters": 1414 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1422, + "type": "uint256", + "value": "c" + }, + "id": 1439, + "name": "Identifier", + "src": "322:1:8" + } + ], + "id": 1440, + "name": "Return", + "src": "315:8:8" + } + ], + "id": 1441, + "name": "Block", + "src": "238:90:8" + } + ], + "id": 1442, + "name": "FunctionDefinition", + "src": "181:147:8" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "safeSub", + "payable": false, + "scope": 1570, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1462, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1443, + "name": "ElementaryTypeName", + "src": "349:4:8" + } + ], + "id": 1444, + "name": "VariableDeclaration", + "src": "349:6:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1462, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1445, + "name": "ElementaryTypeName", + "src": "357:4:8" + } + ], + "id": 1446, + "name": "VariableDeclaration", + "src": "357:6:8" + } + ], + "id": 1447, + "name": "ParameterList", + "src": "348:16:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1462, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1448, + "name": "ElementaryTypeName", + "src": "383:4:8" + } + ], + "id": 1449, + "name": "VariableDeclaration", + "src": "383:4:8" + } + ], + "id": 1450, + "name": "ParameterList", + "src": "382:6:8" + }, + { + "children": [ + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1569, + "type": "function (bool)", + "value": "assert" + }, + "id": 1451, + "name": "Identifier", + "src": "395:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "<=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1446, + "type": "uint256", + "value": "b" + }, + "id": 1452, + "name": "Identifier", + "src": "402:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1444, + "type": "uint256", + "value": "a" + }, + "id": 1453, + "name": "Identifier", + "src": "407:1:8" + } + ], + "id": 1454, + "name": "BinaryOperation", + "src": "402:6:8" + } + ], + "id": 1455, + "name": "FunctionCall", + "src": "395:14:8" + } + ], + "id": 1456, + "name": "ExpressionStatement", + "src": "395:14:8" + }, + { + "attributes": { + "functionReturnParameters": 1450 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "-", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1444, + "type": "uint256", + "value": "a" + }, + "id": 1457, + "name": "Identifier", + "src": "422:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1446, + "type": "uint256", + "value": "b" + }, + "id": 1458, + "name": "Identifier", + "src": "426:1:8" + } + ], + "id": 1459, + "name": "BinaryOperation", + "src": "422:5:8" + } + ], + "id": 1460, + "name": "Return", + "src": "415:12:8" + } + ], + "id": 1461, + "name": "Block", + "src": "389:43:8" + } + ], + "id": 1462, + "name": "FunctionDefinition", + "src": "332:100:8" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "safeAdd", + "payable": false, + "scope": 1570, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1490, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1463, + "name": "ElementaryTypeName", + "src": "453:4:8" + } + ], + "id": 1464, + "name": "VariableDeclaration", + "src": "453:6:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1490, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1465, + "name": "ElementaryTypeName", + "src": "461:4:8" + } + ], + "id": 1466, + "name": "VariableDeclaration", + "src": "461:6:8" + } + ], + "id": 1467, + "name": "ParameterList", + "src": "452:16:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1490, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1468, + "name": "ElementaryTypeName", + "src": "487:4:8" + } + ], + "id": 1469, + "name": "VariableDeclaration", + "src": "487:4:8" + } + ], + "id": 1470, + "name": "ParameterList", + "src": "486:6:8" + }, + { + "children": [ + { + "attributes": { + "assignments": [ + 1472 + ] + }, + "children": [ + { + "attributes": { + "constant": false, + "name": "c", + "scope": 1490, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint", + "type": "uint256" + }, + "id": 1471, + "name": "ElementaryTypeName", + "src": "499:4:8" + } + ], + "id": 1472, + "name": "VariableDeclaration", + "src": "499:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "+", + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1464, + "type": "uint256", + "value": "a" + }, + "id": 1473, + "name": "Identifier", + "src": "508:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1466, + "type": "uint256", + "value": "b" + }, + "id": 1474, + "name": "Identifier", + "src": "512:1:8" + } + ], + "id": 1475, + "name": "BinaryOperation", + "src": "508:5:8" + } + ], + "id": 1476, + "name": "VariableDeclarationStatement", + "src": "499:14:8" + }, + { + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "isStructConstructorCall": false, + "lValueRequested": false, + "names": [ + null + ], + "type": "tuple()", + "type_conversion": false + }, + "children": [ + { + "attributes": { + "argumentTypes": [ + { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + ], + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1569, + "type": "function (bool)", + "value": "assert" + }, + "id": 1477, + "name": "Identifier", + "src": "519:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "&&", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1472, + "type": "uint256", + "value": "c" + }, + "id": 1478, + "name": "Identifier", + "src": "526:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1464, + "type": "uint256", + "value": "a" + }, + "id": 1479, + "name": "Identifier", + "src": "529:1:8" + } + ], + "id": 1480, + "name": "BinaryOperation", + "src": "526:4:8" + }, + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1472, + "type": "uint256", + "value": "c" + }, + "id": 1481, + "name": "Identifier", + "src": "534:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1466, + "type": "uint256", + "value": "b" + }, + "id": 1482, + "name": "Identifier", + "src": "537:1:8" + } + ], + "id": 1483, + "name": "BinaryOperation", + "src": "534:4:8" + } + ], + "id": 1484, + "name": "BinaryOperation", + "src": "526:12:8" + } + ], + "id": 1485, + "name": "FunctionCall", + "src": "519:20:8" + } + ], + "id": 1486, + "name": "ExpressionStatement", + "src": "519:20:8" + }, + { + "attributes": { + "functionReturnParameters": 1470 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1472, + "type": "uint256", + "value": "c" + }, + "id": 1487, + "name": "Identifier", + "src": "552:1:8" + } + ], + "id": 1488, + "name": "Return", + "src": "545:8:8" + } + ], + "id": 1489, + "name": "Block", + "src": "493:65:8" + } + ], + "id": 1490, + "name": "FunctionDefinition", + "src": "436:122:8" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "max64", + "payable": false, + "scope": 1570, + "stateMutability": "view", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1507, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1491, + "name": "ElementaryTypeName", + "src": "577:6:8" + } + ], + "id": 1492, + "name": "VariableDeclaration", + "src": "577:8:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1507, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1493, + "name": "ElementaryTypeName", + "src": "587:6:8" + } + ], + "id": 1494, + "name": "VariableDeclaration", + "src": "587:8:8" + } + ], + "id": 1495, + "name": "ParameterList", + "src": "576:20:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1507, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1496, + "name": "ElementaryTypeName", + "src": "624:6:8" + } + ], + "id": 1497, + "name": "VariableDeclaration", + "src": "624:6:8" + } + ], + "id": 1498, + "name": "ParameterList", + "src": "623:8:8" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1498 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "uint64" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint64", + "typeString": "uint64" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1492, + "type": "uint64", + "value": "a" + }, + "id": 1499, + "name": "Identifier", + "src": "645:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1494, + "type": "uint64", + "value": "b" + }, + "id": 1500, + "name": "Identifier", + "src": "650:1:8" + } + ], + "id": 1501, + "name": "BinaryOperation", + "src": "645:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1492, + "type": "uint64", + "value": "a" + }, + "id": 1502, + "name": "Identifier", + "src": "654:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1494, + "type": "uint64", + "value": "b" + }, + "id": 1503, + "name": "Identifier", + "src": "658:1:8" + } + ], + "id": 1504, + "name": "Conditional", + "src": "645:14:8" + } + ], + "id": 1505, + "name": "Return", + "src": "638:21:8" + } + ], + "id": 1506, + "name": "Block", + "src": "632:32:8" + } + ], + "id": 1507, + "name": "FunctionDefinition", + "src": "562:102:8" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "min64", + "payable": false, + "scope": 1570, + "stateMutability": "view", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1524, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1508, + "name": "ElementaryTypeName", + "src": "683:6:8" + } + ], + "id": 1509, + "name": "VariableDeclaration", + "src": "683:8:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1524, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1510, + "name": "ElementaryTypeName", + "src": "693:6:8" + } + ], + "id": 1511, + "name": "VariableDeclaration", + "src": "693:8:8" + } + ], + "id": 1512, + "name": "ParameterList", + "src": "682:20:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1524, + "stateVariable": false, + "storageLocation": "default", + "type": "uint64", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint64", + "type": "uint64" + }, + "id": 1513, + "name": "ElementaryTypeName", + "src": "730:6:8" + } + ], + "id": 1514, + "name": "VariableDeclaration", + "src": "730:6:8" + } + ], + "id": 1515, + "name": "ParameterList", + "src": "729:8:8" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1515 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "uint64" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint64", + "typeString": "uint64" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "<", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1509, + "type": "uint64", + "value": "a" + }, + "id": 1516, + "name": "Identifier", + "src": "751:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1511, + "type": "uint64", + "value": "b" + }, + "id": 1517, + "name": "Identifier", + "src": "755:1:8" + } + ], + "id": 1518, + "name": "BinaryOperation", + "src": "751:5:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1509, + "type": "uint64", + "value": "a" + }, + "id": 1519, + "name": "Identifier", + "src": "759:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1511, + "type": "uint64", + "value": "b" + }, + "id": 1520, + "name": "Identifier", + "src": "763:1:8" + } + ], + "id": 1521, + "name": "Conditional", + "src": "751:13:8" + } + ], + "id": 1522, + "name": "Return", + "src": "744:20:8" + } + ], + "id": 1523, + "name": "Block", + "src": "738:31:8" + } + ], + "id": 1524, + "name": "FunctionDefinition", + "src": "668:101:8" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "max256", + "payable": false, + "scope": 1570, + "stateMutability": "view", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1541, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1525, + "name": "ElementaryTypeName", + "src": "789:7:8" + } + ], + "id": 1526, + "name": "VariableDeclaration", + "src": "789:9:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1541, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1527, + "name": "ElementaryTypeName", + "src": "800:7:8" + } + ], + "id": 1528, + "name": "VariableDeclaration", + "src": "800:9:8" + } + ], + "id": 1529, + "name": "ParameterList", + "src": "788:22:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1541, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1530, + "name": "ElementaryTypeName", + "src": "838:7:8" + } + ], + "id": 1531, + "name": "VariableDeclaration", + "src": "838:7:8" + } + ], + "id": 1532, + "name": "ParameterList", + "src": "837:9:8" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1532 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": ">=", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1526, + "type": "uint256", + "value": "a" + }, + "id": 1533, + "name": "Identifier", + "src": "860:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1528, + "type": "uint256", + "value": "b" + }, + "id": 1534, + "name": "Identifier", + "src": "865:1:8" + } + ], + "id": 1535, + "name": "BinaryOperation", + "src": "860:6:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1526, + "type": "uint256", + "value": "a" + }, + "id": 1536, + "name": "Identifier", + "src": "869:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1528, + "type": "uint256", + "value": "b" + }, + "id": 1537, + "name": "Identifier", + "src": "873:1:8" + } + ], + "id": 1538, + "name": "Conditional", + "src": "860:14:8" + } + ], + "id": 1539, + "name": "Return", + "src": "853:21:8" + } + ], + "id": 1540, + "name": "Block", + "src": "847:32:8" + } + ], + "id": 1541, + "name": "FunctionDefinition", + "src": "773:106:8" + }, + { + "attributes": { + "constant": true, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "min256", + "payable": false, + "scope": 1570, + "stateMutability": "view", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "a", + "scope": 1558, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1542, + "name": "ElementaryTypeName", + "src": "899:7:8" + } + ], + "id": 1543, + "name": "VariableDeclaration", + "src": "899:9:8" + }, + { + "attributes": { + "constant": false, + "name": "b", + "scope": 1558, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1544, + "name": "ElementaryTypeName", + "src": "910:7:8" + } + ], + "id": 1545, + "name": "VariableDeclaration", + "src": "910:9:8" + } + ], + "id": 1546, + "name": "ParameterList", + "src": "898:22:8" + }, + { + "children": [ + { + "attributes": { + "constant": false, + "name": "", + "scope": 1558, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1547, + "name": "ElementaryTypeName", + "src": "948:7:8" + } + ], + "id": 1548, + "name": "VariableDeclaration", + "src": "948:7:8" + } + ], + "id": 1549, + "name": "ParameterList", + "src": "947:9:8" + }, + { + "children": [ + { + "attributes": { + "functionReturnParameters": 1549 + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "type": "uint256" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "commonType": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "<", + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1543, + "type": "uint256", + "value": "a" + }, + "id": 1550, + "name": "Identifier", + "src": "970:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1545, + "type": "uint256", + "value": "b" + }, + "id": 1551, + "name": "Identifier", + "src": "974:1:8" + } + ], + "id": 1552, + "name": "BinaryOperation", + "src": "970:5:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1543, + "type": "uint256", + "value": "a" + }, + "id": 1553, + "name": "Identifier", + "src": "978:1:8" + }, + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1545, + "type": "uint256", + "value": "b" + }, + "id": 1554, + "name": "Identifier", + "src": "982:1:8" + } + ], + "id": 1555, + "name": "Conditional", + "src": "970:13:8" + } + ], + "id": 1556, + "name": "Return", + "src": "963:20:8" + } + ], + "id": 1557, + "name": "Block", + "src": "957:31:8" + } + ], + "id": 1558, + "name": "FunctionDefinition", + "src": "883:105:8" + }, + { + "attributes": { + "constant": false, + "implemented": true, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "assert", + "payable": false, + "scope": 1570, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "internal" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "assertion", + "scope": 1569, + "stateVariable": false, + "storageLocation": "default", + "type": "bool", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bool", + "type": "bool" + }, + "id": 1559, + "name": "ElementaryTypeName", + "src": "1008:4:8" + } + ], + "id": 1560, + "name": "VariableDeclaration", + "src": "1008:14:8" + } + ], + "id": 1561, + "name": "ParameterList", + "src": "1007:16:8" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1562, + "name": "ParameterList", + "src": "1033:0:8" + }, + { + "children": [ + { + "attributes": { + "falseBody": null + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "isConstant": false, + "isLValue": false, + "isPure": false, + "lValueRequested": false, + "operator": "!", + "prefix": true, + "type": "bool" + }, + "children": [ + { + "attributes": { + "argumentTypes": null, + "overloadedDeclarations": [ + null + ], + "referencedDeclaration": 1560, + "type": "bool", + "value": "assertion" + }, + "id": 1563, + "name": "Identifier", + "src": "1044:9:8" + } + ], + "id": 1564, + "name": "UnaryOperation", + "src": "1043:10:8" + }, + { + "children": [ + { + "children": [], + "id": 1565, + "name": "Throw", + "src": "1063:5:8" + } + ], + "id": 1566, + "name": "Block", + "src": "1055:20:8" + } + ], + "id": 1567, + "name": "IfStatement", + "src": "1039:36:8" + } + ], + "id": 1568, + "name": "Block", + "src": "1033:46:8" + } + ], + "id": 1569, + "name": "FunctionDefinition", + "src": "992:87:8" + } + ], + "id": 1570, + "name": "ContractDefinition", + "src": "25:1056:8" + } + ], + "id": 1571, + "name": "SourceUnit", + "src": "0:1081:8" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.803Z" +} \ No newline at end of file diff --git a/build/contracts/TokenSpender.json b/build/contracts/TokenSpender.json new file mode 100644 index 0000000..d4de775 --- /dev/null +++ b/build/contracts/TokenSpender.json @@ -0,0 +1,239 @@ +{ + "contractName": "TokenSpender", + "abi": [ + { + "constant": false, + "inputs": [ + { + "name": "_from", + "type": "address" + }, + { + "name": "_value", + "type": "uint256" + }, + { + "name": "_token", + "type": "address" + }, + { + "name": "_extraData", + "type": "bytes" + } + ], + "name": "receiveApproval", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + } + ], + "bytecode": "0x", + "deployedBytecode": "0x", + "sourceMap": "", + "deployedSourceMap": "", + "source": "pragma solidity ^0.4.8;\n\ncontract TokenSpender {\n function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);\n}", + "sourcePath": "rlc-token/contracts/TokenSpender.sol", + "ast": { + "attributes": { + "absolutePath": "rlc-token/contracts/TokenSpender.sol", + "exportedSymbols": { + "TokenSpender": [ + 1584 + ] + } + }, + "children": [ + { + "attributes": { + "literals": [ + "solidity", + "^", + "0.4", + ".8" + ] + }, + "id": 1572, + "name": "PragmaDirective", + "src": "0:23:9" + }, + { + "attributes": { + "baseContracts": [ + null + ], + "contractDependencies": [ + null + ], + "contractKind": "contract", + "documentation": null, + "fullyImplemented": false, + "linearizedBaseContracts": [ + 1584 + ], + "name": "TokenSpender", + "scope": 1585 + }, + "children": [ + { + "attributes": { + "body": null, + "constant": false, + "implemented": false, + "isConstructor": false, + "modifiers": [ + null + ], + "name": "receiveApproval", + "payable": false, + "scope": 1584, + "stateMutability": "nonpayable", + "superFunction": null, + "visibility": "public" + }, + "children": [ + { + "children": [ + { + "attributes": { + "constant": false, + "name": "_from", + "scope": 1583, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1573, + "name": "ElementaryTypeName", + "src": "78:7:9" + } + ], + "id": 1574, + "name": "VariableDeclaration", + "src": "78:13:9" + }, + { + "attributes": { + "constant": false, + "name": "_value", + "scope": 1583, + "stateVariable": false, + "storageLocation": "default", + "type": "uint256", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "uint256", + "type": "uint256" + }, + "id": 1575, + "name": "ElementaryTypeName", + "src": "93:7:9" + } + ], + "id": 1576, + "name": "VariableDeclaration", + "src": "93:14:9" + }, + { + "attributes": { + "constant": false, + "name": "_token", + "scope": 1583, + "stateVariable": false, + "storageLocation": "default", + "type": "address", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "address", + "type": "address" + }, + "id": 1577, + "name": "ElementaryTypeName", + "src": "109:7:9" + } + ], + "id": 1578, + "name": "VariableDeclaration", + "src": "109:14:9" + }, + { + "attributes": { + "constant": false, + "name": "_extraData", + "scope": 1583, + "stateVariable": false, + "storageLocation": "default", + "type": "bytes memory", + "value": null, + "visibility": "internal" + }, + "children": [ + { + "attributes": { + "name": "bytes", + "type": "bytes storage pointer" + }, + "id": 1579, + "name": "ElementaryTypeName", + "src": "125:5:9" + } + ], + "id": 1580, + "name": "VariableDeclaration", + "src": "125:16:9" + } + ], + "id": 1581, + "name": "ParameterList", + "src": "77:65:9" + }, + { + "attributes": { + "parameters": [ + null + ] + }, + "children": [], + "id": 1582, + "name": "ParameterList", + "src": "142:0:9" + } + ], + "id": 1583, + "name": "FunctionDefinition", + "src": "53:90:9" + } + ], + "id": 1584, + "name": "ContractDefinition", + "src": "25:120:9" + } + ], + "id": 1585, + "name": "SourceUnit", + "src": "0:145:9" + }, + "compiler": { + "name": "solc", + "version": "0.4.18+commit.9cf6e910.Emscripten.clang" + }, + "networks": {}, + "schemaVersion": "1.0.1", + "updatedAt": "2018-01-31T22:23:17.803Z" +} \ No newline at end of file diff --git a/truffle.js b/truffle.js new file mode 100644 index 0000000..cee669e --- /dev/null +++ b/truffle.js @@ -0,0 +1,53 @@ +'use strict'; + +const oracleJSON = require('iexec-oracle-contract/build/contracts/IexecOracle.json'); + +const ROPSTEN_ORACLE_ADDRESS = oracleJSON.networks['3'].address; +const RINKEBY_ORACLE_ADDRESS = oracleJSON.networks['4'].address; +const KOVAN_ORACLE_ADDRESS = oracleJSON.networks['42'].address; +const MAIN_ORACLE_ADDRESS = oracleJSON.networks['1'].address; +const LOCAL_ORACLE_ADDRESS = 'local_oracle_address_value'; + +module.exports = { + networks: { + development: { + host: 'http://localhost:8545', + port: 8545, + network_id: '*', // Match any network id, + constructorArgs: [LOCAL_ORACLE_ADDRESS], + server: 'https://localhost:443' + }, + ropsten: { + host: 'https://ropsten.infura.io/berv5GTB5cSdOJPPnqOq', + port: 8545, + network_id: '3', + constructorArgs: [ROPSTEN_ORACLE_ADDRESS], + server: 'https://testxw.iex.ec:443' + // gasPriceMultiplier: 2, // use factor 2 of the network estimated gasPrice + // gasLimitMultiplier: 4, // use factor 4 of the network estimated gasLimit + // gasPrice: 21000000000 // manually set the gasPrice in gwei. Prefer 'gasPriceMultiplier' + // gas: 400000 // manually set the gas limit in gwei. Prefer 'gasLimitMultiplier' + }, + rinkeby: { + host: 'https://rinkeby.infura.io/berv5GTB5cSdOJPPnqOq', + port: 8545, + network_id: '4', + constructorArgs: [RINKEBY_ORACLE_ADDRESS], + server: 'https://testxw.iex.ec:443' + }, + kovan: { + host: 'https://kovan.infura.io/berv5GTB5cSdOJPPnqOq', + port: 8545, + network_id: '42', + constructorArgs: [KOVAN_ORACLE_ADDRESS], + server: 'https://testxw.iex.ec:443' + }, + mainnet: { + host: 'https://mainnet.infura.io/berv5GTB5cSdOJPPnqOq ', + port: 8545, + network_id: '1', + constructorArgs: [MAIN_ORACLE_ADDRESS], + server: 'https://mainxw.iex.ec:443' + } + } +}; \ No newline at end of file From bacc91981ade8327cc512703c87fbfcafda2ce64 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 22:40:01 +0000 Subject: [PATCH 33/37] add: initiali contract and cmdline --- contracts/OpenMOLEPi.sol | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 contracts/OpenMOLEPi.sol diff --git a/contracts/OpenMOLEPi.sol b/contracts/OpenMOLEPi.sol new file mode 100644 index 0000000..c2e173d --- /dev/null +++ b/contracts/OpenMOLEPi.sol @@ -0,0 +1,12 @@ +pragma solidity ^0.4.11; +import "iexec-oracle-contract/contracts/IexecOracleAPI.sol"; +contract OpenMOLEPi is IexecOracleAPI{ + + uint public constant DAPP_PRICE = 0; + string public constant DAPP_NAME = "openmolepi"; + + function OpenMOLEPi (address _iexecOracleAddress) IexecOracleAPI(_iexecOracleAddress,DAPP_PRICE,DAPP_NAME){ + + } + +} From a4bf10226488aee095b46f4609d2c0d8f04c443d Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Wed, 31 Jan 2018 23:35:07 +0000 Subject: [PATCH 34/37] add: initial version of openmole Pi calculation --- apps/OpenMOLEPi | 24 ++++++++++++++++++++++++ build/contracts/OpenMOLEPi.json | 2 +- iexec.js | 4 ++-- 3 files changed, 27 insertions(+), 3 deletions(-) create mode 100755 apps/OpenMOLEPi diff --git a/apps/OpenMOLEPi b/apps/OpenMOLEPi new file mode 100755 index 0000000..913d431 --- /dev/null +++ b/apps/OpenMOLEPi @@ -0,0 +1,24 @@ +#!/bin/bash + +BASE_DIR="$(pwd)" + +wget https://openmole.org/openmole.tar.gz +tar zxf openmole.tar.gz +rm openmole.tar.gz + +cd openmole || exit 1 + +mkdir -p java_om && tar zxf runtime/jvm-x64.tar.gz -C java_om +JAVA_HOME="$(pwd)/java_om/jre" +PATH="${JAVA_HOME}/bin:${PATH}" + +export JAVA_HOME PATH +java -version + +wget https://raw.githubusercontent.com/openmole/openmole-market/7-dev/pi/Pi.oms +pi_avg=$(./openmole --password "" --script ./Pi.oms | tail -n1 | sed -e 's/.*\([0-9]\+\.[0-9]\+\).*/\1/g') + +echo "${pi_avg}" + +cd "${BASE_DIR}" && rm -rf openmole + diff --git a/build/contracts/OpenMOLEPi.json b/build/contracts/OpenMOLEPi.json index 925222a..c21b9d5 100644 --- a/build/contracts/OpenMOLEPi.json +++ b/build/contracts/OpenMOLEPi.json @@ -432,7 +432,7 @@ }, "networks": { "3": { - "address": "0x5445dd04c7ed17690f3ec2480782cee44122f044" + "address": "0xf688925b5b94a2a2a4aaabf3b712bdda4ca8aef1" } }, "schemaVersion": "1.0.1", diff --git a/iexec.js b/iexec.js index 7d6b547..10419c0 100644 --- a/iexec.js +++ b/iexec.js @@ -1,11 +1,11 @@ module.exports = { - name: 'MyContract', +name:'OpenMOLEPi', data: { type: 'BINARY', cpu: 'AMD64', os: 'LINUX', }, work: { - cmdline: '10', + cmdline: '', } }; From abca1c36e3bcc9ea3b420d0e1d5965e692e884fb Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Thu, 1 Feb 2018 00:45:36 +0000 Subject: [PATCH 35/37] enh: describe Pi estimation in DApp README --- apps/README.md | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/apps/README.md b/apps/README.md index bc23275..11af2d1 100644 --- a/apps/README.md +++ b/apps/README.md @@ -1,7 +1,12 @@ -Your iExec Dapp is composed of two parts: +## Estimation of Pi via a Monte Carlo method -* under the ```apps``` directory : -Put the offchain app (any kind of legacy application). The offchain app will be executed by the iExec decentralized cloud. +This workflow exposes how to compute an estimation of Pi usign a Monte-Carlo estimation of Pi. The computation task is a Scala task using a self contained code. The workflow computes 100 independant executions of this task using randomly generated seeds for the random number generator. It produces 100 independant realisation of the Monte-Caro estimation. Then the workflow gathers them in a vector and computes an average on the values of the vector. Finally the result is displayed on the standard output. + +[Original source](https://github.com/openmole/openmole-market/tree/7-dev/pi) + +## Deployment + +`iexec deploy` +`iexec submit` +`iexec result txID --save` # will return an approximate value of Pi in stdout.txt` -* under the ```contracts``` directory : -A smart contract that interfaces with your iExec Dapp, it will serve as a gateway from Ethereum to your offchain app. From 0af1788fdb6e98194773cc2d4e9b3e42427b4de4 Mon Sep 17 00:00:00 2001 From: Jonathan Passerat-Palmbach Date: Thu, 1 Feb 2018 01:17:59 +0000 Subject: [PATCH 36/37] add: README describing challenge entry --- README.md | 117 ++++++++++++++++++++++++++++------- images/component_diagram.png | Bin 0 -> 481181 bytes images/sequence_diagram.png | Bin 0 -> 111396 bytes 3 files changed, 96 insertions(+), 21 deletions(-) create mode 100644 images/component_diagram.png create mode 100644 images/sequence_diagram.png diff --git a/README.md b/README.md index 0b0e6dc..e6d1318 100644 --- a/README.md +++ b/README.md @@ -1,28 +1,103 @@ -# iExec dapp samples -## 1 branch = 1 dapp +# Submission to DApp challenge: the OpenMOLE scientific platform, decentralised model exploration and parameter tuning on the iEx.ec network -Each branch of this repo is a sample iExec dapp, and can be easily played with by using the [iexec sdk cli](https://github.com/iExecBlockchainComputing/iexec-sdk) like this: -```iexec init branchName``` +## Idea proposal +[OpenMOLE](https://www.openmole.org) is a generic scientific exploration platform with a strong support for High-Throughput Computing environments. Its principal purpose is to provide advanced **model exploration methods and parameter tuning** based on distributed genetic algorithms. OpenMOLE exposes a workflow formalism to describe the experiments and as such, can serve as a generic description language for processing pipelines. +The power of OpenMOLE is further expressed in its ability to **automatically introduce parallelism to the underlying applications**. We exploit the intrinsic parallel aspect of data parallel problems without having to modify the target application’s source code. Studied applications are viewed as black-boxes by the platform, which ensures the required inputs and outputs travel to the remote execution nodes. -```bash -iexec init # current branch containing minimum working config -iexec init factorial # download and init factorial dapp -iexec init echo # download and init echo dapp -``` +The typical uses of OpenMOLE are **model calibration, model exploration, machine learning, optimisation and data processing**. End-users can specify the execution environment for each stage of the experiment. OpenMOLE currently supports clusters (Slurm, HT Condor, PBS, …) and grids such as the **European Grid Infrastructure (EGI)**. -Start a [Pull Request](https://github.com/iExecBlockchainComputing/iexec-dapp-samples/pulls) to add you dapp to this repo. +This project proposal introduces an OpenMOLE DApp leveraging the computing resources of the iEx.ec network to decentralise the execution of OpenMOLE’s **scientific use-cases**. -## [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) +## Background +Over the last 10 years, we have developed an expertise in distributed computing through our respective research interests requiring large quantities of processing power. These efforts are gathered in the scientific platform OpenMOLE, an open source software leveraging **distributed computing to explore large parameter spaces** using state of the art methods. +OpenMOLE has been used to calibrate simulation models through the use of large scale distributed computing environments (http://journals.sagepub.com/doi/10.1068/b130064p). Our current setup enables users to delegate their compute-intensive tasks to local clusters (*e.g.* via Slurm, HT Condor, *etc.*) as well the European Grid Infrastructure (EGI). - * Go checkout the [iExec Dapp Challenge](https://medium.com/iex-ec/the-iexec-%C3%B0app-challenge-150k-of-grants-to-win-abf6798b31ee) - * Go submit a request to be listed on the [iExec dapp store](https://dapps.iex.ec/) +Working with heterogeneous computing environments such as the EGI has led us to build advanced task (re-)submission, file transfers and automatic results retrieval mechanism in OpenMOLE. +As strong advocates of **reproducible science**, we recently published a method to reproduce **[neuroimaging experiments at scale](http://journal.frontiersin.org/article/10.3389/fninf.2017.00021/full#)** with the OpenMOLE platform. It focuses on providing a standalone solution mimicking the packaging features provided by traditional container solutions such as Docker and Singularity, without relying on a pre-installed piece of software on the execution host. This work allowed us to develop an **expertise to package complex scientific pipelines**. Further research building on this initial achievement has resulted in techniques to manipulate docker images on restricted environments where no docker installation is available (*to be published*, an early description is available [in the documentation](https://next.openmole.org/Container.html)). ---- -# My Dapp name -## Description -My Dapp description here... -## Dapp params -An example of a iexec.js conf -## [Examples](./examples) -A link to all iexec.js conf examples for the dapp. +Another aspect of our research embedded in OpenMOLE is the conception of Evolutionary/Genetic Algorithms (EA/GA) based optimisation methods. These methods provide support for **Parameter exploration**. As models become more and more complex, they display a large number of parameters. Most of the time, finding the best parameter settings rely on the expert's knowledge. However, this might not be the optimal set of parameters, or an expert choice can hide some aspects of the model. Using scientific exploration platforms like OpenMOLE is a way for scientists to understand their models better. In some cases, it's even the only way to study a model. + +Beyond parameter tuning, we have proposed a novel method to explore [all possible behaviour of a given model](http://journals.plos.org/plosone/article?id=10.1371/journal.pone.0138212). While OpenMOLE roots in the modelling and simulation community, it has proved to be generic enough to be employed to address problems in various scientific fields ranging from [geography and social sciences](http://jasss.soc.surrey.ac.uk/18/4/9.html) to [biomedical image analysis](https://hal.inria.fr/hal-01099220/). + +Today we aim to bring the optimisation and parameter space exploration methods at the heart of the OpenMOLE ecosystem to the iEx.ec platform. We believe our joint expertise in modelling and simulation, optimisation methods and distributed computing places us in a unique position to build the **first scientific DApp on the iEx.ec DApp store**. + +## Roadmap +We expect to provide a first prototype of our solution for Q3 2018. Further refinements will be made based on the initial feedback in order to release a beta version in Q4 2018. + +The steps taken will be as follows: + +1. Preliminary version running OpenMOLE on the iEx.ec worker nodes and fetching a predefined execution context: a simple task from the OpenMOLE marketplace estimating the value of Pi using a Monte Carlo method. At this stage, we only consider the OpenMOLE components running on the worker nodes. The user will not interact with the OpenMOLE web platform, but will instead directly use the iEx.ec SDK to vary the input parameters of the application. **This is the state at the time of submission**. + +2. Integrate the iEx.ec SDK in OpenMOLE. An initial version will embed the iEx.ec NodeJS application in OpenMOLE and call it as an external process to submit new jobs to the network. We will discuss with the iEx.ec team the possibility to see the SDK translated to other languages in the future. The job’s configuration as JSON files will be automatically generated by the platform, and passed to the `iexec-submit` command. +This **second milestone** is reusing the Pi simulation, and will automatically create a test wallet and fill it with test ETH/RLC. + +3. Manage the iEx.ec wallet from OpenMOLE’s authentications mechanism. The user should be able to retrieve his iEx.ec wallet from the OpenMOLE interface and define the same limits as from the SDK regarding his RLC spending cap. The user’s private key will never travel away from his machine and will be stored encrypted in OpenMOLE’s preferences. This will enable **transparent task submissions** to the iEx.ec network from the OpenMOLE web interface. + +4. Our **fourth milestone (M4)** will start tackling **input data management**. Up until now, a single application was considered and manually serialised to the iEx.ec network along with the OpenMOLE runtime. Milestone **M4** will bring the possibility to serialise tasks described from the OpenMOLE web interface, and provide them to the iEx.ec platform upon submission. We will reuse mechanisms such as `dirinuri` to transfer the data or any better scheme suggested by the iEx.ec team. Upon completion of **M4**, it will be possible to delegate the execution of generic tasks, involving no or low data transfers, to the iEx.ec network. + + +5. Milestone **M5** will strengthen the data management component of our solution. We expect this to be in line with iEx.ec’s developments towards V3 of the network. OpenMOLE should be able to upload the user’s data to a decentralised storage managed either by iEx.ec or the OpenMOLE project. An initial version will manually spawn and maintain *IPFS* nodes (or equivalent), before switching to iEx.ec’s solution. + +6. With larger data managed, the **OpenMOLE DApp** will be ready for deployment on the App Store. The final milestone (**M6**) will define a monetisation scheme for OpenMOLE in accordance with other practices on the iEx.ec network and the input from the team. It should be the opportunity to involve a larger community of beta-testers, and incorporate their useful feedback. + + +## Estimated timeline + +- M1: February 2018 +- M2: March 2018 +- M3: April 2018 +- M4: June 2018 +- M5: Q3 2018 +- M6: Q4 2018 + + +## Diagrams + +### Component diagram + +Below is a component diagram giving a high level view of the elements interacting in our proposal. + +![component_diagram](images/component_diagram.png) + +### Sequence diagram + +To visually express the flow which the desired program will have, the sequence diagram below sketches a scenario involving two iEx.ec worker nodes. The storage location is a modular +component and will be further investigated in the implementation stage. + + +![sequence_diagram](images/sequence_diagram.png) + +## Benefits for iEx.ec + +Our submission will bring multiple valuable assets to the iEx.ec network. + +- A **scientific DApp** introducing the network to scientists not yet familiar with web3 technologies. +- An **entry point** for other applications lacking the expertise to bring their software to the iEx.ec network. They can rely on OpenMOLE to delegate their workload to the iEx.ec network. +- An extensive roadmap that can lead to a **generic support of Map/Reduce applications**, and refining the task and data management specifications. + + +## Team + +- Romain Reuillon +CNRS Researcher at Géographie-cité and ISC-PIF. Scientific Manager of the OpenMOLE platform leader of the development for Scientific simulation and computing, he developed both MGO and GridScale. + +- Mathieu Leclaire +CNRS Researcher Engineer at ISC-PIF (UPS 3611) and Géographie-cité (UMR 8504). Developer of the OpenMOLE Platform, he developed both the Scaladget library and ScalaWUI skeleton. + +- [Jonathan Passerat-Palmbach](https://jopasser.at) +Research associate at Imperial College London, in the BioMedIA group. Developer of the OpenMOLE Platform, he co-developed GridScale. + +- Karow Maruf +MEng student at Imperial College London. + + +## Bonus + +**Don't take our words for granted!** You can already estimate the value of Pi on the iEx.ec test network with our [very early implementation (M0)](apps/README.md). + +## References + +- [1] [OpenMOLE website](https://www.openmole.org) +- [2] [OpenMOLE code base and related projects](https://github.com/openmole) +- [3] [The academic papers mentioned in this document](https://openmole.org/Communications.html) diff --git a/images/component_diagram.png b/images/component_diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..8dcaab5b7c4f26fd6781fe586bb0e03de3c30780 GIT binary patch literal 481181 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 W5@n_i)vLwH{mqOmjWVV<2mKGQSP_{3 literal 0 HcmV?d00001 diff --git a/images/sequence_diagram.png b/images/sequence_diagram.png new file mode 100644 index 0000000000000000000000000000000000000000..a92faf1ec3f79b40c423aa2ea4dbb4b3e5ea78f3 GIT binary patch literal 111396 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 Date: Thu, 1 Feb 2018 01:43:08 +0000 Subject: [PATCH 37/37] fix: usage instructions for example --- apps/README.md | 11 ++++++++--- build/contracts/OpenMOLEPi.json | 2 +- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/apps/README.md b/apps/README.md index 11af2d1..3c2a585 100644 --- a/apps/README.md +++ b/apps/README.md @@ -6,7 +6,12 @@ This workflow exposes how to compute an estimation of Pi usign a Monte-Carlo est ## Deployment -`iexec deploy` -`iexec submit` -`iexec result txID --save` # will return an approximate value of Pi in stdout.txt` +```shell +iexec wallet create +iexec wallet getETH +iexec wallet getRLC +iexec deploy # if you've modified the app +iexec submit +iexec result --save # will return an approximate value of Pi in stdout.txt +``` diff --git a/build/contracts/OpenMOLEPi.json b/build/contracts/OpenMOLEPi.json index c21b9d5..e608ab3 100644 --- a/build/contracts/OpenMOLEPi.json +++ b/build/contracts/OpenMOLEPi.json @@ -432,7 +432,7 @@ }, "networks": { "3": { - "address": "0xf688925b5b94a2a2a4aaabf3b712bdda4ca8aef1" + "address": "0xf7151c982a6ff336991cf2c286a82b7c8a592428" } }, "schemaVersion": "1.0.1",