From 6073cb82c94e774cb27e09dd7c7721f9f07e1cc6 Mon Sep 17 00:00:00 2001 From: D-Nice Date: Fri, 29 Jun 2018 12:24:59 -0400 Subject: [PATCH 01/14] Update to use Android proof type --- solidity/KrakenPriceTicker.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solidity/KrakenPriceTicker.sol b/solidity/KrakenPriceTicker.sol index 3556a9e1..b479d7ef 100644 --- a/solidity/KrakenPriceTicker.sol +++ b/solidity/KrakenPriceTicker.sol @@ -17,7 +17,7 @@ contract KrakenPriceTicker is usingOraclize { event NewKrakenPriceTicker(string price); function KrakenPriceTicker() public { - oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS); + oraclize_setProof(proofType_Android | proofStorage_IPFS); update(); } From 73413f71a398eb75a14307082a34a24aecdc6a1c Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Wed, 11 Jul 2018 15:38:58 +0100 Subject: [PATCH 02/14] Remove duplicate import & pragma statements --- solidity/YoutubeViews.sol | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/solidity/YoutubeViews.sol b/solidity/YoutubeViews.sol index 842abe45..a103afd1 100644 --- a/solidity/YoutubeViews.sol +++ b/solidity/YoutubeViews.sol @@ -5,12 +5,6 @@ for a given Youtube video. */ - -pragma solidity ^0.4.0; - -import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; - - pragma solidity ^0.4.0; import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; @@ -38,4 +32,4 @@ contract YoutubeViews is usingOraclize { NewOraclizeQuery("Oraclize query was sent, standing by for the answer.."); oraclize_query("URL", 'html(https://www.youtube.com/watch?v=9bZkp7q19f0).xpath(//*[contains(@class, "watch-view-count")]/text())'); } -} \ No newline at end of file +} From e12d22903558860da8dde2dbf9b7a39db2734c85 Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Tue, 24 Jul 2018 14:19:07 +0100 Subject: [PATCH 03/14] standardise contract & file naming --- solidity/Swarm.sol | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/solidity/Swarm.sol b/solidity/Swarm.sol index 1a9e6a4d..c427c451 100644 --- a/solidity/Swarm.sol +++ b/solidity/Swarm.sol @@ -6,14 +6,14 @@ pragma solidity ^0.4.0; import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; -contract swarmExample is usingOraclize { +contract Swarm is usingOraclize { string public swarmContent; event newOraclizeQuery(string description); event newSwarmContent(string swarmContent); - function swarmExample() { + function Swarm() { update(); } From 6637ea11c20c9b1930b1b039179f2cd8c4d663fa Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Fri, 27 Jul 2018 11:58:23 +0100 Subject: [PATCH 04/14] standardise file & contract namings --- ...getBitcoinAddressBalance.sol => BitcoinAddressBalance.sol} | 0 .../computation-datasource/delegatedMath/delegatedMath.sol | 4 ++-- solidity/computation-datasource/url-requests/urlRequests.sol | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) rename solidity/computation-datasource/bitcoin/{getBitcoinAddressBalance.sol => BitcoinAddressBalance.sol} (100%) diff --git a/solidity/computation-datasource/bitcoin/getBitcoinAddressBalance.sol b/solidity/computation-datasource/bitcoin/BitcoinAddressBalance.sol similarity index 100% rename from solidity/computation-datasource/bitcoin/getBitcoinAddressBalance.sol rename to solidity/computation-datasource/bitcoin/BitcoinAddressBalance.sol diff --git a/solidity/computation-datasource/delegatedMath/delegatedMath.sol b/solidity/computation-datasource/delegatedMath/delegatedMath.sol index 6cf16f78..51f0f011 100644 --- a/solidity/computation-datasource/delegatedMath/delegatedMath.sol +++ b/solidity/computation-datasource/delegatedMath/delegatedMath.sol @@ -7,11 +7,11 @@ pragma solidity ^0.4.0; import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; -contract DelegatedMathExample is usingOraclize { +contract DelegatedMath is usingOraclize { event operationResult(uint _result); - function DelegatedMathExample() { + function DelegatedMath() { oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS); delegateOperation("32", "125"); } diff --git a/solidity/computation-datasource/url-requests/urlRequests.sol b/solidity/computation-datasource/url-requests/urlRequests.sol index 369b1fa2..e5f35101 100644 --- a/solidity/computation-datasource/url-requests/urlRequests.sol +++ b/solidity/computation-datasource/url-requests/urlRequests.sol @@ -10,12 +10,12 @@ pragma solidity ^0.4.0; import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; -contract UrlRequestsComputation is usingOraclize { +contract UrlRequests is usingOraclize { event newOraclizeQuery(string description); event emitResult(string result); - function UrlRequestsComputation() payable { + function UrlRequests() payable { oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS); } From bd84ab46b1c4c64fc89533bdcb6bc90ef53fd7ad Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Fri, 27 Jul 2018 17:19:35 +0100 Subject: [PATCH 05/14] Standardise naming across repo --- .../{BitcoinAddressBalance.sol => BitcoinAddressExample.sol} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename solidity/computation-datasource/bitcoin/{BitcoinAddressBalance.sol => BitcoinAddressExample.sol} (100%) diff --git a/solidity/computation-datasource/bitcoin/BitcoinAddressBalance.sol b/solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol similarity index 100% rename from solidity/computation-datasource/bitcoin/BitcoinAddressBalance.sol rename to solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol From 4df75e6fec06df34df4272972a6b82ab9511d0fc Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Fri, 27 Jul 2018 17:23:40 +0100 Subject: [PATCH 06/14] Standardise naming across repo --- .../delegatedMath/{delegatedMath.sol => DelegatedMath.sol} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename solidity/computation-datasource/delegatedMath/{delegatedMath.sol => DelegatedMath.sol} (100%) diff --git a/solidity/computation-datasource/delegatedMath/delegatedMath.sol b/solidity/computation-datasource/delegatedMath/DelegatedMath.sol similarity index 100% rename from solidity/computation-datasource/delegatedMath/delegatedMath.sol rename to solidity/computation-datasource/delegatedMath/DelegatedMath.sol From aecb0ed409121aad3c6afe2742282c86e6777060 Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Fri, 27 Jul 2018 17:24:16 +0100 Subject: [PATCH 07/14] Standardise naming across repo --- .../url-requests/{urlRequests.sol => UrlRequests.sol} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename solidity/computation-datasource/url-requests/{urlRequests.sol => UrlRequests.sol} (100%) diff --git a/solidity/computation-datasource/url-requests/urlRequests.sol b/solidity/computation-datasource/url-requests/UrlRequests.sol similarity index 100% rename from solidity/computation-datasource/url-requests/urlRequests.sol rename to solidity/computation-datasource/url-requests/UrlRequests.sol From 9ef6d27214d4b2847be8173239a8d0a9c34bad58 Mon Sep 17 00:00:00 2001 From: gregkapka Date: Fri, 31 Aug 2018 20:02:42 +0100 Subject: [PATCH 08/14] add gas-price-oracle & sundry files to ethereum examples rearrange readme --- solidity/gas-price-oracle/README.md | 67 + .../contracts/GasPriceOracle.sol | 409 ++ .../gas-price-oracle/contracts/Migrations.sol | 24 + .../contracts/imported/strings.sol | 718 +++ .../contracts/imported/usingOraclize.sol | 1230 ++++ .../gas-price-oracle-tests.jpg | Bin 0 -> 627423 bytes .../migrations/1_initial_migration.js | 2 + .../migrations/2_deploy_contracts.js | 12 + solidity/gas-price-oracle/package-lock.json | 5650 +++++++++++++++++ solidity/gas-price-oracle/package.json | 38 + .../test/1-gas-price-oracle-basics.test.js | 335 + .../test/2-gas-price-oracle-stale.test.js | 149 + solidity/gas-price-oracle/test/utils.js | 32 + solidity/gas-price-oracle/truffle.js | 47 + 14 files changed, 8713 insertions(+) create mode 100644 solidity/gas-price-oracle/README.md create mode 100644 solidity/gas-price-oracle/contracts/GasPriceOracle.sol create mode 100644 solidity/gas-price-oracle/contracts/Migrations.sol create mode 100644 solidity/gas-price-oracle/contracts/imported/strings.sol create mode 100644 solidity/gas-price-oracle/contracts/imported/usingOraclize.sol create mode 100755 solidity/gas-price-oracle/gas-price-oracle-tests.jpg create mode 100644 solidity/gas-price-oracle/migrations/1_initial_migration.js create mode 100644 solidity/gas-price-oracle/migrations/2_deploy_contracts.js create mode 100644 solidity/gas-price-oracle/package-lock.json create mode 100644 solidity/gas-price-oracle/package.json create mode 100644 solidity/gas-price-oracle/test/1-gas-price-oracle-basics.test.js create mode 100644 solidity/gas-price-oracle/test/2-gas-price-oracle-stale.test.js create mode 100644 solidity/gas-price-oracle/test/utils.js create mode 100644 solidity/gas-price-oracle/truffle.js diff --git a/solidity/gas-price-oracle/README.md b/solidity/gas-price-oracle/README.md new file mode 100644 index 00000000..33b965ac --- /dev/null +++ b/solidity/gas-price-oracle/README.md @@ -0,0 +1,67 @@ +# __A Gas Price Oracle leveraging Oraclize__ +  + +## :computer: __What this is:__ + +Designed for the ethereum community, this is an Oraclize-powered and Oraclize-funded ethereum gas-price oracle for providing ate on-chain gas prices. The smart-contract allows anyone to query the EthGasStation.info for up-to-date gas prices at any time - other smart-contracts can make queries too! In addition, an ongoing recursive query funded by Oraclize will ensure the latest gas prices are updated in the contract every six hours - enjoy! + + +  + +--- + +  + +### :fuelpump: __Gas Prices__: + +**❍** Requires ~ 3,600,000 gas for deployment. + +**❍** Gas for normal query to gas station is ~ 111,000. + +**❍** Gas for restarting the recursive chain is ~~170,000~~ 111,000 too now. + +**❍** _Recursive_ callbacks cost ~170409 so limit is 171000. + +**❍** _Non recursive_ callbacks cost ~ 85,350 so their limit is set at 87,000. + +**❍** Recursive restarting queries also refund excess ETH, meaning if the recursions stopped due to insufficient ETH balance, it should be topped up first. + +  + +*** + +  + + + +### :mortar_board: __Instructions to test:__ + +![The passing tests!!](gas-price-oracle-tests.jpg) + +**Pre-flight.** Make sure you have Truffle 5 installed globally: + +**`❍ npm install -g truffle@beta`** + +**1.** Clone the ethereum-examples repo: + +**`❍ git clone https://github.com/oraclize/ethereum-examples.git`** + +**2.** Switch into the gas-price-oracle directory: + +**`❍ cd ethereum-examples/solidity/gas-price-oracle`** + +**3.** Install dependencies: + +**`❍ npm install`** + +**4.** Start Truffle via: + +**`❍ truffle develop`** + +**5.** Start the Ethereum bridge in a new console via: + +**`❍ npm run bridge`** + +**6.** Once bridge is spooled up, back to first console to run the tests via: + +**`❍ truffle_develop> test`** \ No newline at end of file diff --git a/solidity/gas-price-oracle/contracts/GasPriceOracle.sol b/solidity/gas-price-oracle/contracts/GasPriceOracle.sol new file mode 100644 index 00000000..3a66ff7b --- /dev/null +++ b/solidity/gas-price-oracle/contracts/GasPriceOracle.sol @@ -0,0 +1,409 @@ +pragma solidity 0.4.24; + +import "./imported/strings.sol"; +import "./imported/usingOraclize.sol"; + +/** + * @title SafeMath + * @dev Math operations with safety checks that throw on error + */ +library SafeMath { + /** + * @notice Multiplies two numbers, throws on overflow. + * + */ + function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) { + // Gas optimization: this is cheaper than asserting 'a' not being zero, but the + // benefit is lost if 'b' is also tested. + // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 + if (_a == 0) return 0; + c = _a * _b; + require(c / _a == _b, 'SafeMath multiplication threw!'); + return c; + } + /** + * @notice Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend). + * + */ + function sub(uint256 _a, uint256 _b) internal pure returns (uint256) { + require(_b <= _a, 'SafeMath subtraction threw!'); + return _a - _b; + } +} +/** + * @title GasPriceOracle + * + * @notice A contract for querying ethereum gas prices from the ETH + * Gas Station. Recursive Oraclize calls will retrieve the + * latest prices at 6 hourly intervals. In addition, any + * interested party is able to call the `updateGasPrices` + * function at any time to update the prices. + * + * @dev The contract exposes the public, view functions: + * `getSafeLowPrice`, `getStandardPrice` & `getFastPrice` + * each of which return their respective gas prices in Wei, + * and as type uint256. The `getGasPrices` function returns + * a tuple with all three gas prices in Wei as uint256, ordered + * from slowest to fastest, as well as the time the prices were + * last updated. The `getLastUpdated` function returns the time + * when the gas prices were last updated, as a UTC timestamp + * of type uint256. + * + */ +contract GasPriceOracle is usingOraclize { + using strings for *; + using SafeMath for *; + + uint constant public interval = 6; + uint constant public gasLimit = 187000; + uint constant public gasLimitRec = 200000; + uint constant public conversionFactor = 100000000; + string constant public queryString = "json(https://ethgasstation.info/json/ethgasAPI.json).[safeLow,average,fast]"; + + GasStationPrices public gasStationPrices; + + struct GasStationPrices { // 100 mwei prices inherited from ethgasstation + uint64 safeLow; // gas price * 100 mwei for a transaction time < 30 minutes + uint64 standard; // gas price * 100 mwei for a transaction time < 5 minutes + uint64 fast; // gas price * 100 mwei for a transaction time < 2 minutes + uint64 timeUpdated; // timestamp of when the current prices were last updated. + } + + mapping(bytes32 => QueryIDs) public queryIDs; + + struct QueryIDs { + bool isManual; + bool isProcessed; + bool isRevival; + uint64 dueAt; + uint128 gasPriceUsed; + } + + bytes32 public nextRecursiveQuery; + + event LogInsufficientBalance(); + event LogGasPricesUpdated(uint64 safeLowPrice, uint64 standardPrice, uint64 fastPrice, bytes32 queryID, bytes IPFSMultihash); + /** + * @notice Constructor. Sets the Oraclize proof type, and + * initializes the gas price struct with dummy + * values. This standardises the gas cost of the + * __callback function. + * + * @param _gasPrice Desired gas price for first recursive + * Oraclize call. + * + */ + constructor(uint _gasPrice) public payable { + oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS); + nextRecursiveQuery = keccak256('Oraclize Gas Price Oracle'); + gasStationPrices = GasStationPrices({ + safeLow: uint64(1234), + standard: uint64(1234), + fast: uint64(1234), + timeUpdated: uint64(1) + }); + recursivelyUpdateGasPrices(0, _gasPrice); + } + /** + * @notice Allows anyone to update the gas prices stored in + * this contract at any time. Caller must provide + * enough ETH to cover the cost of the Oraclize query. + * If the recursive queries have gone stale the query + * made here will automatically begin the recursion + * anew if the fast gas price in the gas prices struct + * is sufficient. The function refunds any excess ETH + * above the price of the Oraclize query to the sender. + * + */ + function updateGasPrices() public payable { + updateGasPrices(0); + } + /** + * @notice Allows anyone to update the gas prices stored in + * this contract at any time, with a delay of their + * choosing. Caller must provide enough ETH to cover + * the cost of the Oraclize query. Any extra ETH over + * the price of the query is refunded. If the recursive + * queries have gone stale, any query sent with a 0 + * delay may become eligible to restart the recursion + * if the fast gas price in the gas prices struct is + * sufficient. This function refunds any excess ETH + * above the price of the Oraclize query to the sender. + * + * @param _delay The time the callback of the query is desired. + * Can either be a UTC timestamp, or an offset + * in seconds from now. Delays cannot exceed a + * maximum of 60 days. + * + */ + function updateGasPrices(uint _delay) public payable { + updateGasPrices(_delay, getFastPrice()); + } + /** + * @notice Allows anyone to update the gas prices stored in + * this contract at any time, with a delay of their + * choosing and a gas price of their choosing. Caller + * must provide enough ETH to cover the cost of the + * Oraclize query. If the recursive queries have gone + * stale, any query sent with a 0 delay and a gas price + * higher than the gas price used in the previous + * recursive query will restart the recursive queries. + * This function returns any exccess ETH above the price + * of the Oraclize query to the sender. + * + * @param _delay The time the callback of the query is desired. + * Can either be a UTC timestamp, or an offset + * in seconds from now. Delays cannot exceed a + * maximum of 60 days. + * + * @param _gasPrice Sets a custom gas price desired for the + * query, in Wei. + * + */ + function updateGasPrices(uint _delay, uint _gasPrice) public payable { + if ( + _delay == 0 && + isRecursiveStale() && + _gasPrice >= queryIDs[nextRecursiveQuery].gasPriceUsed + (1 * 10 ** 9) && + getQueryPrice(gasLimitRec, _gasPrice) <= msg.value + ) { + bool successful = recursivelyUpdateGasPrices(_delay, _gasPrice); // query usable to restart stale recursive ones + if (successful) { + queryIDs[nextRecursiveQuery].isRevival = true; + msg.sender.transfer(msg.value.sub(getQueryPrice(gasLimitRec))); + } + } else { + oraclize_setCustomGasPrice(_gasPrice); + bytes32 qID = oraclize_query( + _delay, + "computation", + [ + "json(QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE).[safeLow,average,fast]", + "GET", + "https://ethgasstation.info/json/ethgasAPI.json" + ], + gasLimit + ); + queryIDs[qID].isManual = true; + queryIDs[qID].dueAt = _delay > now + ? uint64(_delay) + : uint64(now + _delay); + msg.sender.transfer(msg.value.sub(getQueryPrice(gasLimit))); + } + } + /** + * @notice Allows the contract to automatically update the gas prices + * stored herein. Contract balance must be sufficient to + * cover the cost of the Oraclize query. + * + * @param _delay The time the callback of the query is desired. + * Can either be a UTC timestamp, or an offset + * in seconds from now. Delays cannot exceed a + * maximum of 60 days. + * + * @param _gasPrice Sets a custom gas price desired for the + * query, in Wei. + * + * @return bool Whether the function call was successful or not. + * + */ + function recursivelyUpdateGasPrices(uint _delay, uint _gasPrice) private returns (bool) { + oraclize_setCustomGasPrice(_gasPrice); + uint cost = getQueryPrice(gasLimitRec); + if (address(this).balance < cost && msg.value < cost) { + emit LogInsufficientBalance(); + return; + } + bytes32 qID = oraclize_query( + _delay, + "computation", + [ + "json(QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE).[safeLow,average,fast]", + "GET", + "https://ethgasstation.info/json/ethgasAPI.json" + ], + gasLimitRec + ); + nextRecursiveQuery = qID; + queryIDs[qID].dueAt = uint64(now + _delay); + queryIDs[qID].gasPriceUsed = uint128(_gasPrice); + return true; + } + /** + * @notice Allows both users and this contract to discover the + * price of the Oraclize query before making it, in + * order to supply the call with the correct amount of ETH. + * + * @param _limit Gas limit required for the __callback function. + * + * @return uint The cost of the Oraclize query in Wei. + * + */ + function getQueryPrice(uint _limit) public view returns (uint) { + return oraclize_getPrice("computation", _limit); + } + /** + * @notice Allows both users and this contract to discover the + * price of the Oraclize query before making it, in + * order to supply the call with the correct amount of ETH. + * + * @param _limit Gas limit required for the __callback function. + * + * @param _price Custom gas price for the Oraclize query. + * + * @return uint The cost of the Oraclize query in Wei. + * + */ + function getQueryPrice(uint _limit, uint _price) public view returns (uint) { + oraclize_setCustomGasPrice(_price); + return oraclize_getPrice("computation", _limit); + } + /** + * @notice Checks whether the currently pending recursive Oraclize + * query is past due by greater than 45 minutes or not. + * Should recursion have lapsed, zero delay user queries + * are used to restart the recursion. Such cases are considered + * instantly stale allowing subsequent, higher gas priced + * queries to take priority in restarting recursion. + * + * @return bool Whether or not the current recursive query is + * past due or replacable. + * + */ + function isRecursiveStale() public view returns (bool) { + return now > queryIDs[nextRecursiveQuery].dueAt + 2700 || + queryIDs[nextRecursiveQuery].isRevival; + } + /** + * @notice Oraclize callback function. Only callable by the + * Oraclize address(es). Parses API call result and + * stores it into struct. If query was made manually, + * no further recursive queries are triggered. + * + * @param _myid Bytes32 ID of the Oraclize query. + * + * @param _result String of the result of the Oraclize query. + * + * @param _proof Bytes of the proof of the Oraclize query. + * + */ + function __callback(bytes32 _myid, string _result, bytes _proof) public { + require(msg.sender == oraclize_cbAddress(), 'Caller is not Oraclize address!'); + require(!queryIDs[_myid].isProcessed, 'Query has already been processed!'); + if (queryIDs[_myid].dueAt > gasStationPrices.timeUpdated) + processUpdate(_myid, _result, _proof); + queryIDs[_myid].isProcessed = true; + if (!queryIDs[_myid].isManual && _myid == nextRecursiveQuery) + recursivelyUpdateGasPrices(getDelayToNextInterval(), getFastPrice()); + } + /** + * @notice Function processes the result string of the Oraclize + * query. Splices string into its constituent parts and + * parses the gas prices into the desired uints. + * + * + * @dev The vars are returning struct types from the strings + * library. They give deprecation warnings but we have + * no other option. Note also the mutable nature of + * split(). + * + * @param _myid Bytes32 ID of the Oraclize query. + * + * @param _result String of the result of the Oraclize query. + * + * @param _proof Bytes of the proof of the Oraclize query. + * + */ + function processUpdate(bytes32 _myid, string _result, bytes _proof) private { + var delim = ",".toSlice(); + var stringToParse = _result.toSlice(); + uint64 l = uint64(parseInt(stringToParse.split(delim).toString())); + uint64 s = uint64(parseInt(stringToParse.split(delim).toString())); + uint64 f = uint64(parseInt(stringToParse.split(delim).toString())); + gasStationPrices = GasStationPrices({ + safeLow: l, + standard: s, + fast: f, + timeUpdated: queryIDs[_myid].dueAt + }); + emit LogGasPricesUpdated(l, s, f, _myid, _proof); + } + /** + * @notice Get the safe low gas price in Wei. + * + * @return uint + * + */ + function getSafeLowPrice() public view returns (uint) { + return gasStationPrices.safeLow.mul(conversionFactor); + } + /** + * @notice Get the standard gas price in Wei. + * + * @return uint + * + */ + function getStandardPrice() public view returns (uint) { + return gasStationPrices.standard.mul(conversionFactor); + } + /** + * @notice Get the fast gas price in Wei. + * + * @return uint + * + */ + function getFastPrice() public view returns (uint) { + return gasStationPrices.fast.mul(conversionFactor); + } + /** + * @notice Returns the time the gas prices were last updated, + * as a UTC timestamp. + * + */ + function getLastUpdated() public view returns (uint) { + return gasStationPrices.timeUpdated; + } + /** + * @notice Returns all three gas prices, ordered slowest to + * fastest, plus the time at which they were updated. + * + * @return uint The safe low gas price in Wei. + * uint The standard gas price in Wei. + * uint The fast gas price in Wei. + * uint Timestamp of last update + * + */ + function getGasPrices() public view returns (uint, uint, uint, uint) { + return ( + getSafeLowPrice(), + getStandardPrice(), + getFastPrice(), + getLastUpdated() + ); + } + /** + * @notice Calculates the delay in seconds to the next occuring + * sixth hour. If delay is fewer than 600 seconds, the + * delay until the subsequent 6th hour mark is used instead. + * + * @return uint Time in seconds to next sixth hour. + * + */ + function getDelayToNextInterval() public view returns (uint) { + uint secs = now % 60; + uint mins = (now / 60) % 60; + uint hour = (now / 60 / 60) % 24; + uint secsElapsed = ((hour * 60 * 60) + (mins * 60) + secs); + uint secsInPeriod = (((hour / interval) + 1) * interval) * 60 * 60; + uint remaining = secsInPeriod - secsElapsed; + return remaining > 600 + ? remaining + : remaining + (interval * 60 * 60); + } + /** + * @notice Fallback function allowing ETH addition by + * anyone. + * + */ + function () public payable {} +} diff --git a/solidity/gas-price-oracle/contracts/Migrations.sol b/solidity/gas-price-oracle/contracts/Migrations.sol new file mode 100644 index 00000000..42aaa98e --- /dev/null +++ b/solidity/gas-price-oracle/contracts/Migrations.sol @@ -0,0 +1,24 @@ +pragma solidity ^0.4.18; + + +contract Migrations { + address public owner; + uint public last_completed_migration; + + function Migrations() public { + owner = msg.sender; + } + + modifier restricted() { + if (msg.sender == owner) _; + } + + function setCompleted(uint completed) public restricted { + last_completed_migration = completed; + } + + function upgrade(address new_address) public restricted { + Migrations upgraded = Migrations(new_address); + upgraded.setCompleted(last_completed_migration); + } +} diff --git a/solidity/gas-price-oracle/contracts/imported/strings.sol b/solidity/gas-price-oracle/contracts/imported/strings.sol new file mode 100644 index 00000000..f47f81fb --- /dev/null +++ b/solidity/gas-price-oracle/contracts/imported/strings.sol @@ -0,0 +1,718 @@ +/* + * @title String & slice utility library for Solidity contracts. + * @author Nick Johnson + * + * @dev Functionality in this library is largely implemented using an + * abstraction called a 'slice'. A slice represents a part of a string - + * anything from the entire string to a single character, or even no + * characters at all (a 0-length slice). Since a slice only has to specify + * an offset and a length, copying and manipulating slices is a lot less + * expensive than copying and manipulating the strings they reference. + * + * To further reduce gas costs, most functions on slice that need to return + * a slice modify the original one instead of allocating a new one; for + * instance, `s.split(".")` will return the text up to the first '.', + * modifying s to only contain the remainder of the string after the '.'. + * In situations where you do not want to modify the original slice, you + * can make a copy first with `.copy()`, for example: + * `s.copy().split(".")`. Try and avoid using this idiom in loops; since + * Solidity has no memory management, it will result in allocating many + * short-lived slices that are later discarded. + * + * Functions that return two slices come in two versions: a non-allocating + * version that takes the second slice as an argument, modifying it in + * place, and an allocating version that allocates and returns the second + * slice; see `nextRune` for example. + * + * Functions that have to copy string data will return strings rather than + * slices; these can be cast back to slices for further processing if + * required. + * + * For convenience, some functions are provided with non-modifying + * variants that create a new slice and return both; for instance, + * `s.splitNew('.')` leaves s unmodified, and returns two values + * corresponding to the left and right parts of the string. + */ +pragma solidity ^0.4.14; + + +library strings { + struct slice { + uint _len; + uint _ptr; + } + + function memcpy(uint dest, uint src, uint len) private pure { + // Copy word-length chunks while possible + for (; len >= 32; len -= 32) { + assembly { + mstore(dest, mload(src)) + } + dest += 32; + src += 32; + } + + // Copy remaining bytes + uint mask = 256 ** (32 - len) - 1; + assembly { + let srcpart := and(mload(src), not(mask)) + let destpart := and(mload(dest), mask) + mstore(dest, or(destpart, srcpart)) + } + } + + /* + * @dev Returns a slice containing the entire string. + * @param self The string to make a slice from. + * @return A newly allocated slice containing the entire string. + */ + function toSlice(string self) internal pure returns (slice) { + uint ptr; + assembly { + ptr := add(self, 0x20) + } + return slice(bytes(self).length, ptr); + } + + /* + * @dev Returns the length of a null-terminated bytes32 string. + * @param self The value to find the length of. + * @return The length of the string, from 0 to 32. + */ + function len(bytes32 self) internal pure returns (uint) { + uint ret; + if (self == 0) + return 0; + if (self & 0xffffffffffffffffffffffffffffffff == 0) { + ret += 16; + self = bytes32(uint(self) / 0x100000000000000000000000000000000); + } + if (self & 0xffffffffffffffff == 0) { + ret += 8; + self = bytes32(uint(self) / 0x10000000000000000); + } + if (self & 0xffffffff == 0) { + ret += 4; + self = bytes32(uint(self) / 0x100000000); + } + if (self & 0xffff == 0) { + ret += 2; + self = bytes32(uint(self) / 0x10000); + } + if (self & 0xff == 0) { + ret += 1; + } + return 32 - ret; + } + + /* + * @dev Returns a slice containing the entire bytes32, interpreted as a + * null-terminated utf-8 string. + * @param self The bytes32 value to convert to a slice. + * @return A new slice containing the value of the input argument up to the + * first null. + */ + function toSliceB32(bytes32 self) internal pure returns (slice ret) { + // Allocate space for `self` in memory, copy it there, and point ret at it + assembly { + let ptr := mload(0x40) + mstore(0x40, add(ptr, 0x20)) + mstore(ptr, self) + mstore(add(ret, 0x20), ptr) + } + ret._len = len(self); + } + + /* + * @dev Returns a new slice containing the same data as the current slice. + * @param self The slice to copy. + * @return A new slice containing the same data as `self`. + */ + function copy(slice self) internal pure returns (slice) { + return slice(self._len, self._ptr); + } + + /* + * @dev Copies a slice to a new string. + * @param self The slice to copy. + * @return A newly allocated string containing the slice's text. + */ + function toString(slice self) internal pure returns (string) { + string memory ret = new string(self._len); + uint retptr; + assembly { retptr := add(ret, 32) } + + memcpy(retptr, self._ptr, self._len); + return ret; + } + + /* + * @dev Returns the length in runes of the slice. Note that this operation + * takes time proportional to the length of the slice; avoid using it + * in loops, and call `slice.empty()` if you only need to know whether + * the slice is empty or not. + * @param self The slice to operate on. + * @return The length of the slice in runes. + */ + function len(slice self) internal pure returns (uint l) { + // Starting at ptr-31 means the LSB will be the byte we care about + uint ptr = self._ptr - 31; + uint end = ptr + self._len; + for (l = 0; ptr < end; l++) { + uint8 b; + assembly { b := and(mload(ptr), 0xFF) } + if (b < 0x80) { + ptr += 1; + } else if(b < 0xE0) { + ptr += 2; + } else if(b < 0xF0) { + ptr += 3; + } else if(b < 0xF8) { + ptr += 4; + } else if(b < 0xFC) { + ptr += 5; + } else { + ptr += 6; + } + } + } + + /* + * @dev Returns true if the slice is empty (has a length of 0). + * @param self The slice to operate on. + * @return True if the slice is empty, False otherwise. + */ + function empty(slice self) internal pure returns (bool) { + return self._len == 0; + } + + /* + * @dev Returns a positive number if `other` comes lexicographically after + * `self`, a negative number if it comes before, or zero if the + * contents of the two slices are equal. Comparison is done per-rune, + * on unicode codepoints. + * @param self The first slice to compare. + * @param other The second slice to compare. + * @return The result of the comparison. + */ + function compare(slice self, slice other) internal pure returns (int) { + uint shortest = self._len; + if (other._len < self._len) + shortest = other._len; + + uint selfptr = self._ptr; + uint otherptr = other._ptr; + for (uint idx = 0; idx < shortest; idx += 32) { + uint a; + uint b; + assembly { + a := mload(selfptr) + b := mload(otherptr) + } + if (a != b) { + // Mask out irrelevant bytes and check again + uint256 mask = uint256(-1); // 0xffff... + if(shortest < 32) { + mask = ~(2 ** (8 * (32 - shortest + idx)) - 1); + } + uint256 diff = (a & mask) - (b & mask); + if (diff != 0) + return int(diff); + } + selfptr += 32; + otherptr += 32; + } + return int(self._len) - int(other._len); + } + + /* + * @dev Returns true if the two slices contain the same text. + * @param self The first slice to compare. + * @param self The second slice to compare. + * @return True if the slices are equal, false otherwise. + */ + function equals(slice self, slice other) internal pure returns (bool) { + return compare(self, other) == 0; + } + + /* + * @dev Extracts the first rune in the slice into `rune`, advancing the + * slice to point to the next rune and returning `self`. + * @param self The slice to operate on. + * @param rune The slice that will contain the first rune. + * @return `rune`. + */ + function nextRune(slice self, slice rune) internal pure returns (slice) { + rune._ptr = self._ptr; + + if (self._len == 0) { + rune._len = 0; + return rune; + } + + uint l; + uint b; + // Load the first byte of the rune into the LSBs of b + assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) } + if (b < 0x80) { + l = 1; + } else if(b < 0xE0) { + l = 2; + } else if(b < 0xF0) { + l = 3; + } else { + l = 4; + } + + // Check for truncated codepoints + if (l > self._len) { + rune._len = self._len; + self._ptr += self._len; + self._len = 0; + return rune; + } + + self._ptr += l; + self._len -= l; + rune._len = l; + return rune; + } + + /* + * @dev Returns the first rune in the slice, advancing the slice to point + * to the next rune. + * @param self The slice to operate on. + * @return A slice containing only the first rune from `self`. + */ + function nextRune(slice self) internal pure returns (slice ret) { + nextRune(self, ret); + } + + /* + * @dev Returns the number of the first codepoint in the slice. + * @param self The slice to operate on. + * @return The number of the first codepoint in the slice. + */ + function ord(slice self) internal pure returns (uint ret) { + if (self._len == 0) { + return 0; + } + + uint word; + uint length; + uint divisor = 2 ** 248; + + // Load the rune into the MSBs of b + assembly { word:= mload(mload(add(self, 32))) } + uint b = word / divisor; + if (b < 0x80) { + ret = b; + length = 1; + } else if(b < 0xE0) { + ret = b & 0x1F; + length = 2; + } else if(b < 0xF0) { + ret = b & 0x0F; + length = 3; + } else { + ret = b & 0x07; + length = 4; + } + + // Check for truncated codepoints + if (length > self._len) { + return 0; + } + + for (uint i = 1; i < length; i++) { + divisor = divisor / 256; + b = (word / divisor) & 0xFF; + if (b & 0xC0 != 0x80) { + // Invalid UTF-8 sequence + return 0; + } + ret = (ret * 64) | (b & 0x3F); + } + + return ret; + } + + /* + * @dev Returns the keccak-256 hash of the slice. + * @param self The slice to hash. + * @return The hash of the slice. + */ + function keccak(slice self) internal pure returns (bytes32 ret) { + assembly { + ret := keccak256(mload(add(self, 32)), mload(self)) + } + } + + /* + * @dev Returns true if `self` starts with `needle`. + * @param self The slice to operate on. + * @param needle The slice to search for. + * @return True if the slice starts with the provided text, false otherwise. + */ + function startsWith(slice self, slice needle) internal pure returns (bool) { + if (self._len < needle._len) { + return false; + } + + if (self._ptr == needle._ptr) { + return true; + } + + bool equal; + assembly { + let length := mload(needle) + let selfptr := mload(add(self, 0x20)) + let needleptr := mload(add(needle, 0x20)) + equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) + } + return equal; + } + + /* + * @dev If `self` starts with `needle`, `needle` is removed from the + * beginning of `self`. Otherwise, `self` is unmodified. + * @param self The slice to operate on. + * @param needle The slice to search for. + * @return `self` + */ + function beyond(slice self, slice needle) internal pure returns (slice) { + if (self._len < needle._len) { + return self; + } + + bool equal = true; + if (self._ptr != needle._ptr) { + assembly { + let length := mload(needle) + let selfptr := mload(add(self, 0x20)) + let needleptr := mload(add(needle, 0x20)) + equal := eq(sha3(selfptr, length), sha3(needleptr, length)) + } + } + + if (equal) { + self._len -= needle._len; + self._ptr += needle._len; + } + + return self; + } + + /* + * @dev Returns true if the slice ends with `needle`. + * @param self The slice to operate on. + * @param needle The slice to search for. + * @return True if the slice starts with the provided text, false otherwise. + */ + function endsWith(slice self, slice needle) internal pure returns (bool) { + if (self._len < needle._len) { + return false; + } + + uint selfptr = self._ptr + self._len - needle._len; + + if (selfptr == needle._ptr) { + return true; + } + + bool equal; + assembly { + let length := mload(needle) + let needleptr := mload(add(needle, 0x20)) + equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) + } + + return equal; + } + + /* + * @dev If `self` ends with `needle`, `needle` is removed from the + * end of `self`. Otherwise, `self` is unmodified. + * @param self The slice to operate on. + * @param needle The slice to search for. + * @return `self` + */ + function until(slice self, slice needle) internal pure returns (slice) { + if (self._len < needle._len) { + return self; + } + + uint selfptr = self._ptr + self._len - needle._len; + bool equal = true; + if (selfptr != needle._ptr) { + assembly { + let length := mload(needle) + let needleptr := mload(add(needle, 0x20)) + equal := eq(keccak256(selfptr, length), keccak256(needleptr, length)) + } + } + + if (equal) { + self._len -= needle._len; + } + + return self; + } + + event log_bytemask(bytes32 mask); + + // Returns the memory address of the first byte of the first occurrence of + // `needle` in `self`, or the first byte after `self` if not found. + function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { + uint ptr = selfptr; + uint idx; + + if (needlelen <= selflen) { + if (needlelen <= 32) { + bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); + + bytes32 needledata; + assembly { needledata := and(mload(needleptr), mask) } + + uint end = selfptr + selflen - needlelen; + bytes32 ptrdata; + assembly { ptrdata := and(mload(ptr), mask) } + + while (ptrdata != needledata) { + if (ptr >= end) + return selfptr + selflen; + ptr++; + assembly { ptrdata := and(mload(ptr), mask) } + } + return ptr; + } else { + // For long needles, use hashing + bytes32 hash; + assembly { hash := sha3(needleptr, needlelen) } + + for (idx = 0; idx <= selflen - needlelen; idx++) { + bytes32 testHash; + assembly { testHash := sha3(ptr, needlelen) } + if (hash == testHash) + return ptr; + ptr += 1; + } + } + } + return selfptr + selflen; + } + + // Returns the memory address of the first byte after the last occurrence of + // `needle` in `self`, or the address of `self` if not found. + function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) { + uint ptr; + + if (needlelen <= selflen) { + if (needlelen <= 32) { + bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1)); + + bytes32 needledata; + assembly { needledata := and(mload(needleptr), mask) } + + ptr = selfptr + selflen - needlelen; + bytes32 ptrdata; + assembly { ptrdata := and(mload(ptr), mask) } + + while (ptrdata != needledata) { + if (ptr <= selfptr) + return selfptr; + ptr--; + assembly { ptrdata := and(mload(ptr), mask) } + } + return ptr + needlelen; + } else { + // For long needles, use hashing + bytes32 hash; + assembly { hash := sha3(needleptr, needlelen) } + ptr = selfptr + (selflen - needlelen); + while (ptr >= selfptr) { + bytes32 testHash; + assembly { testHash := sha3(ptr, needlelen) } + if (hash == testHash) + return ptr + needlelen; + ptr -= 1; + } + } + } + return selfptr; + } + + /* + * @dev Modifies `self` to contain everything from the first occurrence of + * `needle` to the end of the slice. `self` is set to the empty slice + * if `needle` is not found. + * @param self The slice to search and modify. + * @param needle The text to search for. + * @return `self`. + */ + function find(slice self, slice needle) internal pure returns (slice) { + uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr); + self._len -= ptr - self._ptr; + self._ptr = ptr; + return self; + } + + /* + * @dev Modifies `self` to contain the part of the string from the start of + * `self` to the end of the first occurrence of `needle`. If `needle` + * is not found, `self` is set to the empty slice. + * @param self The slice to search and modify. + * @param needle The text to search for. + * @return `self`. + */ + function rfind(slice self, slice needle) internal pure returns (slice) { + uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr); + self._len = ptr - self._ptr; + return self; + } + + /* + * @dev Splits the slice, setting `self` to everything after the first + * occurrence of `needle`, and `token` to everything before it. If + * `needle` does not occur in `self`, `self` is set to the empty slice, + * and `token` is set to the entirety of `self`. + * @param self The slice to split. + * @param needle The text to search for in `self`. + * @param token An output parameter to which the first token is written. + * @return `token`. + */ + function split(slice self, slice needle, slice token) internal pure returns (slice) { + uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr); + token._ptr = self._ptr; + token._len = ptr - self._ptr; + if (ptr == self._ptr + self._len) { + // Not found + self._len = 0; + } else { + self._len -= token._len + needle._len; + self._ptr = ptr + needle._len; + } + return token; + } + + /* + * @dev Splits the slice, setting `self` to everything after the first + * occurrence of `needle`, and returning everything before it. If + * `needle` does not occur in `self`, `self` is set to the empty slice, + * and the entirety of `self` is returned. + * @param self The slice to split. + * @param needle The text to search for in `self`. + * @return The part of `self` up to the first occurrence of `delim`. + */ + function split(slice self, slice needle) internal pure returns (slice token) { + split(self, needle, token); + } + + /* + * @dev Splits the slice, setting `self` to everything before the last + * occurrence of `needle`, and `token` to everything after it. If + * `needle` does not occur in `self`, `self` is set to the empty slice, + * and `token` is set to the entirety of `self`. + * @param self The slice to split. + * @param needle The text to search for in `self`. + * @param token An output parameter to which the first token is written. + * @return `token`. + */ + function rsplit(slice self, slice needle, slice token) internal pure returns (slice) { + uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr); + token._ptr = ptr; + token._len = self._len - (ptr - self._ptr); + if (ptr == self._ptr) { + // Not found + self._len = 0; + } else { + self._len -= token._len + needle._len; + } + return token; + } + + /* + * @dev Splits the slice, setting `self` to everything before the last + * occurrence of `needle`, and returning everything after it. If + * `needle` does not occur in `self`, `self` is set to the empty slice, + * and the entirety of `self` is returned. + * @param self The slice to split. + * @param needle The text to search for in `self`. + * @return The part of `self` after the last occurrence of `delim`. + */ + function rsplit(slice self, slice needle) internal pure returns (slice token) { + rsplit(self, needle, token); + } + + /* + * @dev Counts the number of nonoverlapping occurrences of `needle` in `self`. + * @param self The slice to search. + * @param needle The text to search for in `self`. + * @return The number of occurrences of `needle` found in `self`. + */ + function count(slice self, slice needle) internal pure returns (uint cnt) { + uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len; + while (ptr <= self._ptr + self._len) { + cnt++; + ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len; + } + } + + /* + * @dev Returns True if `self` contains `needle`. + * @param self The slice to search. + * @param needle The text to search for in `self`. + * @return True if `needle` is found in `self`, false otherwise. + */ + function contains(slice self, slice needle) internal pure returns (bool) { + return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr; + } + + /* + * @dev Returns a newly allocated string containing the concatenation of + * `self` and `other`. + * @param self The first slice to concatenate. + * @param other The second slice to concatenate. + * @return The concatenation of the two strings. + */ + function concat(slice self, slice other) internal pure returns (string) { + string memory ret = new string(self._len + other._len); + uint retptr; + assembly { retptr := add(ret, 32) } + memcpy(retptr, self._ptr, self._len); + memcpy(retptr + self._len, other._ptr, other._len); + return ret; + } + + /* + * @dev Joins an array of slices, using `self` as a delimiter, returning a + * newly allocated string. + * @param self The delimiter to use. + * @param parts A list of slices to join. + * @return A newly allocated string containing all the slices in `parts`, + * joined with `self`. + */ + function join(slice self, slice[] parts) internal pure returns (string) { + if (parts.length == 0) + return ""; + + uint length = self._len * (parts.length - 1); + for(uint i = 0; i < parts.length; i++) + length += parts[i]._len; + + string memory ret = new string(length); + uint retptr; + assembly { retptr := add(ret, 32) } + + for(i = 0; i < parts.length; i++) { + memcpy(retptr, parts[i]._ptr, parts[i]._len); + retptr += parts[i]._len; + if (i < parts.length - 1) { + memcpy(retptr, self._ptr, self._len); + retptr += self._len; + } + } + + return ret; + } +} \ No newline at end of file diff --git a/solidity/gas-price-oracle/contracts/imported/usingOraclize.sol b/solidity/gas-price-oracle/contracts/imported/usingOraclize.sol new file mode 100644 index 00000000..5e4cd8e7 --- /dev/null +++ b/solidity/gas-price-oracle/contracts/imported/usingOraclize.sol @@ -0,0 +1,1230 @@ +// +/* +Copyright (c) 2015-2016 Oraclize SRL +Copyright (c) 2016 Oraclize LTD + + + +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. +*/ + +// This api is currently targeted at 0.4.18, please import oraclizeAPI_pre0.4.sol or oraclizeAPI_0.4 where necessary + +pragma solidity >=0.4.18;// Incompatible compiler version... please select one stated within pragma solidity or use different oraclizeAPI version + +contract OraclizeI { + address public cbAddress; + function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id); + function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id); + function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id); + function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id); + function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id); + function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id); + function getPrice(string _datasource) public returns (uint _dsprice); + function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice); + function setProofType(byte _proofType) external; + function setCustomGasPrice(uint _gasPrice) external; + function randomDS_getSessionPubKeyHash() external constant returns(bytes32); +} + +contract OraclizeAddrResolverI { + function getAddress() public returns (address _addr); +} + +/* +Begin solidity-cborutils + +https://github.com/smartcontractkit/solidity-cborutils + +MIT License + +Copyright (c) 2018 SmartContract ChainLink, Ltd. + +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. + */ + +library Buffer { + struct buffer { + bytes buf; + uint capacity; + } + + function init(buffer memory buf, uint _capacity) internal pure { + uint capacity = _capacity; + if(capacity % 32 != 0) capacity += 32 - (capacity % 32); + // Allocate space for the buffer data + buf.capacity = capacity; + assembly { + let ptr := mload(0x40) + mstore(buf, ptr) + mstore(ptr, 0) + mstore(0x40, add(ptr, capacity)) + } + } + + function resize(buffer memory buf, uint capacity) private pure { + bytes memory oldbuf = buf.buf; + init(buf, capacity); + append(buf, oldbuf); + } + + function max(uint a, uint b) private pure returns(uint) { + if(a > b) { + return a; + } + return b; + } + + /** + * @dev Appends a byte array to the end of the buffer. Resizes if doing so + * would exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function append(buffer memory buf, bytes data) internal pure returns(buffer memory) { + if(data.length + buf.buf.length > buf.capacity) { + resize(buf, max(buf.capacity, data.length) * 2); + } + + uint dest; + uint src; + uint len = data.length; + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Start address = buffer address + buffer length + sizeof(buffer length) + dest := add(add(bufptr, buflen), 32) + // Update buffer length + mstore(bufptr, add(buflen, mload(data))) + src := add(data, 32) + } + + // Copy word-length chunks while possible + for(; len >= 32; len -= 32) { + assembly { + mstore(dest, mload(src)) + } + dest += 32; + src += 32; + } + + // Copy remaining bytes + uint mask = 256 ** (32 - len) - 1; + assembly { + let srcpart := and(mload(src), not(mask)) + let destpart := and(mload(dest), mask) + mstore(dest, or(destpart, srcpart)) + } + + return buf; + } + + /** + * @dev Appends a byte to the end of the buffer. Resizes if doing so would + * exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function append(buffer memory buf, uint8 data) internal pure { + if(buf.buf.length + 1 > buf.capacity) { + resize(buf, buf.capacity * 2); + } + + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Address = buffer address + buffer length + sizeof(buffer length) + let dest := add(add(bufptr, buflen), 32) + mstore8(dest, data) + // Update buffer length + mstore(bufptr, add(buflen, 1)) + } + } + + /** + * @dev Appends a byte to the end of the buffer. Resizes if doing so would + * exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) { + if(len + buf.buf.length > buf.capacity) { + resize(buf, max(buf.capacity, len) * 2); + } + + uint mask = 256 ** len - 1; + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Address = buffer address + buffer length + sizeof(buffer length) + len + let dest := add(add(bufptr, buflen), len) + mstore(dest, or(and(mload(dest), not(mask)), data)) + // Update buffer length + mstore(bufptr, add(buflen, len)) + } + return buf; + } +} + +library CBOR { + using Buffer for Buffer.buffer; + + uint8 private constant MAJOR_TYPE_INT = 0; + uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1; + uint8 private constant MAJOR_TYPE_BYTES = 2; + uint8 private constant MAJOR_TYPE_STRING = 3; + uint8 private constant MAJOR_TYPE_ARRAY = 4; + uint8 private constant MAJOR_TYPE_MAP = 5; + uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7; + + function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure { + if(value <= 23) { + buf.append(uint8((major << 5) | value)); + } else if(value <= 0xFF) { + buf.append(uint8((major << 5) | 24)); + buf.appendInt(value, 1); + } else if(value <= 0xFFFF) { + buf.append(uint8((major << 5) | 25)); + buf.appendInt(value, 2); + } else if(value <= 0xFFFFFFFF) { + buf.append(uint8((major << 5) | 26)); + buf.appendInt(value, 4); + } else if(value <= 0xFFFFFFFFFFFFFFFF) { + buf.append(uint8((major << 5) | 27)); + buf.appendInt(value, 8); + } + } + + function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure { + buf.append(uint8((major << 5) | 31)); + } + + function encodeUInt(Buffer.buffer memory buf, uint value) internal pure { + encodeType(buf, MAJOR_TYPE_INT, value); + } + + function encodeInt(Buffer.buffer memory buf, int value) internal pure { + if(value >= 0) { + encodeType(buf, MAJOR_TYPE_INT, uint(value)); + } else { + encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value)); + } + } + + function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure { + encodeType(buf, MAJOR_TYPE_BYTES, value.length); + buf.append(value); + } + + function encodeString(Buffer.buffer memory buf, string value) internal pure { + encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length); + buf.append(bytes(value)); + } + + function startArray(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY); + } + + function startMap(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP); + } + + function endSequence(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE); + } +} + +/* +End solidity-cborutils + */ + +contract usingOraclize { + uint constant day = 60*60*24; + uint constant week = 60*60*24*7; + uint constant month = 60*60*24*30; + byte constant proofType_NONE = 0x00; + byte constant proofType_TLSNotary = 0x10; + byte constant proofType_Ledger = 0x30; + byte constant proofType_Android = 0x40; + byte constant proofType_Native = 0xF0; + byte constant proofStorage_IPFS = 0x01; + uint8 constant networkID_auto = 0; + uint8 constant networkID_mainnet = 1; + uint8 constant networkID_testnet = 2; + uint8 constant networkID_morden = 2; + uint8 constant networkID_consensys = 161; + + OraclizeAddrResolverI OAR; + + OraclizeI oraclize; + modifier oraclizeAPI { + if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) + oraclize_setNetwork(networkID_auto); + + if(address(oraclize) != OAR.getAddress()) + oraclize = OraclizeI(OAR.getAddress()); + + _; + } + modifier coupon(string code){ + oraclize = OraclizeI(OAR.getAddress()); + _; + } + + function oraclize_setNetwork(uint8 networkID) internal returns(bool){ + return oraclize_setNetwork(); + networkID; // silence the warning and remain backwards compatible + } + function oraclize_setNetwork() internal returns(bool){ + if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet + OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed); + oraclize_setNetworkName("eth_mainnet"); + return true; + } + if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet + OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1); + oraclize_setNetworkName("eth_ropsten3"); + return true; + } + if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet + OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e); + oraclize_setNetworkName("eth_kovan"); + return true; + } + if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ //rinkeby testnet + OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48); + oraclize_setNetworkName("eth_rinkeby"); + return true; + } + if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ //ethereum-bridge + OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475); + return true; + } + if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ //ether.camp ide + OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF); + return true; + } + if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ //browser-solidity + OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA); + return true; + } + return false; + } + + function __callback(bytes32 myid, string result) public { + __callback(myid, result, new bytes(0)); + } + function __callback(bytes32 myid, string result, bytes proof) public { + return; + myid; result; proof; // Silence compiler warnings + } + + function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){ + return oraclize.getPrice(datasource); + } + + function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){ + return oraclize.getPrice(datasource, gaslimit); + } + + function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query.value(price)(0, datasource, arg); + } + function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query.value(price)(timestamp, datasource, arg); + } + function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit); + } + function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit); + } + function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query2.value(price)(0, datasource, arg1, arg2); + } + function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2); + } + function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit); + } + function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit); + } + function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN.value(price)(0, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN.value(price)(timestamp, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); + } + function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); + } + function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN.value(price)(0, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN.value(price)(timestamp, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); + } + function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); + } + function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_cbAddress() oraclizeAPI internal returns (address){ + return oraclize.cbAddress(); + } + function oraclize_setProof(byte proofP) oraclizeAPI internal { + return oraclize.setProofType(proofP); + } + function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal { + return oraclize.setCustomGasPrice(gasPrice); + } + + function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){ + return oraclize.randomDS_getSessionPubKeyHash(); + } + + function getCodeSize(address _addr) constant internal returns(uint _size) { + assembly { + _size := extcodesize(_addr) + } + } + + function parseAddr(string _a) internal pure returns (address){ + bytes memory tmp = bytes(_a); + uint160 iaddr = 0; + uint160 b1; + uint160 b2; + for (uint i=2; i<2+2*20; i+=2){ + iaddr *= 256; + b1 = uint160(tmp[i]); + b2 = uint160(tmp[i+1]); + if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87; + else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55; + else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48; + if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87; + else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55; + else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48; + iaddr += (b1*16+b2); + } + return address(iaddr); + } + + function strCompare(string _a, string _b) internal pure returns (int) { + bytes memory a = bytes(_a); + bytes memory b = bytes(_b); + uint minLength = a.length; + if (b.length < minLength) minLength = b.length; + for (uint i = 0; i < minLength; i ++) + if (a[i] < b[i]) + return -1; + else if (a[i] > b[i]) + return 1; + if (a.length < b.length) + return -1; + else if (a.length > b.length) + return 1; + else + return 0; + } + + function indexOf(string _haystack, string _needle) internal pure returns (int) { + bytes memory h = bytes(_haystack); + bytes memory n = bytes(_needle); + if(h.length < 1 || n.length < 1 || (n.length > h.length)) + return -1; + else if(h.length > (2**128 -1)) + return -1; + else + { + uint subindex = 0; + for (uint i = 0; i < h.length; i ++) + { + if (h[i] == n[0]) + { + subindex = 1; + while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex]) + { + subindex++; + } + if(subindex == n.length) + return int(i); + } + } + return -1; + } + } + + function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) { + bytes memory _ba = bytes(_a); + bytes memory _bb = bytes(_b); + bytes memory _bc = bytes(_c); + bytes memory _bd = bytes(_d); + bytes memory _be = bytes(_e); + string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length); + bytes memory babcde = bytes(abcde); + uint k = 0; + for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i]; + for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i]; + for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i]; + for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i]; + for (i = 0; i < _be.length; i++) babcde[k++] = _be[i]; + return string(babcde); + } + + function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) { + return strConcat(_a, _b, _c, _d, ""); + } + + function strConcat(string _a, string _b, string _c) internal pure returns (string) { + return strConcat(_a, _b, _c, "", ""); + } + + function strConcat(string _a, string _b) internal pure returns (string) { + return strConcat(_a, _b, "", "", ""); + } + + // parseInt + function parseInt(string _a) internal pure returns (uint) { + return parseInt(_a, 0); + } + + // parseInt(parseFloat*10^_b) + function parseInt(string _a, uint _b) internal pure returns (uint) { + bytes memory bresult = bytes(_a); + uint mint = 0; + bool decimals = false; + for (uint i=0; i= 48)&&(bresult[i] <= 57)){ + if (decimals){ + if (_b == 0) break; + else _b--; + } + mint *= 10; + mint += uint(bresult[i]) - 48; + } else if (bresult[i] == 46) decimals = true; + } + if (_b > 0) mint *= 10**_b; + return mint; + } + + function uint2str(uint i) internal pure returns (string){ + if (i == 0) return "0"; + uint j = i; + uint len; + while (j != 0){ + len++; + j /= 10; + } + bytes memory bstr = new bytes(len); + uint k = len - 1; + while (i != 0){ + bstr[k--] = byte(48 + i % 10); + i /= 10; + } + return string(bstr); + } + + using CBOR for Buffer.buffer; + function stra2cbor(string[] arr) internal pure returns (bytes) { + safeMemoryCleaner(); + Buffer.buffer memory buf; + Buffer.init(buf, 1024); + buf.startArray(); + for (uint i = 0; i < arr.length; i++) { + buf.encodeString(arr[i]); + } + buf.endSequence(); + return buf.buf; + } + + function ba2cbor(bytes[] arr) internal pure returns (bytes) { + safeMemoryCleaner(); + Buffer.buffer memory buf; + Buffer.init(buf, 1024); + buf.startArray(); + for (uint i = 0; i < arr.length; i++) { + buf.encodeBytes(arr[i]); + } + buf.endSequence(); + return buf.buf; + } + + string oraclize_network_name; + function oraclize_setNetworkName(string _network_name) internal { + oraclize_network_name = _network_name; + } + + function oraclize_getNetworkName() internal view returns (string) { + return oraclize_network_name; + } + + function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){ + require((_nbytes > 0) && (_nbytes <= 32)); + // Convert from seconds to ledger timer ticks + _delay *= 10; + bytes memory nbytes = new bytes(1); + nbytes[0] = byte(_nbytes); + bytes memory unonce = new bytes(32); + bytes memory sessionKeyHash = new bytes(32); + bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash(); + assembly { + mstore(unonce, 0x20) + // the following variables can be relaxed + // check relaxed random contract under ethereum-examples repo + // for an idea on how to override and replace comit hash vars + mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp))) + mstore(sessionKeyHash, 0x20) + mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32) + } + bytes memory delay = new bytes(32); + assembly { + mstore(add(delay, 0x20), _delay) + } + + bytes memory delay_bytes8 = new bytes(8); + copyBytes(delay, 24, 8, delay_bytes8, 0); + + bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay]; + bytes32 queryId = oraclize_query("random", args, _customGasLimit); + + bytes memory delay_bytes8_left = new bytes(8); + + assembly { + let x := mload(add(delay_bytes8, 0x20)) + mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000)) + + } + + oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2])); + return queryId; + } + + function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal { + oraclize_randomDS_args[queryId] = commitment; + } + + mapping(bytes32=>bytes32) oraclize_randomDS_args; + mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified; + + function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){ + bool sigok; + address signer; + + bytes32 sigr; + bytes32 sigs; + + bytes memory sigr_ = new bytes(32); + uint offset = 4+(uint(dersig[3]) - 0x20); + sigr_ = copyBytes(dersig, offset, 32, sigr_, 0); + bytes memory sigs_ = new bytes(32); + offset += 32 + 2; + sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0); + + assembly { + sigr := mload(add(sigr_, 32)) + sigs := mload(add(sigs_, 32)) + } + + + (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs); + if (address(keccak256(pubkey)) == signer) return true; + else { + (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs); + return (address(keccak256(pubkey)) == signer); + } + } + + function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) { + bool sigok; + + // Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH) + bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2); + copyBytes(proof, sig2offset, sig2.length, sig2, 0); + + bytes memory appkey1_pubkey = new bytes(64); + copyBytes(proof, 3+1, 64, appkey1_pubkey, 0); + + bytes memory tosign2 = new bytes(1+65+32); + tosign2[0] = byte(1); //role + copyBytes(proof, sig2offset-65, 65, tosign2, 1); + bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c"; + copyBytes(CODEHASH, 0, 32, tosign2, 1+65); + sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey); + + if (sigok == false) return false; + + + // Step 7: verify the APPKEY1 provenance (must be signed by Ledger) + bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4"; + + bytes memory tosign3 = new bytes(1+65); + tosign3[0] = 0xFE; + copyBytes(proof, 3, 65, tosign3, 1); + + bytes memory sig3 = new bytes(uint(proof[3+65+1])+2); + copyBytes(proof, 3+65, sig3.length, sig3, 0); + + sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY); + + return sigok; + } + + modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) { + // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1) + require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1)); + + bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); + require(proofVerified); + + _; + } + + function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){ + // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1) + if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1; + + bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); + if (proofVerified == false) return 2; + + return 0; + } + + function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){ + bool match_ = true; + + require(prefix.length == n_random_bytes); + + for (uint256 i=0; i< n_random_bytes; i++) { + if (content[i] != prefix[i]) match_ = false; + } + + return match_; + } + + function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){ + + // Step 2: the unique keyhash has to match with the sha256 of (context name + queryId) + uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32; + bytes memory keyhash = new bytes(32); + copyBytes(proof, ledgerProofLength, 32, keyhash, 0); + if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false; + + bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2); + copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0); + + // Step 3: we assume sig1 is valid (it will be verified during step 5) and we verify if 'result' is the prefix of sha256(sig1) + if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false; + + // Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage. + // This is to verify that the computed args match with the ones specified in the query. + bytes memory commitmentSlice1 = new bytes(8+1+32); + copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0); + + bytes memory sessionPubkey = new bytes(64); + uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65; + copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0); + + bytes32 sessionPubkeyHash = sha256(sessionPubkey); + if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){ //unonce, nbytes and sessionKeyHash match + delete oraclize_randomDS_args[queryId]; + } else return false; + + + // Step 5: validity verification for sig1 (keyhash and args signed with the sessionKey) + bytes memory tosign1 = new bytes(32+8+1+32); + copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0); + if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false; + + // verify if sessionPubkeyHash was verified already, if not.. let's do it! + if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){ + oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset); + } + + return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash]; + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) { + uint minLength = length + toOffset; + + // Buffer too small + require(to.length >= minLength); // Should be a better way? + + // NOTE: the offset 32 is added to skip the `size` field of both bytes variables + uint i = 32 + fromOffset; + uint j = 32 + toOffset; + + while (i < (32 + fromOffset + length)) { + assembly { + let tmp := mload(add(from, i)) + mstore(add(to, j), tmp) + } + i += 32; + j += 32; + } + + return to; + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + // Duplicate Solidity's ecrecover, but catching the CALL return value + function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) { + // We do our own memory management here. Solidity uses memory offset + // 0x40 to store the current end of memory. We write past it (as + // writes are memory extensions), but don't update the offset so + // Solidity will reuse it. The memory used here is only needed for + // this context. + + // FIXME: inline assembly can't access return values + bool ret; + address addr; + + assembly { + let size := mload(0x40) + mstore(size, hash) + mstore(add(size, 32), v) + mstore(add(size, 64), r) + mstore(add(size, 96), s) + + // NOTE: we can reuse the request memory because we deal with + // the return code + ret := call(3000, 1, 0, size, 128, size, 32) + addr := mload(size) + } + + return (ret, addr); + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) { + bytes32 r; + bytes32 s; + uint8 v; + + if (sig.length != 65) + return (false, 0); + + // The signature format is a compact form of: + // {bytes32 r}{bytes32 s}{uint8 v} + // Compact means, uint8 is not padded to 32 bytes. + assembly { + r := mload(add(sig, 32)) + s := mload(add(sig, 64)) + + // Here we are loading the last 32 bytes. We exploit the fact that + // 'mload' will pad with zeroes if we overread. + // There is no 'mload8' to do this, but that would be nicer. + v := byte(0, mload(add(sig, 96))) + + // Alternative solution: + // 'byte' is not working due to the Solidity parser, so lets + // use the second best option, 'and' + // v := and(mload(add(sig, 65)), 255) + } + + // albeit non-transactional signatures are not specified by the YP, one would expect it + // to match the YP range of [27, 28] + // + // geth uses [0, 1] and some clients have followed. This might change, see: + // https://github.com/ethereum/go-ethereum/issues/2053 + if (v < 27) + v += 27; + + if (v != 27 && v != 28) + return (false, 0); + + return safer_ecrecover(hash, v, r, s); + } + + function safeMemoryCleaner() internal pure { + assembly { + let fmem := mload(0x40) + codecopy(fmem, codesize, sub(msize, fmem)) + } + } + +} +// diff --git a/solidity/gas-price-oracle/gas-price-oracle-tests.jpg b/solidity/gas-price-oracle/gas-price-oracle-tests.jpg new file mode 100755 index 0000000000000000000000000000000000000000..3cfddfe89f4a82e980008b928381107bacf42a50 GIT binary patch literal 627423 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

nLhXa;B3n8wbL{^m5wf{H~M5-0ggpSq_SJbEACX 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 {&f)bN_e%q`8>$v*mlZ2 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

)n?R<>2|I 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%0D3^bo&h((Of7JS~Y`|q#U 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�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 + deployer.deploy(artifacts.require('./Migrations.sol')) \ No newline at end of file diff --git a/solidity/gas-price-oracle/migrations/2_deploy_contracts.js b/solidity/gas-price-oracle/migrations/2_deploy_contracts.js new file mode 100644 index 00000000..db9ec8f0 --- /dev/null +++ b/solidity/gas-price-oracle/migrations/2_deploy_contracts.js @@ -0,0 +1,12 @@ +const contracts = [ + artifacts.require("strings.sol"), + artifacts.require("usingOraclize.sol"), +] +const gasOracle = artifacts.require("GasPriceOracle.sol") + +module.exports = deployer => { + const gasPrice = 2e10 + const amountETH = 1e17 + contracts.map(contract => deployer.deploy(contract)) + deployer.deploy(gasOracle, gasPrice, {value: amountETH}) +} diff --git a/solidity/gas-price-oracle/package-lock.json b/solidity/gas-price-oracle/package-lock.json new file mode 100644 index 00000000..34aa1a03 --- /dev/null +++ b/solidity/gas-price-oracle/package-lock.json @@ -0,0 +1,5650 @@ +{ + "name": "solidity-gasprice-oracle-priv", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "abstract-leveldown": { + "version": "2.6.3", + "resolved": "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-2.6.3.tgz", + "integrity": "sha512-2++wDf/DYqkPR3o5tbfdhF96EfMApo1GpPfzOsR/ZYXdkSmELlvOOEAl9iKkRsktMPHdGjO4rtkBpf2I7TiTeA==", + "requires": { + "xtend": "~4.0.0" + } + }, + "accepts": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz", + "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", + "requires": { + "mime-types": "~2.1.18", + "negotiator": "0.6.1" + } + }, + "aes-js": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/aes-js/-/aes-js-0.2.4.tgz", + "integrity": "sha1-lLiBq3FyhtAV+iGeCPtmcJ3aWj0=" + }, + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "requires": { + "co": "^4.6.0", + "fast-deep-equal": "^1.0.0", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0" + } + }, + "ambi": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/ambi/-/ambi-2.5.0.tgz", + "integrity": "sha1-fI43K+SIkRV+fOoBy2+RQ9H3QiA=", + "requires": { + "editions": "^1.1.1", + "typechecker": "^4.3.0" + }, + "dependencies": { + "typechecker": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/typechecker/-/typechecker-4.5.0.tgz", + "integrity": "sha512-bqPE/ck3bVIaXP7gMKTKSHrypT32lpYTpiqzPYeYzdSQnmaGvaGhy7TnN/M/+5R+2rs/kKcp9ZLPRp/Q9Yj+4w==", + "requires": { + "editions": "^1.3.4" + } + } + } + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=" + }, + "any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha1-q8av7tzqUugJzcA3au0845Y10X8=" + }, + "array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI=" + }, + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=" + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", + "requires": { + "bn.js": "^4.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "async": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.1.tgz", + "integrity": "sha512-fNEiL2+AZt6AlAw/29Cr0UDe4sRAHCpEHh54WMz+Bb7QfNcFw4h3loofyJpLeQs4Yx7yuqu/2dLgM5hKOs6HlQ==", + "requires": { + "lodash": "^4.17.10" + } + }, + "async-eventemitter": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/async-eventemitter/-/async-eventemitter-0.2.4.tgz", + "integrity": "sha512-pd20BwL7Yt1zwDFy+8MX8F1+WCT8aQeKj0kQnTrH9WaeRETlRamVhD0JtRPmrV4GfOJ2F9CvdQkZeZhnh2TuHw==", + "requires": { + "async": "^2.4.0" + } + }, + "async-limiter": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz", + "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg==" + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + }, + "aws4": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.7.0.tgz", + "integrity": "sha512-32NDda82rhwD9/JBCCkB+MRYDp0oSvlo2IL6rQWA10PQi7tDUM3eqMSltXmY+Oyl/7N3P3qNtAlv7X0d9bI28w==" + }, + "babel-code-frame": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz", + "integrity": "sha1-Y/1D99weO7fONZR9uP42mj9Yx0s=", + "requires": { + "chalk": "^1.1.3", + "esutils": "^2.0.2", + "js-tokens": "^3.0.2" + } + }, + "babel-core": { + "version": "6.26.3", + "resolved": "https://registry.npmjs.org/babel-core/-/babel-core-6.26.3.tgz", + "integrity": "sha512-6jyFLuDmeidKmUEb3NM+/yawG0M2bDZ9Z1qbZP59cyHLz8kYGKYwpJP0UwUKKUiTRNvxfLesJnTedqczP7cTDA==", + "requires": { + "babel-code-frame": "^6.26.0", + "babel-generator": "^6.26.0", + "babel-helpers": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-register": "^6.26.0", + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "convert-source-map": "^1.5.1", + "debug": "^2.6.9", + "json5": "^0.5.1", + "lodash": "^4.17.4", + "minimatch": "^3.0.4", + "path-is-absolute": "^1.0.1", + "private": "^0.1.8", + "slash": "^1.0.0", + "source-map": "^0.5.7" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "babel-generator": { + "version": "6.26.1", + "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz", + "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==", + "requires": { + "babel-messages": "^6.23.0", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "detect-indent": "^4.0.0", + "jsesc": "^1.3.0", + "lodash": "^4.17.4", + "source-map": "^0.5.7", + "trim-right": "^1.0.1" + }, + "dependencies": { + "jsesc": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-1.3.0.tgz", + "integrity": "sha1-RsP+yMGJKxKwgz25vHYiF226s0s=" + } + } + }, + "babel-helper-builder-binary-assignment-operator-visitor": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.24.1.tgz", + "integrity": "sha1-zORReto1b0IgvK6KAsKzRvmlZmQ=", + "requires": { + "babel-helper-explode-assignable-expression": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-helper-call-delegate": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-call-delegate/-/babel-helper-call-delegate-6.24.1.tgz", + "integrity": "sha1-7Oaqzdx25Bw0YfiL/Fdb0Nqi340=", + "requires": { + "babel-helper-hoist-variables": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-helper-define-map": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-define-map/-/babel-helper-define-map-6.26.0.tgz", + "integrity": "sha1-pfVtq0GiX5fstJjH66ypgZ+Vvl8=", + "requires": { + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" + } + }, + "babel-helper-explode-assignable-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.24.1.tgz", + "integrity": "sha1-8luCz33BBDPFX3BZLVdGQArCLKo=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-helper-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-function-name/-/babel-helper-function-name-6.24.1.tgz", + "integrity": "sha1-00dbjAPtmCQqJbSDUasYOZ01gKk=", + "requires": { + "babel-helper-get-function-arity": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-helper-get-function-arity": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.24.1.tgz", + "integrity": "sha1-j3eCqpNAfEHTqlCQj4mwMbG2hT0=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-helper-hoist-variables": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.24.1.tgz", + "integrity": "sha1-HssnaJydJVE+rbyZFKc/VAi+enY=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-helper-optimise-call-expression": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.24.1.tgz", + "integrity": "sha1-96E0J7qfc/j0+pk8VKl4gtEkQlc=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-helper-regex": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-helper-regex/-/babel-helper-regex-6.26.0.tgz", + "integrity": "sha1-MlxZ+QL4LyS3T6zu0DY5VPZJXnI=", + "requires": { + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" + } + }, + "babel-helper-remap-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.24.1.tgz", + "integrity": "sha1-XsWBgnrXI/7N04HxySg5BnbkVRs=", + "requires": { + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-helper-replace-supers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helper-replace-supers/-/babel-helper-replace-supers-6.24.1.tgz", + "integrity": "sha1-v22/5Dk40XNpohPKiov3S2qQqxo=", + "requires": { + "babel-helper-optimise-call-expression": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-helpers": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-helpers/-/babel-helpers-6.24.1.tgz", + "integrity": "sha1-NHHenK7DiOXIUOWX5Yom3fN2ArI=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" + } + }, + "babel-messages": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-messages/-/babel-messages-6.23.0.tgz", + "integrity": "sha1-8830cDhYA1sqKVHG7F7fbGLyYw4=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-check-es2015-constants": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz", + "integrity": "sha1-NRV7EBQm/S/9PaP3XH0ekYNbv4o=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-syntax-async-functions": { + "version": "6.13.0", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz", + "integrity": "sha1-ytnK0RkbWtY0vzCuCHI5HgZHvpU=" + }, + "babel-plugin-syntax-exponentiation-operator": { + "version": "6.13.0", + "resolved": "http://registry.npmjs.org/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz", + "integrity": "sha1-nufoM3KQ2pUoggGmpX9BcDF4MN4=" + }, + "babel-plugin-syntax-trailing-function-commas": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz", + "integrity": "sha1-ugNgk3+NBuQBgKQ/4NVhb/9TLPM=" + }, + "babel-plugin-transform-async-to-generator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.24.1.tgz", + "integrity": "sha1-ZTbjeK/2yx1VF6wOQOs+n8jQh2E=", + "requires": { + "babel-helper-remap-async-to-generator": "^6.24.1", + "babel-plugin-syntax-async-functions": "^6.8.0", + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-arrow-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz", + "integrity": "sha1-RSaSy3EdX3ncf4XkQM5BufJE0iE=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-block-scoped-functions": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz", + "integrity": "sha1-u8UbSflk1wy42OC5ToICRs46YUE=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-block-scoping": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.26.0.tgz", + "integrity": "sha1-1w9SmcEwjQXBL0Y4E7CgnnOxiV8=", + "requires": { + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "lodash": "^4.17.4" + } + }, + "babel-plugin-transform-es2015-classes": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.24.1.tgz", + "integrity": "sha1-WkxYpQyclGHlZLSyo7+ryXolhNs=", + "requires": { + "babel-helper-define-map": "^6.24.1", + "babel-helper-function-name": "^6.24.1", + "babel-helper-optimise-call-expression": "^6.24.1", + "babel-helper-replace-supers": "^6.24.1", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-computed-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.24.1.tgz", + "integrity": "sha1-b+Ko0WiV1WNPTNmZttNICjCBWbM=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-destructuring": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz", + "integrity": "sha1-mXux8auWf2gtKwh2/jWNYOdlxW0=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-duplicate-keys": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.24.1.tgz", + "integrity": "sha1-c+s9MQypaePvnskcU3QabxV2Qj4=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-for-of": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz", + "integrity": "sha1-9HyVsrYT3x0+zC/bdXNiPHUkhpE=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-function-name": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.24.1.tgz", + "integrity": "sha1-g0yJhTvDaxrw86TF26qU/Y6sqos=", + "requires": { + "babel-helper-function-name": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz", + "integrity": "sha1-T1SgLWzWbPkVKAAZox0xklN3yi4=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-modules-amd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.24.1.tgz", + "integrity": "sha1-Oz5UAXI5hC1tGcMBHEvS8AoA0VQ=", + "requires": { + "babel-plugin-transform-es2015-modules-commonjs": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-modules-commonjs": { + "version": "6.26.2", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz", + "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==", + "requires": { + "babel-plugin-transform-strict-mode": "^6.24.1", + "babel-runtime": "^6.26.0", + "babel-template": "^6.26.0", + "babel-types": "^6.26.0" + } + }, + "babel-plugin-transform-es2015-modules-systemjs": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.24.1.tgz", + "integrity": "sha1-/4mhQrkRmpBhlfXxBuzzBdlAfSM=", + "requires": { + "babel-helper-hoist-variables": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-modules-umd": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.24.1.tgz", + "integrity": "sha1-rJl+YoXNGO1hdq22B9YCNErThGg=", + "requires": { + "babel-plugin-transform-es2015-modules-amd": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-object-super": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.24.1.tgz", + "integrity": "sha1-JM72muIcuDp/hgPa0CH1cusnj40=", + "requires": { + "babel-helper-replace-supers": "^6.24.1", + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-parameters": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.24.1.tgz", + "integrity": "sha1-V6w1GrScrxSpfNE7CfZv3wpiXys=", + "requires": { + "babel-helper-call-delegate": "^6.24.1", + "babel-helper-get-function-arity": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-template": "^6.24.1", + "babel-traverse": "^6.24.1", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-shorthand-properties": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.24.1.tgz", + "integrity": "sha1-JPh11nIch2YbvZmkYi5R8U3jiqA=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-spread": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz", + "integrity": "sha1-1taKmfia7cRTbIGlQujdnxdG+NE=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-sticky-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.24.1.tgz", + "integrity": "sha1-AMHNsaynERLN8M9hJsLta0V8zbw=", + "requires": { + "babel-helper-regex": "^6.24.1", + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-plugin-transform-es2015-template-literals": { + "version": "6.22.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz", + "integrity": "sha1-qEs0UPfp+PH2g51taH2oS7EjbY0=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-typeof-symbol": { + "version": "6.23.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz", + "integrity": "sha1-3sCfHN3/lLUqxz1QXITfWdzOs3I=", + "requires": { + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-es2015-unicode-regex": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.24.1.tgz", + "integrity": "sha1-04sS9C6nMj9yk4fxinxa4frrNek=", + "requires": { + "babel-helper-regex": "^6.24.1", + "babel-runtime": "^6.22.0", + "regexpu-core": "^2.0.0" + } + }, + "babel-plugin-transform-exponentiation-operator": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.24.1.tgz", + "integrity": "sha1-KrDJx/MJj6SJB3cruBP+QejeOg4=", + "requires": { + "babel-helper-builder-binary-assignment-operator-visitor": "^6.24.1", + "babel-plugin-syntax-exponentiation-operator": "^6.8.0", + "babel-runtime": "^6.22.0" + } + }, + "babel-plugin-transform-regenerator": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.26.0.tgz", + "integrity": "sha1-4HA2lvveJ/Cj78rPi03KL3s6jy8=", + "requires": { + "regenerator-transform": "^0.10.0" + } + }, + "babel-plugin-transform-strict-mode": { + "version": "6.24.1", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.24.1.tgz", + "integrity": "sha1-1fr3qleKZbvlkc9e2uBKDGcCB1g=", + "requires": { + "babel-runtime": "^6.22.0", + "babel-types": "^6.24.1" + } + }, + "babel-preset-env": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/babel-preset-env/-/babel-preset-env-1.7.0.tgz", + "integrity": "sha512-9OR2afuKDneX2/q2EurSftUYM0xGu4O2D9adAhVfADDhrYDaxXV0rBbevVYoY9n6nyX1PmQW/0jtpJvUNr9CHg==", + "requires": { + "babel-plugin-check-es2015-constants": "^6.22.0", + "babel-plugin-syntax-trailing-function-commas": "^6.22.0", + "babel-plugin-transform-async-to-generator": "^6.22.0", + "babel-plugin-transform-es2015-arrow-functions": "^6.22.0", + "babel-plugin-transform-es2015-block-scoped-functions": "^6.22.0", + "babel-plugin-transform-es2015-block-scoping": "^6.23.0", + "babel-plugin-transform-es2015-classes": "^6.23.0", + "babel-plugin-transform-es2015-computed-properties": "^6.22.0", + "babel-plugin-transform-es2015-destructuring": "^6.23.0", + "babel-plugin-transform-es2015-duplicate-keys": "^6.22.0", + "babel-plugin-transform-es2015-for-of": "^6.23.0", + "babel-plugin-transform-es2015-function-name": "^6.22.0", + "babel-plugin-transform-es2015-literals": "^6.22.0", + "babel-plugin-transform-es2015-modules-amd": "^6.22.0", + "babel-plugin-transform-es2015-modules-commonjs": "^6.23.0", + "babel-plugin-transform-es2015-modules-systemjs": "^6.23.0", + "babel-plugin-transform-es2015-modules-umd": "^6.23.0", + "babel-plugin-transform-es2015-object-super": "^6.22.0", + "babel-plugin-transform-es2015-parameters": "^6.23.0", + "babel-plugin-transform-es2015-shorthand-properties": "^6.22.0", + "babel-plugin-transform-es2015-spread": "^6.22.0", + "babel-plugin-transform-es2015-sticky-regex": "^6.22.0", + "babel-plugin-transform-es2015-template-literals": "^6.22.0", + "babel-plugin-transform-es2015-typeof-symbol": "^6.23.0", + "babel-plugin-transform-es2015-unicode-regex": "^6.22.0", + "babel-plugin-transform-exponentiation-operator": "^6.22.0", + "babel-plugin-transform-regenerator": "^6.22.0", + "browserslist": "^3.2.6", + "invariant": "^2.2.2", + "semver": "^5.3.0" + } + }, + "babel-register": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-register/-/babel-register-6.26.0.tgz", + "integrity": "sha1-btAhFz4vy0htestFxgCahW9kcHE=", + "requires": { + "babel-core": "^6.26.0", + "babel-runtime": "^6.26.0", + "core-js": "^2.5.0", + "home-or-tmp": "^2.0.0", + "lodash": "^4.17.4", + "mkdirp": "^0.5.1", + "source-map-support": "^0.4.15" + } + }, + "babel-runtime": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-6.26.0.tgz", + "integrity": "sha1-llxwWGaOgrVde/4E/yM3vItWR/4=", + "requires": { + "core-js": "^2.4.0", + "regenerator-runtime": "^0.11.0" + } + }, + "babel-template": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-template/-/babel-template-6.26.0.tgz", + "integrity": "sha1-3gPi0WOWsGn0bdn/+FIfsaDjXgI=", + "requires": { + "babel-runtime": "^6.26.0", + "babel-traverse": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "lodash": "^4.17.4" + } + }, + "babel-traverse": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-traverse/-/babel-traverse-6.26.0.tgz", + "integrity": "sha1-RqnL1+3MYsjlwGTi0tjQ9ANXZu4=", + "requires": { + "babel-code-frame": "^6.26.0", + "babel-messages": "^6.23.0", + "babel-runtime": "^6.26.0", + "babel-types": "^6.26.0", + "babylon": "^6.18.0", + "debug": "^2.6.8", + "globals": "^9.18.0", + "invariant": "^2.2.2", + "lodash": "^4.17.4" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "babel-types": { + "version": "6.26.0", + "resolved": "https://registry.npmjs.org/babel-types/-/babel-types-6.26.0.tgz", + "integrity": "sha1-o7Bz+Uq0nrb6Vc1lInozQ4BjJJc=", + "requires": { + "babel-runtime": "^6.26.0", + "esutils": "^2.0.2", + "lodash": "^4.17.4", + "to-fast-properties": "^1.0.3" + } + }, + "babelify": { + "version": "7.3.0", + "resolved": "https://registry.npmjs.org/babelify/-/babelify-7.3.0.tgz", + "integrity": "sha1-qlau3nBn/XvVSWZu4W3ChQh+iOU=", + "requires": { + "babel-core": "^6.0.14", + "object-assign": "^4.0.0" + } + }, + "babylon": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==" + }, + "backoff": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/backoff/-/backoff-2.5.0.tgz", + "integrity": "sha1-9hbtqdPktmuMp/ynn2lXIsX44m8=", + "requires": { + "precond": "0.2" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base-x": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.4.tgz", + "integrity": "sha512-UYOadoSIkEI/VrRGSG6qp93rp2WdokiAiNYDfGW5qURAY8GiAQkvMbwNNSDYiVJopqv4gCna7xqf4rrNGp+5AA==", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "base64-js": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz", + "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==" + }, + "bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", + "optional": true, + "requires": { + "tweetnacl": "^0.14.3" + }, + "dependencies": { + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + } + } + }, + "bignumber.js": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-6.0.0.tgz", + "integrity": "sha512-x247jIuy60/+FtMRvscqfxtVHQf8AGx2hm9c6btkgC0x/hp9yt+teISNhvF8WlwRkCc5yF2fDECH8SIMe8j+GA==" + }, + "bindings": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.0.tgz", + "integrity": "sha512-DpLh5EzMR2kzvX1KIlVC0VkC3iZtHKTgdtZ0a3pglBZdaQFjt5S9g9xd1lE+YvXyfd6mtCeRnrUfOLYiTMlNSw==" + }, + "bip39": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/bip39/-/bip39-2.5.0.tgz", + "integrity": "sha512-xwIx/8JKoT2+IPJpFEfXoWdYwP7UVAoUxxLNfGCfVowaJE7yg1Y5B1BVPqlUNsBq5/nGwmFkwRJ8xDW4sX8OdA==", + "requires": { + "create-hash": "^1.1.0", + "pbkdf2": "^3.0.9", + "randombytes": "^2.0.1", + "safe-buffer": "^5.0.1", + "unorm": "^1.3.3" + } + }, + "bip66": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bip66/-/bip66-1.1.5.tgz", + "integrity": "sha1-AfqHSHhcpwlV1QESF9GzE5lpyiI=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "bitcore-lib": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/bitcore-lib/-/bitcore-lib-0.15.0.tgz", + "integrity": "sha512-AeXLWhiivF6CDFzrABZHT4jJrflyylDWTi32o30rF92HW9msfuKpjzrHtFKYGa9w0kNVv5HABQjCB3OEav4PhQ==", + "requires": { + "bn.js": "=4.11.8", + "bs58": "=4.0.1", + "buffer-compare": "=1.1.1", + "elliptic": "=6.4.0", + "inherits": "=2.0.1", + "lodash": "=4.17.4" + }, + "dependencies": { + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" + }, + "lodash": { + "version": "4.17.4", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.4.tgz", + "integrity": "sha1-eCA6TRwyiuHYbcpkYONptX9AVa4=" + } + } + }, + "bitcore-mnemonic": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/bitcore-mnemonic/-/bitcore-mnemonic-1.5.0.tgz", + "integrity": "sha512-sbeP4xwkindLMfIQhVxj6rZSDMwtiKmfc1DqvwpR6Yg+Qo4I4WHO5pvzb12Y04uDh1N3zgD45esHhfH0HHmE4g==", + "requires": { + "bitcore-lib": "^0.15.0", + "unorm": "^1.3.3" + } + }, + "bl": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/bl/-/bl-1.2.2.tgz", + "integrity": "sha512-e8tQYnZodmebYDWGH7KMRvtzKXaJHx3BbilrgZCfvyLUYdKpK1t5PSPmpkny/SgiTSCnjfLW7v5rlONXVFkQEA==", + "requires": { + "readable-stream": "^2.3.5", + "safe-buffer": "^5.1.1" + } + }, + "block-stream": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz", + "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=", + "requires": { + "inherits": "~2.0.0" + } + }, + "bluebird": { + "version": "3.5.1", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.1.tgz", + "integrity": "sha512-MKiLiV+I1AA596t9w1sQJ8jkiSr5+ZKi0WKrYGUn6d1Fx+Ij4tIj+m2WMQSGczs5jZVxV339chE8iwk6F64wjA==" + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==" + }, + "body-parser": { + "version": "1.18.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz", + "integrity": "sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=", + "requires": { + "bytes": "3.0.0", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "~1.1.2", + "http-errors": "~1.6.3", + "iconv-lite": "0.4.23", + "on-finished": "~2.3.0", + "qs": "6.5.2", + "raw-body": "2.3.3", + "type-is": "~1.6.16" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "borc": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/borc/-/borc-2.0.3.tgz", + "integrity": "sha512-2mfipKUXn7yLgwn8D5jZkJqd2ZyzqmYZQX/9d4On33oGNDLwxj5qQMst+nkKyEdaujQRFfrZCId+k8wehQVANg==", + "requires": { + "bignumber.js": "^6.0.0", + "commander": "^2.15.0", + "ieee754": "^1.1.8", + "json-text-sequence": "^0.1" + }, + "dependencies": { + "commander": { + "version": "2.16.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.16.0.tgz", + "integrity": "sha512-sVXqklSaotK9at437sFlFpyOcJonxe0yST/AG9DkQKUdIE6IqGIMv4SfAQSKaJbSdVEJYItASCrBiVQHq1HQew==" + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=" + }, + "browser-stdout": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/browser-stdout/-/browser-stdout-1.3.0.tgz", + "integrity": "sha1-81HTKWnTL6XXpVZxVCY9korjvR8=" + }, + "browserify-aes": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "requires": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "browserify-cipher": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", + "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", + "requires": { + "browserify-aes": "^1.0.4", + "browserify-des": "^1.0.0", + "evp_bytestokey": "^1.0.0" + } + }, + "browserify-des": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", + "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", + "requires": { + "cipher-base": "^1.0.1", + "des.js": "^1.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "requires": { + "bn.js": "^4.1.0", + "randombytes": "^2.0.1" + } + }, + "browserify-sha3": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/browserify-sha3/-/browserify-sha3-0.0.1.tgz", + "integrity": "sha1-P/NKMAbvFcD7NWflQbkaI0ASPRE=", + "requires": { + "js-sha3": "^0.3.1" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "requires": { + "bn.js": "^4.1.1", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.2", + "elliptic": "^6.0.0", + "inherits": "^2.0.1", + "parse-asn1": "^5.0.0" + }, + "dependencies": { + "elliptic": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", + "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + } + } + }, + "browserslist": { + "version": "3.2.8", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-3.2.8.tgz", + "integrity": "sha512-WHVocJYavUwVgVViC0ORikPHQquXwVh939TaelZ4WDqpWgTX/FsGhl/+P4qBUAGcRvtOgDgC+xftNWWp2RUTAQ==", + "requires": { + "caniuse-lite": "^1.0.30000844", + "electron-to-chromium": "^1.3.47" + } + }, + "bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha1-vhYedsNU9veIrkBx9j806MTwpCo=", + "requires": { + "base-x": "^3.0.2" + } + }, + "bs58check": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/bs58check/-/bs58check-1.3.4.tgz", + "integrity": "sha1-xSVABzdJEXcU+gQsMEfrj5FRy/g=", + "requires": { + "bs58": "^3.1.0", + "create-hash": "^1.1.0" + }, + "dependencies": { + "base-x": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-1.1.0.tgz", + "integrity": "sha1-QtPXF0dPnqAiB/bRqh9CaRPut6w=" + }, + "bs58": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-3.1.0.tgz", + "integrity": "sha1-1MJjiL9IBMrHFBQbGUWqR+XrJI4=", + "requires": { + "base-x": "^1.1.0" + } + } + } + }, + "bson": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/bson/-/bson-1.0.9.tgz", + "integrity": "sha512-IQX9/h7WdMBIW/q/++tGd+emQr0XMdeZ6icnT/74Xk9fnabWn+gZgpE+9V+gujL3hhJOoNrnDVY7tWdzc7NUTg==", + "optional": true + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + }, + "buffer-alloc": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz", + "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==", + "requires": { + "buffer-alloc-unsafe": "^1.1.0", + "buffer-fill": "^1.0.0" + } + }, + "buffer-alloc-unsafe": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz", + "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==" + }, + "buffer-compare": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-compare/-/buffer-compare-1.1.1.tgz", + "integrity": "sha1-W+e+hTr4kZjR9N3AkNHWakiu9ZY=" + }, + "buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=" + }, + "buffer-fill": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz", + "integrity": "sha1-+PeLdniYiO858gXNY39o5wISKyw=" + }, + "buffer-from": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.1.tgz", + "integrity": "sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==" + }, + "buffer-to-arraybuffer": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/buffer-to-arraybuffer/-/buffer-to-arraybuffer-0.0.5.tgz", + "integrity": "sha1-YGSkD6dutDxyOrqe+PbhIW0QURo=" + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=" + }, + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=" + }, + "bytes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz", + "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=" + }, + "camelcase": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-3.0.0.tgz", + "integrity": "sha1-MvxLn82vhF/N9+c7uXysImHwqwo=" + }, + "caminte": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/caminte/-/caminte-0.3.7.tgz", + "integrity": "sha1-7B7ARXZkoPCSZDt8ZGxFfVzW9pM=", + "requires": { + "bluebird": "^3.4.6", + "uuid": "^3.0.1" + } + }, + "caniuse-lite": { + "version": "1.0.30000883", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30000883.tgz", + "integrity": "sha512-ovvb0uya4cKJct8Rj9Olstz0LaWmyJhCp3NawRG5fVigka8pEhIIwipF7zyYd2Q58UZb5YfIt52pVF444uj2kQ==" + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "chalk": { + "version": "1.1.3", + "resolved": "http://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "requires": { + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" + }, + "dependencies": { + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=" + } + } + }, + "checkpoint-store": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/checkpoint-store/-/checkpoint-store-1.1.0.tgz", + "integrity": "sha1-BOTLUWuRQziTWB5tRgGnjpVS6gY=", + "requires": { + "functional-red-black-tree": "^1.0.1" + } + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "cliui": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", + "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", + "requires": { + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1", + "wrap-ansi": "^2.0.0" + } + }, + "clone": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.1.tgz", + "integrity": "sha1-0hfR6WERjjrJpLi7oyhVU79kfNs=" + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=" + }, + "coinstring": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/coinstring/-/coinstring-2.3.0.tgz", + "integrity": "sha1-zbYzY6lhUCQEolr7gsLibV/2J6Q=", + "requires": { + "bs58": "^2.0.1", + "create-hash": "^1.1.1" + }, + "dependencies": { + "bs58": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-2.0.1.tgz", + "integrity": "sha1-VZCNWPGYKrogCPob7Y+RmYopv40=" + } + } + }, + "colors": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.3.1.tgz", + "integrity": "sha512-jg/vxRmv430jixZrC+La5kMbUWqIg32/JsYNZb94+JEmzceYbWKTsv1OuTp+7EaqiaWRR2tPcykibwCRgclIsw==" + }, + "combined-stream": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", + "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", + "requires": { + "delayed-stream": "~1.0.0" + } + }, + "commander": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.11.0.tgz", + "integrity": "sha512-b0553uYA5YAEGgyYIGYROzKQ7X5RAqedkfjiZxwi0kL1g3bOaBNNZfYkzt/CL0umgD5wc9Jec2FbB98CjkMRvQ==" + }, + "compare-versions": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/compare-versions/-/compare-versions-3.3.0.tgz", + "integrity": "sha512-MAAAIOdi2s4Gl6rZ76PNcUa9IOYB+5ICdT41o5uMRf09aEu/F9RK+qhe8RjXNPwcTjGV7KU7h2P/fljThFVqyQ==" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "requires": { + "buffer-from": "^1.0.0", + "inherits": "^2.0.3", + "readable-stream": "^2.2.2", + "typedarray": "^0.0.6" + } + }, + "content-disposition": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz", + "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ=" + }, + "content-type": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==" + }, + "convert-source-map": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", + "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=" + }, + "cookie": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz", + "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=" + }, + "cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw=" + }, + "cookiejar": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.2.tgz", + "integrity": "sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA==" + }, + "core-js": { + "version": "2.5.7", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.7.tgz", + "integrity": "sha512-RszJCAxg/PP6uzXVXL6BsxSXx/B05oJAQ2vkJRjyjrEcNVycaqOmNb5OTxZPE3xa5gwZduqza6L9JOCenh/Ecw==" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "cors": { + "version": "2.8.4", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.4.tgz", + "integrity": "sha1-K9OB8usgECAQXNUOpZ2mMJBpRoY=", + "requires": { + "object-assign": "^4", + "vary": "^1" + } + }, + "create-ecdh": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz", + "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", + "requires": { + "bn.js": "^4.1.0", + "elliptic": "^6.0.0" + }, + "dependencies": { + "elliptic": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", + "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + } + } + }, + "create-hash": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "cron-parser": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/cron-parser/-/cron-parser-2.5.0.tgz", + "integrity": "sha512-gzmXu16/prizIbKPPKJo+WgBpV7k8Rxxu9FgaANW+vx5DebCXavfRqbROjKkr9ETvVPqs+IO+NXj4GG/eLf8zQ==", + "requires": { + "is-nan": "^1.2.1", + "moment-timezone": "^0.5.0" + } + }, + "cross-fetch": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-2.2.2.tgz", + "integrity": "sha1-pH/09/xxLauo9qaVoRyUhEDUVyM=", + "requires": { + "node-fetch": "2.1.2", + "whatwg-fetch": "2.0.4" + } + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "requires": { + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" + } + }, + "crypto-js": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.8.tgz", + "integrity": "sha1-cV8HC/YBTyrpkqmLOSkli3E/CNU=" + }, + "crypto-random-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-1.0.0.tgz", + "integrity": "sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=" + }, + "csextends": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/csextends/-/csextends-1.2.0.tgz", + "integrity": "sha512-S/8k1bDTJIwuGgQYmsRoE+8P+ohV32WhQ0l4zqrc0XDdxOhjQQD7/wTZwCzoZX53jSX3V/qwjT+OkPTxWQcmjg==" + }, + "cycle": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cycle/-/cycle-1.0.3.tgz", + "integrity": "sha1-IegLK+hYD5i0aPN5QwZisEbDStI=" + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "debug": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.1.0.tgz", + "integrity": "sha512-OX8XqP7/1a9cqkxYw2yXss15f26NKWBpDXQd0/uK/KPqdQhxbPa994hnzjcE2VqQpDslf55723cKPUOGSmMY3g==", + "requires": { + "ms": "2.0.0" + } + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + }, + "decode-uri-component": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", + "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=" + }, + "decompress": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/decompress/-/decompress-4.2.0.tgz", + "integrity": "sha1-eu3YVCflqS2s/lVnSnxQXpbQH50=", + "requires": { + "decompress-tar": "^4.0.0", + "decompress-tarbz2": "^4.0.0", + "decompress-targz": "^4.0.0", + "decompress-unzip": "^4.0.1", + "graceful-fs": "^4.1.10", + "make-dir": "^1.0.0", + "pify": "^2.3.0", + "strip-dirs": "^2.0.0" + } + }, + "decompress-response": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", + "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", + "requires": { + "mimic-response": "^1.0.0" + } + }, + "decompress-tar": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tar/-/decompress-tar-4.1.1.tgz", + "integrity": "sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==", + "requires": { + "file-type": "^5.2.0", + "is-stream": "^1.1.0", + "tar-stream": "^1.5.2" + } + }, + "decompress-tarbz2": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz", + "integrity": "sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==", + "requires": { + "decompress-tar": "^4.1.0", + "file-type": "^6.1.0", + "is-stream": "^1.1.0", + "seek-bzip": "^1.0.5", + "unbzip2-stream": "^1.0.9" + }, + "dependencies": { + "file-type": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-6.2.0.tgz", + "integrity": "sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==" + } + } + }, + "decompress-targz": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-targz/-/decompress-targz-4.1.1.tgz", + "integrity": "sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==", + "requires": { + "decompress-tar": "^4.1.1", + "file-type": "^5.2.0", + "is-stream": "^1.1.0" + } + }, + "decompress-unzip": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/decompress-unzip/-/decompress-unzip-4.0.1.tgz", + "integrity": "sha1-3qrM39FK6vhVePczroIQ+bSEj2k=", + "requires": { + "file-type": "^3.8.0", + "get-stream": "^2.2.0", + "pify": "^2.3.0", + "yauzl": "^2.4.2" + }, + "dependencies": { + "file-type": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz", + "integrity": "sha1-JXoHg4TR24CHvESdEH1SpSZyuek=" + }, + "get-stream": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-2.3.1.tgz", + "integrity": "sha1-Xzj5PzRgCWZu4BUKBUFn+Rvdld4=", + "requires": { + "object-assign": "^4.0.1", + "pinkie-promise": "^2.0.0" + } + } + } + }, + "deep-equal": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz", + "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=" + }, + "deferred-leveldown": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/deferred-leveldown/-/deferred-leveldown-1.2.2.tgz", + "integrity": "sha512-uukrWD2bguRtXilKt6cAWKyoXrTSMo5m7crUdLfWQmu8kIm88w3QZoUL+6nhpfKVmhHANER6Re3sKoNoZ3IKMA==", + "requires": { + "abstract-leveldown": "~2.6.0" + } + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "requires": { + "foreach": "^2.0.5", + "object-keys": "^1.0.8" + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "delimit-stream": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/delimit-stream/-/delimit-stream-0.1.0.tgz", + "integrity": "sha1-m4MZR3wOX4rrPONXrjBfwl6hzSs=" + }, + "depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=" + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "requires": { + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "destroy": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz", + "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=" + }, + "detect-indent": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-4.0.0.tgz", + "integrity": "sha1-920GQ1LN9Docts5hnE7jqUdd4gg=", + "requires": { + "repeating": "^2.0.0" + } + }, + "diff": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/diff/-/diff-3.3.1.tgz", + "integrity": "sha512-MKPHZDMB0o6yHyDryUOScqZibp914ksXwAMYMTHj6KO8UeKsRYNJD3oNCKjTqZon+V488P7N/HzXF8t7ZR95ww==" + }, + "diffie-hellman": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", + "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", + "requires": { + "bn.js": "^4.1.0", + "miller-rabin": "^4.0.0", + "randombytes": "^2.0.0" + } + }, + "dom-walk": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.1.tgz", + "integrity": "sha1-ZyIm3HTI95mtNTB9+TaroRrNYBg=" + }, + "drbg.js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz", + "integrity": "sha1-Pja2xCs3BDgjzbwzLVjzHiRFSAs=", + "requires": { + "browserify-aes": "^1.0.6", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4" + } + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=" + }, + "eachr": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/eachr/-/eachr-2.0.4.tgz", + "integrity": "sha1-Rm98qhBwj2EFCeMsgHqv5X/BIr8=", + "requires": { + "typechecker": "^2.0.8" + } + }, + "ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", + "optional": true, + "requires": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "editions": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/editions/-/editions-1.3.4.tgz", + "integrity": "sha512-gzao+mxnYDzIysXKMQi/+M1mjy/rjestjg6OPoYTtI+3Izp23oiGZitsl9lPDPiTGXbcSIk1iJWhliSaglxnUg==" + }, + "ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=" + }, + "electron-to-chromium": { + "version": "1.3.62", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.62.tgz", + "integrity": "sha512-x09ndL/Gjnuk3unlAyoGyUg3wbs4w/bXurgL7wL913vXHAOWmMhrLf1VNGRaMLngmadd5Q8gsV9BFuIr6rP+Xg==" + }, + "elliptic": { + "version": "3.1.0", + "resolved": "http://registry.npmjs.org/elliptic/-/elliptic-3.1.0.tgz", + "integrity": "sha1-whaC73YnabVqdCAWCRBdoR1fYMw=", + "requires": { + "bn.js": "^2.0.3", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "inherits": "^2.0.1" + }, + "dependencies": { + "bn.js": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-2.2.0.tgz", + "integrity": "sha1-EhYrwq5x/EClYmwzQ486h1zTdiU=" + } + } + }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=" + }, + "encoding": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz", + "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=", + "requires": { + "iconv-lite": "~0.4.13" + } + }, + "end-of-stream": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz", + "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", + "requires": { + "once": "^1.4.0" + } + }, + "errno": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz", + "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==", + "requires": { + "prr": "~1.0.1" + } + }, + "error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "requires": { + "is-arrayish": "^0.2.1" + } + }, + "es-abstract": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz", + "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==", + "requires": { + "es-to-primitive": "^1.1.1", + "function-bind": "^1.1.1", + "has": "^1.0.1", + "is-callable": "^1.1.3", + "is-regex": "^1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "requires": { + "is-callable": "^1.1.1", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.1" + } + }, + "escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=" + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=" + }, + "etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=" + }, + "eth-block-tracker": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/eth-block-tracker/-/eth-block-tracker-3.0.1.tgz", + "integrity": "sha512-WUVxWLuhMmsfenfZvFO5sbl1qFY2IqUlw/FPVmjjdElpqLsZtSG+wPe9Dz7W/sB6e80HgFKknOmKk2eNlznHug==", + "requires": { + "eth-query": "^2.1.0", + "ethereumjs-tx": "^1.3.3", + "ethereumjs-util": "^5.1.3", + "ethjs-util": "^0.1.3", + "json-rpc-engine": "^3.6.0", + "pify": "^2.3.0", + "tape": "^4.6.3" + } + }, + "eth-json-rpc-infura": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/eth-json-rpc-infura/-/eth-json-rpc-infura-3.1.2.tgz", + "integrity": "sha512-IuK5Iowfs6taluA/3Okmu6EfZcFMq6MQuyrUL1PrCoJstuuBr3TvVeSy3keDyxfbrjFB34nCo538I8G+qMtsbw==", + "requires": { + "cross-fetch": "^2.1.1", + "eth-json-rpc-middleware": "^1.5.0", + "json-rpc-engine": "^3.4.0", + "json-rpc-error": "^2.0.0", + "tape": "^4.8.0" + } + }, + "eth-json-rpc-middleware": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/eth-json-rpc-middleware/-/eth-json-rpc-middleware-1.6.0.tgz", + "integrity": "sha512-tDVCTlrUvdqHKqivYMjtFZsdD7TtpNLBCfKAcOpaVs7orBMS/A8HWro6dIzNtTZIR05FAbJ3bioFOnZpuCew9Q==", + "requires": { + "async": "^2.5.0", + "eth-query": "^2.1.2", + "eth-tx-summary": "^3.1.2", + "ethereumjs-block": "^1.6.0", + "ethereumjs-tx": "^1.3.3", + "ethereumjs-util": "^5.1.2", + "ethereumjs-vm": "^2.1.0", + "fetch-ponyfill": "^4.0.0", + "json-rpc-engine": "^3.6.0", + "json-rpc-error": "^2.0.0", + "json-stable-stringify": "^1.0.1", + "promise-to-callback": "^1.0.0", + "tape": "^4.6.3" + } + }, + "eth-lib": { + "version": "0.1.27", + "resolved": "https://registry.npmjs.org/eth-lib/-/eth-lib-0.1.27.tgz", + "integrity": "sha512-B8czsfkJYzn2UIEMwjc7Mbj+Cy72V+/OXH/tb44LV8jhrjizQJJ325xMOMyk3+ETa6r6oi0jsUY14+om8mQMWA==", + "requires": { + "bn.js": "^4.11.6", + "elliptic": "^6.4.0", + "keccakjs": "^0.2.1", + "nano-json-stream-parser": "^0.1.2", + "servify": "^0.1.12", + "ws": "^3.0.0", + "xhr-request-promise": "^0.1.2" + }, + "dependencies": { + "elliptic": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", + "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + } + } + }, + "eth-lightwallet": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/eth-lightwallet/-/eth-lightwallet-3.0.1.tgz", + "integrity": "sha512-79vVCETy+4l1b6wuOWwjqPW3Bom5ZK46BgkUNwaXhiMG1rrMRHjpjYEWMqH0JHeCzOzB4HBIFz7eK1/4s6w5nA==", + "requires": { + "bitcore-lib": "^0.15.0", + "bitcore-mnemonic": "^1.5.0", + "buffer": "^4.9.0", + "crypto-js": "^3.1.5", + "elliptic": "^3.1.0", + "ethereumjs-tx": "^1.3.3", + "ethereumjs-util": "^5.1.1", + "rlp": "^2.0.0", + "scrypt-async": "^1.2.0", + "tweetnacl": "0.13.2", + "web3": "0.20.2" + }, + "dependencies": { + "bignumber.js": { + "version": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "from": "git+https://github.com/frozeman/bignumber.js-nolookahead.git" + }, + "web3": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/web3/-/web3-0.20.2.tgz", + "integrity": "sha1-xU2sX8DjdzmcBMGm7LsS5FEyeNY=", + "requires": { + "bignumber.js": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "crypto-js": "^3.1.4", + "utf8": "^2.1.1", + "xhr2": "*", + "xmlhttprequest": "*" + }, + "dependencies": { + "bignumber.js": { + "version": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "from": "git+https://github.com/frozeman/bignumber.js-nolookahead.git" + } + } + } + } + }, + "eth-query": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/eth-query/-/eth-query-2.1.2.tgz", + "integrity": "sha1-1nQdkAAQa1FRDHLbktY2VFam2l4=", + "requires": { + "json-rpc-random-id": "^1.0.0", + "xtend": "^4.0.1" + } + }, + "eth-sig-util": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/eth-sig-util/-/eth-sig-util-1.4.2.tgz", + "integrity": "sha1-jZWCAsftuq6Dlwf7pvCf8ydgYhA=", + "requires": { + "ethereumjs-abi": "git+https://github.com/ethereumjs/ethereumjs-abi.git#00ba8463a7f7a67fcad737ff9c2ebd95643427f7", + "ethereumjs-util": "^5.1.1" + }, + "dependencies": { + "ethereumjs-abi": { + "version": "git+https://github.com/ethereumjs/ethereumjs-abi.git#00ba8463a7f7a67fcad737ff9c2ebd95643427f7", + "from": "git+https://github.com/ethereumjs/ethereumjs-abi.git", + "requires": { + "bn.js": "^4.10.0", + "ethereumjs-util": "^5.0.0" + } + } + } + }, + "eth-tx-summary": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/eth-tx-summary/-/eth-tx-summary-3.2.3.tgz", + "integrity": "sha512-1gZpA5fKarJOVSb5OUlPnhDQuIazqAkI61zlVvf5LdG47nEgw+/qhyZnuj3CUdE/TLTKuRzPLeyXLjaB4qWTRQ==", + "requires": { + "async": "^2.1.2", + "bn.js": "^4.11.8", + "clone": "^2.0.0", + "concat-stream": "^1.5.1", + "end-of-stream": "^1.1.0", + "eth-query": "^2.0.2", + "ethereumjs-block": "^1.4.1", + "ethereumjs-tx": "^1.1.1", + "ethereumjs-util": "^5.0.1", + "ethereumjs-vm": "2.3.4", + "through2": "^2.0.3", + "treeify": "^1.0.1", + "web3-provider-engine": "^13.3.2" + }, + "dependencies": { + "eth-block-tracker": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/eth-block-tracker/-/eth-block-tracker-2.3.1.tgz", + "integrity": "sha512-NamWuMBIl8kmkJFVj8WzGatySTzQPQag4Xr677yFxdVtIxACFbL/dQowk0MzEqIKk93U1TwY3MjVU6mOcwZnKA==", + "requires": { + "async-eventemitter": "github:ahultgren/async-eventemitter#fa06e39e56786ba541c180061dbf2c0a5bbf951c", + "eth-query": "^2.1.0", + "ethereumjs-tx": "^1.3.3", + "ethereumjs-util": "^5.1.3", + "ethjs-util": "^0.1.3", + "json-rpc-engine": "^3.6.0", + "pify": "^2.3.0", + "tape": "^4.6.3" + }, + "dependencies": { + "async-eventemitter": { + "version": "github:ahultgren/async-eventemitter#fa06e39e56786ba541c180061dbf2c0a5bbf951c", + "from": "github:ahultgren/async-eventemitter#fa06e39e56786ba541c180061dbf2c0a5bbf951c", + "requires": { + "async": "^2.4.0" + } + } + } + }, + "ethereum-common": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.2.0.tgz", + "integrity": "sha512-XOnAR/3rntJgbCdGhqdaLIxDLWKLmsZOGhHdBKadEr6gEnJLH52k93Ou+TUdFaPN3hJc3isBZBal3U/XZ15abA==" + }, + "ethereumjs-vm": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/ethereumjs-vm/-/ethereumjs-vm-2.3.4.tgz", + "integrity": "sha512-Y4SlzNDqxrCO58jhp98HdnZVdjOqB+HC0hoU+N/DEp1aU+hFkRX/nru5F7/HkQRPIlA6aJlQp/xIA6xZs1kspw==", + "requires": { + "async": "^2.1.2", + "async-eventemitter": "^0.2.2", + "ethereum-common": "0.2.0", + "ethereumjs-account": "^2.0.3", + "ethereumjs-block": "~1.7.0", + "ethereumjs-util": "^5.1.3", + "fake-merkle-patricia-tree": "^1.0.1", + "functional-red-black-tree": "^1.0.1", + "merkle-patricia-tree": "^2.1.2", + "rustbn.js": "~0.1.1", + "safe-buffer": "^5.1.1" + } + }, + "web3-provider-engine": { + "version": "13.8.0", + "resolved": "https://registry.npmjs.org/web3-provider-engine/-/web3-provider-engine-13.8.0.tgz", + "integrity": "sha512-fZXhX5VWwWpoFfrfocslyg6P7cN3YWPG/ASaevNfeO80R+nzgoPUBXcWQekSGSsNDkeRTis4aMmpmofYf1TNtQ==", + "requires": { + "async": "^2.5.0", + "clone": "^2.0.0", + "eth-block-tracker": "^2.2.2", + "eth-sig-util": "^1.4.2", + "ethereumjs-block": "^1.2.2", + "ethereumjs-tx": "^1.2.0", + "ethereumjs-util": "^5.1.1", + "ethereumjs-vm": "^2.0.2", + "fetch-ponyfill": "^4.0.0", + "json-rpc-error": "^2.0.0", + "json-stable-stringify": "^1.0.1", + "promise-to-callback": "^1.0.0", + "readable-stream": "^2.2.9", + "request": "^2.67.0", + "semaphore": "^1.0.3", + "solc": "^0.4.2", + "tape": "^4.4.0", + "xhr": "^2.2.0", + "xtend": "^4.0.1" + } + } + } + }, + "ethereum-bridge": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/ethereum-bridge/-/ethereum-bridge-0.6.1.tgz", + "integrity": "sha512-yDTivI85618BoLI71yNRzW6iVcVN2rjnviCIzs0QOCOENj4XpYQhMDGhdqDi8XWDdzTd0Ja/Canuuh3vfE2IcA==", + "requires": { + "async": "^2.4.1", + "borc": "^2.0.2", + "caminte": "0.3.7", + "colors": "^1.1.2", + "compare-versions": "^3.0.1", + "crypto-random-string": "^1.0.0", + "eth-lightwallet": "^3.0.1", + "ethereumjs-abi": "0.6.4", + "ethereumjs-tx": "^1.3.1", + "ethereumjs-util": "^5.2.0", + "i18n": "^0.8.3", + "moment": "^2.22.2", + "multihashes": "^0.4.5", + "node-async-loop": "^1.2.2", + "node-cache": "^4.1.1", + "node-schedule": "^1.2.3", + "pragma-singleton": "1.0.3", + "request": "^2.81.0", + "semver": "^5.5.0", + "stdio": "^0.2.7", + "tingodb": "^0.6.1", + "underscore": "^1.8.3", + "utf8": "^2.1.2", + "web3": "0.19.1", + "winston": "^2.3.1" + }, + "dependencies": { + "bignumber.js": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-4.1.0.tgz", + "integrity": "sha512-eJzYkFYy9L4JzXsbymsFn3p54D+llV27oTQ+ziJG7WFRheJcNZilgVXMG0LoZtlQSKBsJdWtLFqOD0u+U0jZKA==" + }, + "web3": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/web3/-/web3-0.19.1.tgz", + "integrity": "sha1-52PVsRB8S8JKvU+MvuG6Nlnm6zE=", + "requires": { + "bignumber.js": "^4.0.2", + "crypto-js": "^3.1.4", + "utf8": "^2.1.1", + "xhr2": "*", + "xmlhttprequest": "*" + } + } + } + }, + "ethereum-common": { + "version": "0.0.18", + "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.18.tgz", + "integrity": "sha1-L9w1dvIykDNYl26znaeDIT/5Uj8=" + }, + "ethereumjs-abi": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.4.tgz", + "integrity": "sha1-m6G7BWSS0AwnJ59uzNTVgnWRLBo=", + "requires": { + "bn.js": "^4.10.0", + "ethereumjs-util": "^4.3.0" + }, + "dependencies": { + "ethereumjs-util": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz", + "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=", + "requires": { + "bn.js": "^4.8.0", + "create-hash": "^1.1.2", + "keccakjs": "^0.2.0", + "rlp": "^2.0.0", + "secp256k1": "^3.0.1" + } + } + } + }, + "ethereumjs-account": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/ethereumjs-account/-/ethereumjs-account-2.0.5.tgz", + "integrity": "sha512-bgDojnXGjhMwo6eXQC0bY6UK2liSFUSMwwylOmQvZbSl/D7NXQ3+vrGO46ZeOgjGfxXmgIeVNDIiHw7fNZM4VA==", + "requires": { + "ethereumjs-util": "^5.0.0", + "rlp": "^2.0.0", + "safe-buffer": "^5.1.1" + } + }, + "ethereumjs-block": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/ethereumjs-block/-/ethereumjs-block-1.7.1.tgz", + "integrity": "sha512-B+sSdtqm78fmKkBq78/QLKJbu/4Ts4P2KFISdgcuZUPDm9x+N7qgBPIIFUGbaakQh8bzuquiRVbdmvPKqbILRg==", + "requires": { + "async": "^2.0.1", + "ethereum-common": "0.2.0", + "ethereumjs-tx": "^1.2.2", + "ethereumjs-util": "^5.0.0", + "merkle-patricia-tree": "^2.1.2" + }, + "dependencies": { + "ethereum-common": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.2.0.tgz", + "integrity": "sha512-XOnAR/3rntJgbCdGhqdaLIxDLWKLmsZOGhHdBKadEr6gEnJLH52k93Ou+TUdFaPN3hJc3isBZBal3U/XZ15abA==" + } + } + }, + "ethereumjs-common": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/ethereumjs-common/-/ethereumjs-common-0.4.1.tgz", + "integrity": "sha512-ywYGsOeGCsMNWso5Y4GhjWI24FJv9FK7+VyVKiQgXg8ZRDPXJ7F/kJ1CnjtkjTvDF4e0yqU+FWswlqR3bmZQ9Q==" + }, + "ethereumjs-tx": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-1.3.7.tgz", + "integrity": "sha512-wvLMxzt1RPhAQ9Yi3/HKZTn0FZYpnsmQdbKYfUUpi4j1SEIcbkd9tndVjcPrufY3V7j2IebOpC00Zp2P/Ay2kA==", + "requires": { + "ethereum-common": "^0.0.18", + "ethereumjs-util": "^5.0.0" + } + }, + "ethereumjs-util": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-5.2.0.tgz", + "integrity": "sha512-CJAKdI0wgMbQFLlLRtZKGcy/L6pzVRgelIZqRqNbuVFM3K9VEnyfbcvz0ncWMRNCe4kaHWjwRYQcYMucmwsnWA==", + "requires": { + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "ethjs-util": "^0.1.3", + "keccak": "^1.0.2", + "rlp": "^2.0.0", + "safe-buffer": "^5.1.1", + "secp256k1": "^3.0.1" + } + }, + "ethereumjs-vm": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/ethereumjs-vm/-/ethereumjs-vm-2.4.0.tgz", + "integrity": "sha512-MJ4lCWa5c6LhahhhvoDKW+YGjK00ZQn0RHHLh4L+WaH1k6Qv7/q3uTluew6sJGNCZdlO0yYMDXYW9qyxLHKlgQ==", + "requires": { + "async": "^2.1.2", + "async-eventemitter": "^0.2.2", + "ethereumjs-account": "^2.0.3", + "ethereumjs-block": "~1.7.0", + "ethereumjs-common": "~0.4.0", + "ethereumjs-util": "^5.2.0", + "fake-merkle-patricia-tree": "^1.0.1", + "functional-red-black-tree": "^1.0.1", + "merkle-patricia-tree": "^2.1.2", + "rustbn.js": "~0.2.0", + "safe-buffer": "^5.1.1" + }, + "dependencies": { + "rustbn.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.2.0.tgz", + "integrity": "sha512-4VlvkRUuCJvr2J6Y0ImW7NvTCriMi7ErOAqWk1y69vAdoNIzCF3yPmgeNzx+RQTLEDFq5sHfscn1MwHxP9hNfA==" + } + } + }, + "ethereumjs-wallet": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/ethereumjs-wallet/-/ethereumjs-wallet-0.6.0.tgz", + "integrity": "sha1-gnY7Fpfuenlr5xVdqd+0my+Yz9s=", + "requires": { + "aes-js": "^0.2.3", + "bs58check": "^1.0.8", + "ethereumjs-util": "^4.4.0", + "hdkey": "^0.7.0", + "scrypt.js": "^0.2.0", + "utf8": "^2.1.1", + "uuid": "^2.0.1" + }, + "dependencies": { + "ethereumjs-util": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz", + "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=", + "requires": { + "bn.js": "^4.8.0", + "create-hash": "^1.1.2", + "keccakjs": "^0.2.0", + "rlp": "^2.0.0", + "secp256k1": "^3.0.1" + } + }, + "uuid": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.3.tgz", + "integrity": "sha1-Z+LoY3lyFVMN/zGOW/nc6/1Hsho=" + } + } + }, + "ethjs-unit": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz", + "integrity": "sha1-xmWSHkduh7ziqdWIpv4EBbLEFpk=", + "requires": { + "bn.js": "4.11.6", + "number-to-bn": "1.7.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "requires": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + } + }, + "eventemitter3": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-1.1.1.tgz", + "integrity": "sha1-R3hr2qCHyvext15zq8XH1UAVjNA=" + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "requires": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "express": { + "version": "4.16.3", + "resolved": "https://registry.npmjs.org/express/-/express-4.16.3.tgz", + "integrity": "sha1-avilAjUNsyRuzEvs9rWjTSL37VM=", + "requires": { + "accepts": "~1.3.5", + "array-flatten": "1.1.1", + "body-parser": "1.18.2", + "content-disposition": "0.5.2", + "content-type": "~1.0.4", + "cookie": "0.3.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "~1.1.2", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.1.1", + "fresh": "0.5.2", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.3", + "qs": "6.5.1", + "range-parser": "~1.2.0", + "safe-buffer": "5.1.1", + "send": "0.16.2", + "serve-static": "1.13.2", + "setprototypeof": "1.1.0", + "statuses": "~1.4.0", + "type-is": "~1.6.16", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "dependencies": { + "body-parser": { + "version": "1.18.2", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.2.tgz", + "integrity": "sha1-h2eKGdhLR9hZuDGZvVm84iKxBFQ=", + "requires": { + "bytes": "3.0.0", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "~1.1.1", + "http-errors": "~1.6.2", + "iconv-lite": "0.4.19", + "on-finished": "~2.3.0", + "qs": "6.5.1", + "raw-body": "2.3.2", + "type-is": "~1.6.15" + } + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==" + }, + "qs": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz", + "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A==" + }, + "raw-body": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.2.tgz", + "integrity": "sha1-vNYMd9Prk83gBQKVw/N5OJvIj4k=", + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.2", + "iconv-lite": "0.4.19", + "unpipe": "1.0.0" + }, + "dependencies": { + "depd": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.1.tgz", + "integrity": "sha1-V4O04cRZ8G+lyif5kfPQbnoxA1k=" + }, + "http-errors": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.2.tgz", + "integrity": "sha1-CgAsyFcHGSp+eUbO7cERVfYOxzY=", + "requires": { + "depd": "1.1.1", + "inherits": "2.0.3", + "setprototypeof": "1.0.3", + "statuses": ">= 1.3.1 < 2" + } + }, + "setprototypeof": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.0.3.tgz", + "integrity": "sha1-ZlZ+NwQ+608E2RvWWMDL77VbjgQ=" + } + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + }, + "extendr": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/extendr/-/extendr-2.1.0.tgz", + "integrity": "sha1-MBqgu+pWX00tyPVw8qImEahSe1Y=", + "requires": { + "typechecker": "~2.0.1" + }, + "dependencies": { + "typechecker": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/typechecker/-/typechecker-2.0.8.tgz", + "integrity": "sha1-6D2oS7ZMWEzLNFg4V2xAsDN9uC4=" + } + } + }, + "extract-opts": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/extract-opts/-/extract-opts-2.2.0.tgz", + "integrity": "sha1-H6KOunNSxttID4hc63GkaBC+bX0=", + "requires": { + "typechecker": "~2.0.1" + }, + "dependencies": { + "typechecker": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/typechecker/-/typechecker-2.0.8.tgz", + "integrity": "sha1-6D2oS7ZMWEzLNFg4V2xAsDN9uC4=" + } + } + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "eyes": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz", + "integrity": "sha1-Ys8SAjTGg3hdkCNIqADvPgzCC8A=" + }, + "fake-merkle-patricia-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/fake-merkle-patricia-tree/-/fake-merkle-patricia-tree-1.0.1.tgz", + "integrity": "sha1-S4w6z7Ugr635hgsfFM2M40As3dM=", + "requires": { + "checkpoint-store": "^1.1.0" + } + }, + "fast-deep-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", + "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=" + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=", + "requires": { + "pend": "~1.2.0" + } + }, + "fetch-ponyfill": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/fetch-ponyfill/-/fetch-ponyfill-4.1.0.tgz", + "integrity": "sha1-rjzl9zLGReq4fkroeTQUcJsjmJM=", + "requires": { + "node-fetch": "~1.7.1" + }, + "dependencies": { + "node-fetch": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.3.tgz", + "integrity": "sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==", + "requires": { + "encoding": "^0.1.11", + "is-stream": "^1.0.1" + } + } + } + }, + "file-type": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-5.2.0.tgz", + "integrity": "sha1-LdvqfHP/42No365J3DOMBYwritY=" + }, + "finalhandler": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.1.1.tgz", + "integrity": "sha512-Y1GUDo39ez4aHAw7MysnUD5JzYX+WaIj8I57kO3aEPT1fFRL4sr7mjei97FgnwhAyyzRYmQZaTHb2+9uZ1dPtg==", + "requires": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", + "statuses": "~1.4.0", + "unpipe": "~1.0.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "find-up": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-1.1.2.tgz", + "integrity": "sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8=", + "requires": { + "path-exists": "^2.0.0", + "pinkie-promise": "^2.0.0" + } + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "requires": { + "is-callable": "^1.1.3" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=" + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", + "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "1.0.6", + "mime-types": "^2.1.12" + } + }, + "forwarded": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz", + "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=" + }, + "fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=" + }, + "fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" + }, + "fs-extra": { + "version": "0.30.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz", + "integrity": "sha1-8jP/zAjU2n1DLapEl3aYnbHfk/A=", + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0", + "klaw": "^1.0.0", + "path-is-absolute": "^1.0.0", + "rimraf": "^2.2.8" + } + }, + "fs-promise": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/fs-promise/-/fs-promise-2.0.3.tgz", + "integrity": "sha1-9k5PhUvPaJqovdy6JokW2z20aFQ=", + "requires": { + "any-promise": "^1.3.0", + "fs-extra": "^2.0.0", + "mz": "^2.6.0", + "thenify-all": "^1.6.0" + }, + "dependencies": { + "fs-extra": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-2.1.2.tgz", + "integrity": "sha1-BGxwFjzvmq1GsOSn+kZ/si1x3jU=", + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0" + } + } + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fstream": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz", + "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=", + "requires": { + "graceful-fs": "^4.1.2", + "inherits": "~2.0.0", + "mkdirp": ">=0.5 0", + "rimraf": "2" + } + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=" + }, + "get-caller-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz", + "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=" + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=" + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "glob": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.1.tgz", + "integrity": "sha1-gFIR3wT6rxxjo2ADBs31reULLsg=", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.2", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "global": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/global/-/global-4.3.2.tgz", + "integrity": "sha1-52mJJopsdMOJCLEwWxD8DjlOnQ8=", + "requires": { + "min-document": "^2.19.0", + "process": "~0.5.1" + } + }, + "globals": { + "version": "9.18.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-9.18.0.tgz", + "integrity": "sha512-S0nG3CLEQiY/ILxqtztTWH/3iRRdyBLw6KMDxnKMchrtbj2OFmehVh0WUCfW3DUrIgx/qFrJPICrq4Z4sTR9UQ==" + }, + "got": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz", + "integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==", + "requires": { + "decompress-response": "^3.2.0", + "duplexer3": "^0.1.4", + "get-stream": "^3.0.0", + "is-plain-obj": "^1.1.0", + "is-retry-allowed": "^1.0.0", + "is-stream": "^1.0.0", + "isurl": "^1.0.0-alpha5", + "lowercase-keys": "^1.0.0", + "p-cancelable": "^0.3.0", + "p-timeout": "^1.1.1", + "safe-buffer": "^5.0.1", + "timed-out": "^4.0.0", + "url-parse-lax": "^1.0.0", + "url-to-options": "^1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "graceful-readlink": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", + "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=" + }, + "growl": { + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.3.tgz", + "integrity": "sha512-hKlsbA5Vu3xsh1Cg3J7jSmX/WaW6A5oBeqzM88oNbCRQFz+zUaXm6yxS4RVytp1scBoJzSYl4YAEOQIt6O8V1Q==" + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + }, + "har-validator": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.0.3.tgz", + "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", + "requires": { + "ajv": "^5.1.0", + "har-schema": "^2.0.0" + } + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "has-flag": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz", + "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=" + }, + "has-symbol-support-x": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz", + "integrity": "sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==" + }, + "has-to-string-tag-x": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz", + "integrity": "sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==", + "requires": { + "has-symbol-support-x": "^1.4.1" + } + }, + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "hash.js": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.5.tgz", + "integrity": "sha512-eWI5HG9Np+eHV1KQhisXWwM+4EPPYe5dFX1UZZH7k/E3JzDEazVH+VGlZi6R94ZqImq+A3D1mCEtrFIfg/E7sA==", + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "hdkey": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/hdkey/-/hdkey-0.7.1.tgz", + "integrity": "sha1-yu5L6BqneSHpCbjSKN0PKayu5jI=", + "requires": { + "coinstring": "^2.0.0", + "secp256k1": "^3.0.1" + } + }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=" + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "home-or-tmp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/home-or-tmp/-/home-or-tmp-2.0.0.tgz", + "integrity": "sha1-42w/LSyufXRqhX440Y1fMqeILbg=", + "requires": { + "os-homedir": "^1.0.0", + "os-tmpdir": "^1.0.1" + } + }, + "hosted-git-info": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.6.0.tgz", + "integrity": "sha512-lIbgIIQA3lz5XaB6vxakj6sDHADJiZadYEJB+FgA+C4nubM1NwcuvUr9EJPmnH1skZqpqUzWborWo8EIUi0Sdw==" + }, + "http-errors": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", + "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", + "requires": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": ">= 1.4.0 < 2" + } + }, + "http-https": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/http-https/-/http-https-1.0.0.tgz", + "integrity": "sha1-L5CN1fHbQGjAWM1ubUzjkskTOJs=" + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "requires": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + } + }, + "i18n": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/i18n/-/i18n-0.8.3.tgz", + "integrity": "sha1-LYzxwkciYCwgQdAbpq5eqlE4jw4=", + "requires": { + "debug": "*", + "make-plural": "^3.0.3", + "math-interval-parser": "^1.1.0", + "messageformat": "^0.3.1", + "mustache": "*", + "sprintf-js": ">=1.0.3" + } + }, + "iconv-lite": { + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz", + "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "ieee754": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz", + "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==" + }, + "ignorefs": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/ignorefs/-/ignorefs-1.2.0.tgz", + "integrity": "sha1-2ln7hYl25KXkNwLM0fKC/byeV1Y=", + "requires": { + "editions": "^1.3.3", + "ignorepatterns": "^1.1.0" + } + }, + "ignorepatterns": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ignorepatterns/-/ignorepatterns-1.1.0.tgz", + "integrity": "sha1-rI9DbyI5td+2bV8NOpBKh6xnzF4=" + }, + "immediate": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.2.3.tgz", + "integrity": "sha1-0UD6j2FGWb1lQSMwl92qwlzdmRw=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "invariant": { + "version": "2.2.4", + "resolved": "https://registry.npmjs.org/invariant/-/invariant-2.2.4.tgz", + "integrity": "sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==", + "requires": { + "loose-envify": "^1.0.0" + } + }, + "invert-kv": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", + "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=" + }, + "ipaddr.js": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.8.0.tgz", + "integrity": "sha1-6qM9bd16zo9/b+DJygRA5wZzix4=" + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=" + }, + "is-builtin-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", + "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", + "requires": { + "builtin-modules": "^1.0.0" + } + }, + "is-callable": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz", + "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==" + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=" + }, + "is-finite": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz", + "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=", + "requires": { + "number-is-nan": "^1.0.0" + } + }, + "is-fn": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fn/-/is-fn-1.0.0.tgz", + "integrity": "sha1-lUPV3nvPWwiiLsiiC65uKG1RDYw=" + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "requires": { + "number-is-nan": "^1.0.0" + } + }, + "is-function": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-function/-/is-function-1.0.1.tgz", + "integrity": "sha1-Es+5i2W1fdPRk6MSH19uL0N2ArU=" + }, + "is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha1-fY035q135dEnFIkTxXPggtd39VQ=" + }, + "is-nan": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-nan/-/is-nan-1.2.1.tgz", + "integrity": "sha1-n69ltvttskt/XAYoR16nH5iEAeI=", + "requires": { + "define-properties": "^1.1.1" + } + }, + "is-natural-number": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-natural-number/-/is-natural-number-4.0.1.tgz", + "integrity": "sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=" + }, + "is-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz", + "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=" + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=" + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "requires": { + "has": "^1.0.1" + } + }, + "is-retry-allowed": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz", + "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=" + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=" + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "is-utf8": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "integrity": "sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI=" + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "isurl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz", + "integrity": "sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==", + "requires": { + "has-to-string-tag-x": "^1.2.0", + "is-object": "^1.0.1" + } + }, + "js-sha3": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.3.1.tgz", + "integrity": "sha1-hhIoAhQvCChQKg0d7h2V4lO7AkM=" + }, + "js-tokens": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-3.0.2.tgz", + "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls=" + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "optional": true + }, + "jsesc": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz", + "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=" + }, + "json-rpc-engine": { + "version": "3.7.3", + "resolved": "https://registry.npmjs.org/json-rpc-engine/-/json-rpc-engine-3.7.3.tgz", + "integrity": "sha512-+FO3UWu/wafh/+MZ6BXy0HZU+f5plwUn82FgxpC0scJkEh5snOjFrAAtqCITPDfvfLHRUFOG5pQDUx2pspfERQ==", + "requires": { + "async": "^2.0.1", + "babel-preset-env": "^1.3.2", + "babelify": "^7.3.0", + "clone": "^2.1.1", + "json-rpc-error": "^2.0.0", + "promise-to-callback": "^1.0.0" + } + }, + "json-rpc-error": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/json-rpc-error/-/json-rpc-error-2.0.0.tgz", + "integrity": "sha1-p6+cICg4tekFxyUOVH8a/3cligI=", + "requires": { + "inherits": "^2.0.1" + } + }, + "json-rpc-random-id": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-rpc-random-id/-/json-rpc-random-id-1.0.1.tgz", + "integrity": "sha1-uknZat7RRE27jaPSA3SKy7zeyMg=" + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + }, + "json-stable-stringify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz", + "integrity": "sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=", + "requires": { + "jsonify": "~0.0.0" + } + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json-text-sequence": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/json-text-sequence/-/json-text-sequence-0.1.1.tgz", + "integrity": "sha1-py8hfcSvxGKf/1/rME3BvVGi89I=", + "requires": { + "delimit-stream": "0.1.0" + } + }, + "json5": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", + "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=" + }, + "jsonfile": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", + "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", + "requires": { + "graceful-fs": "^4.1.6" + } + }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=" + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "keccak": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-1.4.0.tgz", + "integrity": "sha512-eZVaCpblK5formjPjeTBik7TAg+pqnDrMHIffSvi9Lh7PQgM1+hSzakUeZFCk9DVVG0dacZJuaz2ntwlzZUIBw==", + "requires": { + "bindings": "^1.2.1", + "inherits": "^2.0.3", + "nan": "^2.2.1", + "safe-buffer": "^5.1.0" + } + }, + "keccakjs": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/keccakjs/-/keccakjs-0.2.1.tgz", + "integrity": "sha1-HWM6+QfvMFu/ny+mFtVsRFYd+k0=", + "requires": { + "browserify-sha3": "^0.0.1", + "sha3": "^1.1.0" + } + }, + "klaw": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", + "integrity": "sha1-QIhDO0azsbolnXh4XY6W9zugJDk=", + "requires": { + "graceful-fs": "^4.1.9" + } + }, + "lcid": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", + "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", + "requires": { + "invert-kv": "^1.0.0" + } + }, + "level-codec": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/level-codec/-/level-codec-7.0.1.tgz", + "integrity": "sha512-Ua/R9B9r3RasXdRmOtd+t9TCOEIIlts+TN/7XTT2unhDaL6sJn83S3rUyljbr6lVtw49N3/yA0HHjpV6Kzb2aQ==" + }, + "level-errors": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/level-errors/-/level-errors-1.0.5.tgz", + "integrity": "sha512-/cLUpQduF6bNrWuAC4pwtUKA5t669pCsCi2XbmojG2tFeOr9j6ShtdDCtFFQO1DRt+EVZhx9gPzP9G2bUaG4ig==", + "requires": { + "errno": "~0.1.1" + } + }, + "level-iterator-stream": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/level-iterator-stream/-/level-iterator-stream-1.3.1.tgz", + "integrity": "sha1-5Dt4sagUPm+pek9IXrjqUwNS8u0=", + "requires": { + "inherits": "^2.0.1", + "level-errors": "^1.0.3", + "readable-stream": "^1.0.33", + "xtend": "^4.0.0" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + } + } + }, + "level-ws": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/level-ws/-/level-ws-0.0.0.tgz", + "integrity": "sha1-Ny5RIXeSSgBCSwtDrvK7QkltIos=", + "requires": { + "readable-stream": "~1.0.15", + "xtend": "~2.1.1" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "object-keys": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz", + "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=" + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.1", + "isarray": "0.0.1", + "string_decoder": "~0.10.x" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + }, + "xtend": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz", + "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=", + "requires": { + "object-keys": "~0.4.0" + } + } + } + }, + "levelup": { + "version": "1.3.9", + "resolved": "https://registry.npmjs.org/levelup/-/levelup-1.3.9.tgz", + "integrity": "sha512-VVGHfKIlmw8w1XqpGOAGwq6sZm2WwWLmlDcULkKWQXEA5EopA8OBNJ2Ck2v6bdk8HeEZSbCSEgzXadyQFm76sQ==", + "requires": { + "deferred-leveldown": "~1.2.1", + "level-codec": "~7.0.0", + "level-errors": "~1.0.3", + "level-iterator-stream": "~1.3.0", + "prr": "~1.0.1", + "semver": "~5.4.1", + "xtend": "~4.0.0" + }, + "dependencies": { + "semver": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.4.1.tgz", + "integrity": "sha512-WfG/X9+oATh81XtllIo/I8gOiY9EXRdv1cQdyykeXK17YcUW3EXUAi2To4pcH6nZtJPr7ZOpM5OMyWJZm+8Rsg==" + } + } + }, + "load-json-file": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-1.1.0.tgz", + "integrity": "sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA=", + "requires": { + "graceful-fs": "^4.1.2", + "parse-json": "^2.2.0", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0", + "strip-bom": "^2.0.0" + } + }, + "lodash": { + "version": "4.17.10", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.10.tgz", + "integrity": "sha512-UejweD1pDoXu+AD825lWwp4ZGtSwgnpZxb3JDViD7StjQz+Nb/6l093lx4OQ0foGWNRoc19mWy7BzL+UAK2iVg==" + }, + "lodash.assign": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/lodash.assign/-/lodash.assign-4.2.0.tgz", + "integrity": "sha1-DZnzzNem0mHRm9rrkkUAXShYCOc=" + }, + "long-timeout": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/long-timeout/-/long-timeout-0.1.1.tgz", + "integrity": "sha1-lyHXiLR+C8taJMLivuGg2lXatRQ=" + }, + "loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "requires": { + "js-tokens": "^3.0.0 || ^4.0.0" + } + }, + "lowercase-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz", + "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==" + }, + "ltgt": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ltgt/-/ltgt-2.2.1.tgz", + "integrity": "sha1-81ypHEk/e3PaDgdJUwTxezH4fuU=" + }, + "make-dir": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz", + "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==", + "requires": { + "pify": "^3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=" + } + } + }, + "make-plural": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/make-plural/-/make-plural-3.0.6.tgz", + "integrity": "sha1-IDOgO6wpC487uRJY9lud9+iwHKc=", + "requires": { + "minimist": "^1.2.0" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "optional": true + } + } + }, + "math-interval-parser": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-interval-parser/-/math-interval-parser-1.1.0.tgz", + "integrity": "sha1-2+2lsGsySZc8bfYXD94jhvCv2JM=", + "requires": { + "xregexp": "^2.0.0" + } + }, + "md5.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz", + "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=" + }, + "memdown": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/memdown/-/memdown-1.4.1.tgz", + "integrity": "sha1-tOThkhdGZP+65BNhqlAPMRnv4hU=", + "requires": { + "abstract-leveldown": "~2.7.1", + "functional-red-black-tree": "^1.0.1", + "immediate": "^3.2.3", + "inherits": "~2.0.1", + "ltgt": "~2.2.0", + "safe-buffer": "~5.1.1" + }, + "dependencies": { + "abstract-leveldown": { + "version": "2.7.2", + "resolved": "https://registry.npmjs.org/abstract-leveldown/-/abstract-leveldown-2.7.2.tgz", + "integrity": "sha512-+OVvxH2rHVEhWLdbudP6p0+dNMXu8JA1CbhP19T8paTYAcX7oJ4OVjT+ZUVpv7mITxXHqDMej+GdqXBmXkw09w==", + "requires": { + "xtend": "~4.0.0" + } + } + } + }, + "memorystream": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/memorystream/-/memorystream-0.3.1.tgz", + "integrity": "sha1-htcJCzDORV1j+64S3aUaR93K+bI=" + }, + "merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E=" + }, + "merkle-patricia-tree": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/merkle-patricia-tree/-/merkle-patricia-tree-2.3.1.tgz", + "integrity": "sha512-Qp9Mpb3xazznXzzGQBqHbqCpT2AR9joUOHYYPiQjYCarrdCPCnLWXo4BFv77y4xN26KR224xoU1n/qYY7RYYgw==", + "requires": { + "async": "^1.4.2", + "ethereumjs-util": "^5.0.0", + "level-ws": "0.0.0", + "levelup": "^1.2.1", + "memdown": "^1.0.0", + "readable-stream": "^2.0.0", + "rlp": "^2.0.0", + "semaphore": ">=1.0.1" + }, + "dependencies": { + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=" + } + } + }, + "messageformat": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/messageformat/-/messageformat-0.3.1.tgz", + "integrity": "sha1-5Y//gkXps5cXmeW0PbWLPpQX9aI=", + "requires": { + "async": "~1.5.2", + "glob": "~6.0.4", + "make-plural": "~3.0.3", + "nopt": "~3.0.6", + "watchr": "~2.4.13" + }, + "dependencies": { + "async": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=" + }, + "glob": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/glob/-/glob-6.0.4.tgz", + "integrity": "sha1-DwiGD2oVUSey+t1PnOJLGqtuTSI=", + "requires": { + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + }, + "methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=" + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "requires": { + "bn.js": "^4.0.0", + "brorand": "^1.0.1" + } + }, + "mime": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz", + "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ==" + }, + "mime-db": { + "version": "1.35.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.35.0.tgz", + "integrity": "sha512-JWT/IcCTsB0Io3AhWUMjRqucrHSPsSf2xKLaRldJVULioggvkJvggZ3VXNNSRkCddE6D+BUI4HEIZIA2OjwIvg==" + }, + "mime-types": { + "version": "2.1.19", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.19.tgz", + "integrity": "sha512-P1tKYHVSZ6uFo26mtnve4HQFE3koh1UWVkp8YUC+ESBHe945xWSoXuHHiGarDqcEZ+whpCDnlNw5LON0kLo+sw==", + "requires": { + "mime-db": "~1.35.0" + } + }, + "mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==" + }, + "min-document": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/min-document/-/min-document-2.19.0.tgz", + "integrity": "sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU=", + "requires": { + "dom-walk": "^0.1.0" + } + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==" + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } + }, + "mkdirp-promise": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/mkdirp-promise/-/mkdirp-promise-5.0.1.tgz", + "integrity": "sha1-6bj2jlUsaKnBcTuEiD96HdA5uKE=", + "requires": { + "mkdirp": "*" + } + }, + "mocha": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/mocha/-/mocha-4.1.0.tgz", + "integrity": "sha512-0RVnjg1HJsXY2YFDoTNzcc1NKhYuXKRrBAG2gDygmJJA136Cs2QlRliZG1mA0ap7cuaT30mw16luAeln+4RiNA==", + "requires": { + "browser-stdout": "1.3.0", + "commander": "2.11.0", + "debug": "3.1.0", + "diff": "3.3.1", + "escape-string-regexp": "1.0.5", + "glob": "7.1.2", + "growl": "1.10.3", + "he": "1.1.1", + "mkdirp": "0.5.1", + "supports-color": "4.4.0" + }, + "dependencies": { + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + }, + "mock-fs": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/mock-fs/-/mock-fs-4.6.0.tgz", + "integrity": "sha512-aYutNIwFaMsVgtMoc5vMsobA/yRJR2FTUFoTZgnjdb3gID0g8WMmeafWmHPgzKgZ7zwQ5kggYUgeq5sN9k9uDw==" + }, + "moment": { + "version": "2.22.2", + "resolved": "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz", + "integrity": "sha1-PCV/mDn8DpP/UxSWMiOeuQeD/2Y=" + }, + "moment-timezone": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/moment-timezone/-/moment-timezone-0.5.21.tgz", + "integrity": "sha512-j96bAh4otsgj3lKydm3K7kdtA3iKf2m6MY2iSYCzCm5a1zmHo1g+aK3068dDEeocLZQIS9kU8bsdQHLqEvgW0A==", + "requires": { + "moment": ">= 2.9.0" + } + }, + "mout": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/mout/-/mout-0.11.1.tgz", + "integrity": "sha1-ujYR318OWx/7/QEWa48C0fX6K5k=" + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "multihashes": { + "version": "0.4.13", + "resolved": "https://registry.npmjs.org/multihashes/-/multihashes-0.4.13.tgz", + "integrity": "sha512-HwJGEKPCpLlNlgGQA56CYh/Wsqa+c4JAq8+mheIgw7OK5T4QvNJqgp6TH8gZ4q4l1aiWeNat/H/MrFXmTuoFfQ==", + "requires": { + "bs58": "^4.0.1", + "varint": "^5.0.0" + } + }, + "mustache": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/mustache/-/mustache-2.3.0.tgz", + "integrity": "sha1-QCj3d4sXcIpImTCm5SrDvKDaQdA=" + }, + "mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "requires": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "nan": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.10.0.tgz", + "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==" + }, + "nano-json-stream-parser": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/nano-json-stream-parser/-/nano-json-stream-parser-0.1.2.tgz", + "integrity": "sha1-DMj20OK2IrR5xA1JnEbWS3Vcb18=" + }, + "negotiator": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz", + "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=" + }, + "node-async-loop": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/node-async-loop/-/node-async-loop-1.2.2.tgz", + "integrity": "sha1-xYcCmb9kd7eAyItDGqWzdzP1Wj0=" + }, + "node-cache": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/node-cache/-/node-cache-4.2.0.tgz", + "integrity": "sha512-obRu6/f7S024ysheAjoYFEEBqqDWv4LOMNJEuO8vMeEw2AT4z+NCzO4hlc2lhI4vATzbCQv6kke9FVdx0RbCOw==", + "requires": { + "clone": "2.x", + "lodash": "4.x" + } + }, + "node-fetch": { + "version": "2.1.2", + "resolved": "http://registry.npmjs.org/node-fetch/-/node-fetch-2.1.2.tgz", + "integrity": "sha1-q4hOjn5X44qUR1POxwb3iNF2i7U=" + }, + "node-schedule": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/node-schedule/-/node-schedule-1.3.0.tgz", + "integrity": "sha512-NNwO9SUPjBwFmPh3vXiPVEhJLn4uqYmZYvJV358SRGM06BR4UoIqxJpeJwDDXB6atULsgQA97MfD1zMd5xsu+A==", + "requires": { + "cron-parser": "^2.4.0", + "long-timeout": "0.1.1", + "sorted-array-functions": "^1.0.0" + } + }, + "nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", + "requires": { + "abbrev": "1" + } + }, + "normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", + "requires": { + "hosted-git-info": "^2.1.4", + "is-builtin-module": "^1.0.0", + "semver": "2 || 3 || 4 || 5", + "validate-npm-package-license": "^3.0.1" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=" + }, + "number-to-bn": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz", + "integrity": "sha1-uzYjWS9+X54AMLGXe9QaDFP+HqA=", + "requires": { + "bn.js": "4.11.6", + "strip-hex-prefix": "1.0.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-inspect": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz", + "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==" + }, + "object-keys": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", + "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==" + }, + "oboe": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/oboe/-/oboe-2.1.3.tgz", + "integrity": "sha1-K0hl29Rr6BIlcT9Om/5Lz09oCk8=", + "requires": { + "http-https": "^1.0.0" + } + }, + "on-finished": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", + "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", + "requires": { + "ee-first": "1.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "original-require": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/original-require/-/original-require-1.0.1.tgz", + "integrity": "sha1-DxMEcVhM0zURxew4yNWSE/msXiA=" + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=" + }, + "os-locale": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-1.4.0.tgz", + "integrity": "sha1-IPnxeuKe00XoveWDsT0gCYA8FNk=", + "requires": { + "lcid": "^1.0.0" + } + }, + "os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=" + }, + "p-cancelable": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz", + "integrity": "sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==" + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=" + }, + "p-timeout": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz", + "integrity": "sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=", + "requires": { + "p-finally": "^1.0.0" + } + }, + "parse-asn1": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz", + "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==", + "requires": { + "asn1.js": "^4.0.0", + "browserify-aes": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.0", + "pbkdf2": "^3.0.3" + } + }, + "parse-headers": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.1.tgz", + "integrity": "sha1-aug6eqJanZtwCswoaYzR8e1+lTY=", + "requires": { + "for-each": "^0.3.2", + "trim": "0.0.1" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "requires": { + "error-ex": "^1.2.0" + } + }, + "parseurl": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz", + "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=" + }, + "path-exists": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-2.1.0.tgz", + "integrity": "sha1-D+tsZPD8UY2adU3V77YscCJ2H0s=", + "requires": { + "pinkie-promise": "^2.0.0" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-parse": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz", + "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==" + }, + "path-to-regexp": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w=" + }, + "path-type": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-1.1.0.tgz", + "integrity": "sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE=", + "requires": { + "graceful-fs": "^4.1.2", + "pify": "^2.0.0", + "pinkie-promise": "^2.0.0" + } + }, + "pbkdf2": { + "version": "3.0.16", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.16.tgz", + "integrity": "sha512-y4CXP3thSxqf7c0qmOF+9UeOTrifiVTIM+u7NWlq+PRsHbr7r7dpCmvzrZxa96JJUNi0Y5w9VqG5ZNeCVMoDcA==", + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha1-elfrVQpng/kRUzH89GY9XI4AelA=" + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=" + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "requires": { + "pinkie": "^2.0.0" + } + }, + "pragma-singleton": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/pragma-singleton/-/pragma-singleton-1.0.3.tgz", + "integrity": "sha1-aJQxe7jUcVflneKkoAnbfm9j4w4=" + }, + "precond": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/precond/-/precond-0.2.3.tgz", + "integrity": "sha1-qpWRvKokkj8eD0hJ0kD0fvwQdaw=" + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=" + }, + "private": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz", + "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==" + }, + "process": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/process/-/process-0.5.2.tgz", + "integrity": "sha1-FjjYqONML0QKkduVq5rrZ3/Bhc8=" + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + }, + "promise-to-callback": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/promise-to-callback/-/promise-to-callback-1.0.0.tgz", + "integrity": "sha1-XSp0kBC/tn2WNZj805YHRqaP7vc=", + "requires": { + "is-fn": "^1.0.0", + "set-immediate-shim": "^1.0.1" + } + }, + "proxy-addr": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.4.tgz", + "integrity": "sha512-5erio2h9jp5CHGwcybmxmVqHmnCBZeewlfJ0pex+UW7Qny7OOZXTtH56TGNyBizkgiOwhJtMKrVzDTeKcySZwA==", + "requires": { + "forwarded": "~0.1.2", + "ipaddr.js": "1.8.0" + } + }, + "prr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz", + "integrity": "sha1-0/wRS6BplaRexok/SEzrHXj19HY=" + }, + "public-encrypt": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.2.tgz", + "integrity": "sha512-4kJ5Esocg8X3h8YgJsKAuoesBgB7mqH3eowiDzMUPKiRDDE7E/BqqZD1hnTByIaAFiwAw246YEltSq7tdrOH0Q==", + "requires": { + "bn.js": "^4.1.0", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "parse-asn1": "^5.0.0", + "randombytes": "^2.0.1" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + }, + "qs": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", + "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" + }, + "query-string": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz", + "integrity": "sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==", + "requires": { + "decode-uri-component": "^0.2.0", + "object-assign": "^4.1.0", + "strict-uri-encode": "^1.0.0" + } + }, + "randombytes": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz", + "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "requires": { + "randombytes": "^2.0.5", + "safe-buffer": "^5.1.0" + } + }, + "randomhex": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/randomhex/-/randomhex-0.1.5.tgz", + "integrity": "sha1-us7vmCMpCRQA8qKRLGzQLxCU9YU=" + }, + "range-parser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz", + "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=" + }, + "raw-body": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.3.tgz", + "integrity": "sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==", + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.3", + "iconv-lite": "0.4.23", + "unpipe": "1.0.0" + } + }, + "read-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-1.1.0.tgz", + "integrity": "sha1-9f+qXs0pyzHAR0vKfXVra7KePyg=", + "requires": { + "load-json-file": "^1.0.0", + "normalize-package-data": "^2.3.2", + "path-type": "^1.0.0" + } + }, + "read-pkg-up": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-1.0.1.tgz", + "integrity": "sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI=", + "requires": { + "find-up": "^1.0.0", + "read-pkg": "^1.0.0" + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "regenerate": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.0.tgz", + "integrity": "sha512-1G6jJVDWrt0rK99kBjvEtziZNCICAuvIPkSiUFIQxVP06RCVpq3dmDo2oi6ABpYaDYaTRr67BEhL8r1wgEZZKg==" + }, + "regenerator-runtime": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.1.tgz", + "integrity": "sha512-MguG95oij0fC3QV3URf4V2SDYGJhJnJGqvIIgdECeODCT98wSWDAJ94SSuVpYQUoTcGUIL6L4yNB7j1DFFHSBg==" + }, + "regenerator-transform": { + "version": "0.10.1", + "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.10.1.tgz", + "integrity": "sha512-PJepbvDbuK1xgIgnau7Y90cwaAmO/LCLMI2mPvaXq2heGMR3aWW5/BQvYrhJ8jgmQjXewXvBjzfqKcVOmhjZ6Q==", + "requires": { + "babel-runtime": "^6.18.0", + "babel-types": "^6.19.0", + "private": "^0.1.6" + } + }, + "regexpu-core": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-2.0.0.tgz", + "integrity": "sha1-SdA4g3uNz4v6W5pCE5k45uoq4kA=", + "requires": { + "regenerate": "^1.2.1", + "regjsgen": "^0.2.0", + "regjsparser": "^0.1.4" + } + }, + "regjsgen": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz", + "integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=" + }, + "regjsparser": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.1.5.tgz", + "integrity": "sha1-fuj4Tcb6eS0/0K4ijSS9lJ6tIFw=", + "requires": { + "jsesc": "~0.5.0" + } + }, + "repeating": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/repeating/-/repeating-2.0.1.tgz", + "integrity": "sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo=", + "requires": { + "is-finite": "^1.0.0" + } + }, + "request": { + "version": "2.87.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.87.0.tgz", + "integrity": "sha512-fcogkm7Az5bsS6Sl0sibkbhcKsnyon/jV1kF3ajGmF0c8HrttdKTPRT9hieOaQHA5HEq6r8OyWOo/o781C1tNw==", + "requires": { + "aws-sign2": "~0.7.0", + "aws4": "^1.6.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.5", + "extend": "~3.0.1", + "forever-agent": "~0.6.1", + "form-data": "~2.3.1", + "har-validator": "~5.0.3", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.17", + "oauth-sign": "~0.8.2", + "performance-now": "^2.1.0", + "qs": "~6.5.1", + "safe-buffer": "^5.1.1", + "tough-cookie": "~2.3.3", + "tunnel-agent": "^0.6.0", + "uuid": "^3.1.0" + } + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=" + }, + "require-from-string": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-1.2.1.tgz", + "integrity": "sha1-UpyczvJzgK3+yaL5ZbZJu+5jZBg=" + }, + "require-main-filename": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", + "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=" + }, + "resolve": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz", + "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==", + "requires": { + "path-parse": "^1.0.5" + } + }, + "resumer": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz", + "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=", + "requires": { + "through": "~2.3.4" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "requires": { + "glob": "^7.0.5" + } + }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "rlp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.1.0.tgz", + "integrity": "sha512-93U7IKH5j7nmXFVg19MeNBGzQW5uXW1pmCuKY8veeKIhYTE32C2d0mOegfiIAfXcHOKJjjPlJisn8iHDF5AezA==", + "requires": { + "safe-buffer": "^5.1.1" + } + }, + "rustbn.js": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/rustbn.js/-/rustbn.js-0.1.2.tgz", + "integrity": "sha512-bAkNqSHYdJdFsBC7Z11JgzYktL31HIpB2o70jZcGiL1U1TVtPyvaVhDrGWwS8uZtaqwW2k6NOPGZCqW/Dgh5Lg==" + }, + "safe": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/safe/-/safe-0.4.6.tgz", + "integrity": "sha1-HVWAzyY1xcuUDqSPtQga48JbG+E=" + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "safefs": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/safefs/-/safefs-3.2.2.tgz", + "integrity": "sha1-gXDBRE1wOOCMrqBaN0+uL6NJ4Vw=", + "requires": { + "graceful-fs": "*" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "scandirectory": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/scandirectory/-/scandirectory-2.5.0.tgz", + "integrity": "sha1-bOA/VKCQtmjjy+2/IO354xBZPnI=", + "requires": { + "ignorefs": "^1.0.0", + "safefs": "^3.1.2", + "taskgroup": "^4.0.5" + } + }, + "scrypt": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/scrypt/-/scrypt-6.0.3.tgz", + "integrity": "sha1-BOAUpWgrU/pQwtXM4WfXGcBthw0=", + "requires": { + "nan": "^2.0.8" + } + }, + "scrypt-async": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/scrypt-async/-/scrypt-async-1.3.1.tgz", + "integrity": "sha1-oR/W+smBtLgj7gHe4CIRaVAN2uk=" + }, + "scrypt.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/scrypt.js/-/scrypt.js-0.2.0.tgz", + "integrity": "sha1-r40UZbcemZARC+38WTuUeeA6ito=", + "requires": { + "scrypt": "^6.0.2", + "scryptsy": "^1.2.1" + } + }, + "scryptsy": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/scryptsy/-/scryptsy-1.2.1.tgz", + "integrity": "sha1-oyJfpLJST4AnAHYeKFW987LZIWM=", + "requires": { + "pbkdf2": "^3.0.3" + } + }, + "secp256k1": { + "version": "3.5.0", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-3.5.0.tgz", + "integrity": "sha512-e5QIJl8W7Y4tT6LHffVcZAxJjvpgE5Owawv6/XCYPQljE9aP2NFFddQ8OYMKhdLshNu88FfL3qCN3/xYkXGRsA==", + "requires": { + "bindings": "^1.2.1", + "bip66": "^1.1.3", + "bn.js": "^4.11.3", + "create-hash": "^1.1.2", + "drbg.js": "^1.0.1", + "elliptic": "^6.2.3", + "nan": "^2.2.1", + "safe-buffer": "^5.1.0" + }, + "dependencies": { + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + } + } + }, + "seek-bzip": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.5.tgz", + "integrity": "sha1-z+kXyz0nS8/6x5J1ivUxc+sfq9w=", + "requires": { + "commander": "~2.8.1" + }, + "dependencies": { + "commander": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.8.1.tgz", + "integrity": "sha1-Br42f+v9oMMwqh4qBy09yXYkJdQ=", + "requires": { + "graceful-readlink": ">= 1.0.0" + } + } + } + }, + "semaphore": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/semaphore/-/semaphore-1.1.0.tgz", + "integrity": "sha512-O4OZEaNtkMd/K0i6js9SL+gqy0ZCBMgUvlSqHKi4IBdjhe7wB8pwztUk1BbZ1fmrvpwFrPbHzqd2w5pTcJH6LA==" + }, + "semver": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==" + }, + "send": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.16.2.tgz", + "integrity": "sha512-E64YFPUssFHEFBvpbbjr44NCLtI1AohxQ8ZSiJjQLskAdKuriYEP6VyGEsRDH8ScozGpkaX1BGvhanqCwkcEZw==", + "requires": { + "debug": "2.6.9", + "depd": "~1.1.2", + "destroy": "~1.0.4", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "~1.6.2", + "mime": "1.4.1", + "ms": "2.0.0", + "on-finished": "~2.3.0", + "range-parser": "~1.2.0", + "statuses": "~1.4.0" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "serve-static": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.13.2.tgz", + "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==", + "requires": { + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.2", + "send": "0.16.2" + } + }, + "servify": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/servify/-/servify-0.1.12.tgz", + "integrity": "sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==", + "requires": { + "body-parser": "^1.16.0", + "cors": "^2.8.1", + "express": "^4.14.0", + "request": "^2.79.0", + "xhr": "^2.3.3" + } + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=" + }, + "set-immediate-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", + "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=" + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=" + }, + "setprototypeof": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==" + }, + "sha.js": { + "version": "2.4.11", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "sha3": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/sha3/-/sha3-1.2.2.tgz", + "integrity": "sha1-pmxQmN5MJbyIM27ItIF9AFvKe6k=", + "requires": { + "nan": "2.10.0" + } + }, + "simple-concat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.0.tgz", + "integrity": "sha1-c0TLuLbib7J9ZrL8hvn21Zl1IcY=" + }, + "simple-get": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-2.8.1.tgz", + "integrity": "sha512-lSSHRSw3mQNUGPAYRqo7xy9dhKmxFXIjLjp4KHpf99GEH2VH7C3AM+Qfx6du6jhfUi6Vm7XnbEVEf7Wb6N8jRw==", + "requires": { + "decompress-response": "^3.3.0", + "once": "^1.3.1", + "simple-concat": "^1.0.0" + } + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=" + }, + "solc": { + "version": "0.4.20", + "resolved": "https://registry.npmjs.org/solc/-/solc-0.4.20.tgz", + "integrity": "sha512-LrP3Jp4FS3y8sduIR67y8Ss1riR3fggk5sMnx4OSCcU88Ro0e51+KVXyfH3NP6ghLo7COrLx/lGUaDDugCzdgA==", + "requires": { + "fs-extra": "^0.30.0", + "memorystream": "^0.3.1", + "require-from-string": "^1.1.0", + "semver": "^5.3.0", + "yargs": "^4.7.1" + } + }, + "sorted-array-functions": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/sorted-array-functions/-/sorted-array-functions-1.2.0.tgz", + "integrity": "sha512-sWpjPhIZJtqO77GN+LD8dDsDKcWZ9GCOJNqKzi1tvtjGIzwfoyuRH8S0psunmc6Z5P+qfDqztSbwYR5X/e1UTg==" + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" + }, + "source-map-support": { + "version": "0.4.18", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.4.18.tgz", + "integrity": "sha512-try0/JqxPLF9nOjvSta7tVondkP5dwgyLDjVoyMDlmjugT2lRZ1OfsrYTkCd2hkDnJTKRbO/Rl3orm8vlsUzbA==", + "requires": { + "source-map": "^0.5.6" + } + }, + "spdx-correct": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.0.0.tgz", + "integrity": "sha512-N19o9z5cEyc8yQQPukRCZ9EUmb4HUpnrmaL/fxS2pBo2jbfcFRVuFZ/oFC+vZz0MNNk0h80iMn5/S6qGZOL5+g==", + "requires": { + "spdx-expression-parse": "^3.0.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-exceptions": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.1.0.tgz", + "integrity": "sha512-4K1NsmrlCU1JJgUrtgEeTVyfx8VaYea9J9LvARxhbHtVtohPs/gFGG5yy49beySjlIMhhXZ4QqujIZEfS4l6Cg==" + }, + "spdx-expression-parse": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz", + "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==", + "requires": { + "spdx-exceptions": "^2.1.0", + "spdx-license-ids": "^3.0.0" + } + }, + "spdx-license-ids": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.0.tgz", + "integrity": "sha512-2+EPwgbnmOIl8HjGBXXMd9NAu02vLjOO1nWw4kmeRDFyHn+M/ETfHxQUK0oXg8ctgVnl9t3rosNVsZ1jG61nDA==" + }, + "sprintf-js": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.1.tgz", + "integrity": "sha1-Nr54Mgr+WAH2zqPueLblqrlA6gw=" + }, + "sshpk": { + "version": "1.14.2", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.2.tgz", + "integrity": "sha1-xvxhZIo9nE52T9P8306hBeSSupg=", + "requires": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + }, + "dependencies": { + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + } + } + }, + "stack-trace": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", + "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=" + }, + "statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=" + }, + "stdio": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/stdio/-/stdio-0.2.7.tgz", + "integrity": "sha1-ocV9oQ/hz6oMO/aDydB0PRtmCDk=" + }, + "strict-uri-encode": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz", + "integrity": "sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=" + }, + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "requires": { + "code-point-at": "^1.0.0", + "is-fullwidth-code-point": "^1.0.0", + "strip-ansi": "^3.0.0" + } + }, + "string.prototype.trim": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz", + "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=", + "requires": { + "define-properties": "^1.1.2", + "es-abstract": "^1.5.0", + "function-bind": "^1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "~5.1.0" + } + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "^2.0.0" + } + }, + "strip-bom": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-2.0.0.tgz", + "integrity": "sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4=", + "requires": { + "is-utf8": "^0.2.0" + } + }, + "strip-dirs": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz", + "integrity": "sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==", + "requires": { + "is-natural-number": "^4.0.1" + } + }, + "strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha1-DF8VX+8RUTczd96du1iNoFUA428=", + "requires": { + "is-hex-prefixed": "1.0.0" + } + }, + "supports-color": { + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.4.0.tgz", + "integrity": "sha512-rKC3+DyXWgK0ZLKwmRsrkyHVZAjNkfzeehuFWdGGcqGDTZFH73+RH6S/RDAAxl9GusSjZSUWYLmT9N5pzXFOXQ==", + "requires": { + "has-flag": "^2.0.0" + } + }, + "swarm-js": { + "version": "0.1.37", + "resolved": "https://registry.npmjs.org/swarm-js/-/swarm-js-0.1.37.tgz", + "integrity": "sha512-G8gi5fcXP/2upwiuOShJ258sIufBVztekgobr3cVgYXObZwJ5AXLqZn52AI+/ffft29pJexF9WNdUxjlkVehoQ==", + "requires": { + "bluebird": "^3.5.0", + "buffer": "^5.0.5", + "decompress": "^4.0.0", + "eth-lib": "^0.1.26", + "fs-extra": "^2.1.2", + "fs-promise": "^2.0.0", + "got": "^7.1.0", + "mime-types": "^2.1.16", + "mkdirp-promise": "^5.0.1", + "mock-fs": "^4.1.0", + "setimmediate": "^1.0.5", + "tar.gz": "^1.0.5", + "xhr-request-promise": "^0.1.2" + }, + "dependencies": { + "buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.2.1.tgz", + "integrity": "sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, + "fs-extra": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-2.1.2.tgz", + "integrity": "sha1-BGxwFjzvmq1GsOSn+kZ/si1x3jU=", + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0" + } + } + } + }, + "tape": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.1.tgz", + "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==", + "requires": { + "deep-equal": "~1.0.1", + "defined": "~1.0.0", + "for-each": "~0.3.3", + "function-bind": "~1.1.1", + "glob": "~7.1.2", + "has": "~1.0.3", + "inherits": "~2.0.3", + "minimist": "~1.2.0", + "object-inspect": "~1.6.0", + "resolve": "~1.7.1", + "resumer": "~0.0.0", + "string.prototype.trim": "~1.1.2", + "through": "~2.3.8" + }, + "dependencies": { + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + } + } + }, + "tar": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz", + "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=", + "requires": { + "block-stream": "*", + "fstream": "^1.0.2", + "inherits": "2" + } + }, + "tar-stream": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.1.tgz", + "integrity": "sha512-IFLM5wp3QrJODQFPm6/to3LJZrONdBY/otxcvDIQzu217zKye6yVR3hhi9lAjrC2Z+m/j5oDxMPb1qcd8cIvpA==", + "requires": { + "bl": "^1.0.0", + "buffer-alloc": "^1.1.0", + "end-of-stream": "^1.0.0", + "fs-constants": "^1.0.0", + "readable-stream": "^2.3.0", + "to-buffer": "^1.1.0", + "xtend": "^4.0.0" + } + }, + "tar.gz": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/tar.gz/-/tar.gz-1.0.7.tgz", + "integrity": "sha512-uhGatJvds/3diZrETqMj4RxBR779LKlIE74SsMcn5JProZsfs9j0QBwWO1RW+IWNJxS2x8Zzra1+AW6OQHWphg==", + "requires": { + "bluebird": "^2.9.34", + "commander": "^2.8.1", + "fstream": "^1.0.8", + "mout": "^0.11.0", + "tar": "^2.1.1" + }, + "dependencies": { + "bluebird": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-2.11.0.tgz", + "integrity": "sha1-U0uQM8AiyVecVro7Plpcqvu2UOE=" + } + } + }, + "taskgroup": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/taskgroup/-/taskgroup-4.3.1.tgz", + "integrity": "sha1-feGT/r12gnPEV3MElwJNUSwnkVo=", + "requires": { + "ambi": "^2.2.0", + "csextends": "^1.0.3" + } + }, + "thenify": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.0.tgz", + "integrity": "sha1-5p44obq+lpsBCCB5eLn2K4hgSDk=", + "requires": { + "any-promise": "^1.0.0" + } + }, + "thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha1-GhkY1ALY/D+Y+/I02wvMjMEOlyY=", + "requires": { + "thenify": ">= 3.1.0 < 4" + } + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "^2.1.5", + "xtend": "~4.0.1" + } + }, + "timed-out": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz", + "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=" + }, + "tingodb": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/tingodb/-/tingodb-0.6.1.tgz", + "integrity": "sha1-9jM2JZr336bJDf4lVqDfsNTu3lk=", + "requires": { + "bson": "^1.0.4", + "lodash": "^4.17.5", + "safe": "^0.4.5", + "safe-buffer": "^5.1.1" + } + }, + "to-buffer": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz", + "integrity": "sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==" + }, + "to-fast-properties": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz", + "integrity": "sha1-uDVx+k2MJbguIxsG46MFXeTKGkc=" + }, + "tough-cookie": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.4.tgz", + "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", + "requires": { + "punycode": "^1.4.1" + } + }, + "treeify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/treeify/-/treeify-1.1.0.tgz", + "integrity": "sha512-1m4RA7xVAJrSGrrXGs0L3YTwyvBs2S8PbRHaLZAkFw7JR8oIFwYtysxlBZhYIa7xSyiYJKZ3iGrrk55cGA3i9A==" + }, + "trim": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz", + "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=" + }, + "trim-right": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/trim-right/-/trim-right-1.0.1.tgz", + "integrity": "sha1-yy4SAwZ+DI3h9hQJS5/kVwTqYAM=" + }, + "truffle": { + "version": "5.0.0-beta.0", + "resolved": "https://registry.npmjs.org/truffle/-/truffle-5.0.0-beta.0.tgz", + "integrity": "sha512-hZ3TvO0ByHZabVvF5kH3phliAMLbeTM9XrBuJRTfM5x2Q4kHVYnTQa1oOhetPPVPaULsVai5T+iQPV3ptOq9jA==", + "requires": { + "mocha": "^4.1.0", + "original-require": "1.0.1", + "solc": "0.4.24" + }, + "dependencies": { + "solc": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/solc/-/solc-0.4.24.tgz", + "integrity": "sha512-2xd7Cf1HeVwrIb6Bu1cwY2/TaLRodrppCq3l7rhLimFQgmxptXhTC3+/wesVLpB09F1A2kZgvbMOgH7wvhFnBQ==", + "requires": { + "fs-extra": "^0.30.0", + "memorystream": "^0.3.1", + "require-from-string": "^1.1.0", + "semver": "^5.3.0", + "yargs": "^4.7.1" + } + } + } + }, + "truffle-hdwallet-provider": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/truffle-hdwallet-provider/-/truffle-hdwallet-provider-0.0.6.tgz", + "integrity": "sha512-vh1nCk9+COz9Z1BnDYjrZEc8Z4KCWeoThAX6U13SpHMuSL7gX40ZDWszlVmovPLEwHSJBh/OaFmaduKfeXT9rA==", + "requires": { + "bip39": "^2.2.0", + "ethereumjs-wallet": "0.6.0", + "web3": "^0.18.2", + "web3-provider-engine": "^14.0.5" + }, + "dependencies": { + "bignumber.js": { + "version": "git+https://github.com/debris/bignumber.js.git#94d7146671b9719e00a09c29b01a691bc85048c2", + "from": "git+https://github.com/debris/bignumber.js.git#94d7146671b9719e00a09c29b01a691bc85048c2" + }, + "web3": { + "version": "0.18.4", + "resolved": "https://registry.npmjs.org/web3/-/web3-0.18.4.tgz", + "integrity": "sha1-gewXhBRUkfLqqJVbMcBgSeB8Xn0=", + "requires": { + "bignumber.js": "git+https://github.com/debris/bignumber.js.git#94d7146671b9719e00a09c29b01a691bc85048c2", + "crypto-js": "^3.1.4", + "utf8": "^2.1.1", + "xhr2": "*", + "xmlhttprequest": "*" + } + } + } + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "tweetnacl": { + "version": "0.13.2", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.13.2.tgz", + "integrity": "sha1-RTFhdwRp1FzSZsNkBOK8maj6mUQ=" + }, + "type-is": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz", + "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==", + "requires": { + "media-typer": "0.3.0", + "mime-types": "~2.1.18" + } + }, + "typechecker": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/typechecker/-/typechecker-2.1.0.tgz", + "integrity": "sha1-0cIJOlT/ihn1jP+HfuqlTyJC04M=" + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "requires": { + "is-typedarray": "^1.0.0" + } + }, + "ultron": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", + "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==" + }, + "unbzip2-stream": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.2.5.tgz", + "integrity": "sha512-izD3jxT8xkzwtXRUZjtmRwKnZoeECrfZ8ra/ketwOcusbZEp4mjULMnJOCfTDZBgGQAAY1AJ/IgxcwkavcX9Og==", + "requires": { + "buffer": "^3.0.1", + "through": "^2.3.6" + }, + "dependencies": { + "base64-js": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-0.0.8.tgz", + "integrity": "sha1-EQHpVE9KdrG8OybUUsqW16NeeXg=" + }, + "buffer": { + "version": "3.6.0", + "resolved": "http://registry.npmjs.org/buffer/-/buffer-3.6.0.tgz", + "integrity": "sha1-pyyTb3e5a/UvX357RnGAYoVR3vs=", + "requires": { + "base64-js": "0.0.8", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + } + } + }, + "underscore": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.9.1.tgz", + "integrity": "sha512-5/4etnCkd9c8gwgowi5/om/mYO5ajCaOgdzj/oW+0eQV9WxKBDZw5+ycmKmeaTXjInS/W0BzpGLo2xR2aBwZdg==" + }, + "unorm": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/unorm/-/unorm-1.4.1.tgz", + "integrity": "sha1-NkIA1fE2RsqLzURJAnEzVhR5IwA=" + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" + }, + "url-parse-lax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz", + "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=", + "requires": { + "prepend-http": "^1.0.1" + } + }, + "url-set-query": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-set-query/-/url-set-query-1.0.0.tgz", + "integrity": "sha1-AW6M/Xwg7gXK/neV6JK9BwL6ozk=" + }, + "url-to-options": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz", + "integrity": "sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=" + }, + "utf8": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-2.1.2.tgz", + "integrity": "sha1-H6DZJw6b6FDZsFAn9jUZv0ZFfZY=" + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=" + }, + "uuid": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", + "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==" + }, + "validate-npm-package-license": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.3.tgz", + "integrity": "sha512-63ZOUnL4SIXj4L0NixR3L1lcjO38crAbgrTpl28t8jjrfuiOBL5Iygm+60qPs/KsZGzPNg6Smnc/oY16QTjF0g==", + "requires": { + "spdx-correct": "^3.0.0", + "spdx-expression-parse": "^3.0.0" + } + }, + "varint": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/varint/-/varint-5.0.0.tgz", + "integrity": "sha1-2Ca4n3SQcy+rwMDtaT7Uddyynr8=" + }, + "vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=" + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "requires": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "watchr": { + "version": "2.4.13", + "resolved": "https://registry.npmjs.org/watchr/-/watchr-2.4.13.tgz", + "integrity": "sha1-10hHu01vkPYf4sdPn2hmKqDgdgE=", + "requires": { + "eachr": "^2.0.2", + "extendr": "^2.1.0", + "extract-opts": "^2.2.0", + "ignorefs": "^1.0.0", + "safefs": "^3.1.2", + "scandirectory": "^2.5.0", + "taskgroup": "^4.2.0", + "typechecker": "^2.0.8" + } + }, + "web3": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3/-/web3-1.0.0-beta.35.tgz", + "integrity": "sha512-xwDmUhvTcHQvvNnOPcPZZgCxKUsI2e+GbHy7JkTK3/Rmnutazy8x7fsAXT9myw7V1qpi3GgLoZ3fkglSUbg1Mg==", + "requires": { + "web3-bzz": "1.0.0-beta.35", + "web3-core": "1.0.0-beta.35", + "web3-eth": "1.0.0-beta.35", + "web3-eth-personal": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-shh": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-bzz": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-bzz/-/web3-bzz-1.0.0-beta.35.tgz", + "integrity": "sha512-BhAU0qhlr8zltm4gs/+P1gki2VkxHJaM2Rrh4DGesDW0lzwufRoNvWFlwx1bKHoFPWNbSmm9PRkHOYOINL/Tgw==", + "requires": { + "got": "7.1.0", + "swarm-js": "0.1.37", + "underscore": "1.8.3" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-core": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core/-/web3-core-1.0.0-beta.35.tgz", + "integrity": "sha512-ayGavbgVk4KL9Y88Uv411fBJ0SVgVfKhKEBweKYzmP0zOqneMzWt6YsyD1n6kRvjAbqA0AfUPEOKyMNjcx2tjw==", + "requires": { + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-requestmanager": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-core-helpers": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-helpers/-/web3-core-helpers-1.0.0-beta.35.tgz", + "integrity": "sha512-APOu3sEsamyqWt//8o4yq9KF25/uqGm+pQShson/sC4gKzmfJB07fLo2ond0X30E8fIqAPeVCotPXQxGciGUmA==", + "requires": { + "underscore": "1.8.3", + "web3-eth-iban": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-core-method": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-method/-/web3-core-method-1.0.0-beta.35.tgz", + "integrity": "sha512-jidImCide8q0GpfsO4L73qoHrbkeWgwU3uOH5DKtJtv0ccmG086knNMRgryb/o9ZgetDWLmDEsJnHjBSoIwcbA==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-promievent": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-core-promievent": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-promievent/-/web3-core-promievent-1.0.0-beta.35.tgz", + "integrity": "sha512-GvqXqKq07OmHuVi5uNRg6k79a1/CI0ViCC+EtNv4CORHtDRmYEt5Bvdv6z6FJEiaaQkD0lKbFwNhLxutx7HItw==", + "requires": { + "any-promise": "1.3.0", + "eventemitter3": "1.1.1" + } + }, + "web3-core-requestmanager": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-requestmanager/-/web3-core-requestmanager-1.0.0-beta.35.tgz", + "integrity": "sha512-S+zW2h17ZZQU9oe3yaCJE0E7aJS4C3Kf4kGPDv+nXjW0gKhQQhgVhw1Doq/aYQGqNSWJp7f1VHkz5gQWwg6RRg==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-providers-http": "1.0.0-beta.35", + "web3-providers-ipc": "1.0.0-beta.35", + "web3-providers-ws": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-core-subscriptions": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-subscriptions/-/web3-core-subscriptions-1.0.0-beta.35.tgz", + "integrity": "sha512-gXzLrWvcGkGiWq1y33Z4Y80XI8XMrwowiQJkrPSjQ81K5PBKquOGwcMffLaKcwdmEy/NpsOXDeFo3eLE1Ghvvw==", + "requires": { + "eventemitter3": "1.1.1", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-eth": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth/-/web3-eth-1.0.0-beta.35.tgz", + "integrity": "sha512-04mcb2nGPXThawuuYICPOxv0xOHofvQKsjZeIq+89nyOC8DQMGTAErDkGyMHQYtjpth5XDhic0wuEsA80AmFZA==", + "requires": { + "underscore": "1.8.3", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-eth-abi": "1.0.0-beta.35", + "web3-eth-accounts": "1.0.0-beta.35", + "web3-eth-contract": "1.0.0-beta.35", + "web3-eth-iban": "1.0.0-beta.35", + "web3-eth-personal": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-eth-abi": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-abi/-/web3-eth-abi-1.0.0-beta.35.tgz", + "integrity": "sha512-KUDC+EtFFYG8z01ZleKrASdjj327/rtWHzEt6RWsEj7bBa0bGp9nEh+nqdZx/Sdgz1O8tnfFzJlrRcXpfr1vGg==", + "requires": { + "bn.js": "4.11.6", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + }, + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-eth-accounts": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-accounts/-/web3-eth-accounts-1.0.0-beta.35.tgz", + "integrity": "sha512-duIgRsfht/0kAW/eQ0X9lKtVIykbETrnM2H7EnvplCzPHtQLodpib4o9JXfh9n6ZDgdDC7cuJoiVB9QJg089ew==", + "requires": { + "any-promise": "1.3.0", + "crypto-browserify": "3.12.0", + "eth-lib": "0.2.7", + "scrypt.js": "0.2.0", + "underscore": "1.8.3", + "uuid": "2.0.1", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "elliptic": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", + "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "eth-lib": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/eth-lib/-/eth-lib-0.2.7.tgz", + "integrity": "sha1-L5Pxex4jrsN1nNSj/iDBKGo/wco=", + "requires": { + "bn.js": "^4.11.6", + "elliptic": "^6.4.0", + "xhr-request-promise": "^0.1.2" + } + }, + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + }, + "uuid": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz", + "integrity": "sha1-wqMN7bPlNdcsz4LjQ5QaULqFM6w=" + } + } + }, + "web3-eth-contract": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-contract/-/web3-eth-contract-1.0.0-beta.35.tgz", + "integrity": "sha512-foPohOg5O1UCGKGZOIs+kQK5IZdV2QQ7pAWwNxH8WHplUA+fre1MurXNpoxknUmH6mYplFhXjqgYq2MsrBpHrA==", + "requires": { + "underscore": "1.8.3", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-promievent": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-eth-abi": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-eth-iban": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-iban/-/web3-eth-iban-1.0.0-beta.35.tgz", + "integrity": "sha512-H5wkcNcAIc+h/WoDIKv7ZYmrM2Xqu3O7jBQl1IWo73EDVQji+AoB2i3J8tuwI1yZRInRwrfpI3Zuwuf54hXHmQ==", + "requires": { + "bn.js": "4.11.6", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "web3-eth-personal": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-personal/-/web3-eth-personal-1.0.0-beta.35.tgz", + "integrity": "sha512-AcM9nnlxu7ZRRxPvkrFB9eLxMM4A2cPfj2aCg21Wb2EpMnhR+b/O1cT33k7ApRowoMpM+T9M8vx2oPNwXfaCOQ==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-net": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-net/-/web3-net-1.0.0-beta.35.tgz", + "integrity": "sha512-bbwaQ/KohGjIJ6HAKbZ6KrklCAaG6/B7hIbAbVLSFLxF+Yz9lmAgQYaDInpidpC/NLb3WOmcbRF+P77J4qMVIA==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-provider-engine": { + "version": "14.0.6", + "resolved": "https://registry.npmjs.org/web3-provider-engine/-/web3-provider-engine-14.0.6.tgz", + "integrity": "sha512-tr5cGSyxfSC/JqiUpBlJtfZpwQf1yAA8L/zy1C6fDFm0ntR974pobJ4v4676atpZne4Ze5VFy3kPPahHe9gQiQ==", + "requires": { + "async": "^2.5.0", + "backoff": "^2.5.0", + "clone": "^2.0.0", + "cross-fetch": "^2.1.0", + "eth-block-tracker": "^3.0.0", + "eth-json-rpc-infura": "^3.1.0", + "eth-sig-util": "^1.4.2", + "ethereumjs-block": "^1.2.2", + "ethereumjs-tx": "^1.2.0", + "ethereumjs-util": "^5.1.5", + "ethereumjs-vm": "^2.3.4", + "json-rpc-error": "^2.0.0", + "json-stable-stringify": "^1.0.1", + "promise-to-callback": "^1.0.0", + "readable-stream": "^2.2.9", + "request": "^2.67.0", + "semaphore": "^1.0.3", + "tape": "^4.4.0", + "ws": "^5.1.1", + "xhr": "^2.2.0", + "xtend": "^4.0.1" + }, + "dependencies": { + "ws": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/ws/-/ws-5.2.2.tgz", + "integrity": "sha512-jaHFD6PFv6UgoIVda6qZllptQsMlDEJkTQcybzzXDYM1XO9Y8em691FGMPmM46WGyLU4z9KMgQN+qrux/nhlHA==", + "requires": { + "async-limiter": "~1.0.0" + } + } + } + }, + "web3-providers-http": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-http/-/web3-providers-http-1.0.0-beta.35.tgz", + "integrity": "sha512-DcIMFq52Fb08UpWyZ3ZlES6NsNqJnco4hBS/Ej6eOcASfuUayPI+GLkYVZsnF3cBYqlH+DOKuArcKSuIxK7jIA==", + "requires": { + "web3-core-helpers": "1.0.0-beta.35", + "xhr2-cookies": "1.1.0" + } + }, + "web3-providers-ipc": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-ipc/-/web3-providers-ipc-1.0.0-beta.35.tgz", + "integrity": "sha512-iB0FG0HcpUnayfa8pn4guqEQ4Y1nrroi/jffdtQgFkrNt0sD3fMSwwC0AbmECqj3tDLl0e1slBR0RENll+ZF0g==", + "requires": { + "oboe": "2.1.3", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-providers-ws": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-ws/-/web3-providers-ws-1.0.0-beta.35.tgz", + "integrity": "sha512-Cx64NgDStynKaUGDIIOfaCd0fZusL8h5avKTkdTjUu2aHhFJhZoVBGVLhoDtUaqZGWIZGcBJOoVf2JkGUOjDRQ==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "websocket": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2" + }, + "dependencies": { + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + } + } + }, + "web3-shh": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-shh/-/web3-shh-1.0.0-beta.35.tgz", + "integrity": "sha512-8qSonk/x0xabERS9Sr6AIADN/Ty+5KwARkkGIfSYHKqFpdMDz+76F7cUCxtoCZoS8K04xgZlDKYe0TJXLYA0Fw==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35" + } + }, + "web3-utils": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.0.0-beta.35.tgz", + "integrity": "sha512-Dq6f0SOKj3BDFRgOPnE6ALbzBDCKVIW8mKWVf7tGVhTDHf+wQaWwQSC3aArFSqdExB75BPBPyDpuMTNszhljpA==", + "requires": { + "bn.js": "4.11.6", + "eth-lib": "0.1.27", + "ethjs-unit": "0.1.6", + "number-to-bn": "1.7.0", + "randomhex": "0.1.5", + "underscore": "1.8.3", + "utf8": "2.1.1" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + }, + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + }, + "utf8": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-2.1.1.tgz", + "integrity": "sha1-LgHbAvfY0JRPdxBPFgnrDDBM92g=" + } + } + }, + "websocket": { + "version": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2", + "from": "git://github.com/frozeman/WebSocket-Node.git#browserifyCompatible", + "requires": { + "debug": "^2.2.0", + "nan": "^2.3.3", + "typedarray-to-buffer": "^3.1.2", + "yaeti": "^0.0.6" + }, + "dependencies": { + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + } + } + }, + "whatwg-fetch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-2.0.4.tgz", + "integrity": "sha512-dcQ1GWpOD/eEQ97k66aiEVpNnapVj90/+R+SXTPYGHpYBBypfKJEQjLrvMZ7YXbKm21gXd4NcuxUTjiv1YtLng==" + }, + "which-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz", + "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8=" + }, + "window-size": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.2.0.tgz", + "integrity": "sha1-tDFbtCFKPXBY6+7okuE/ok2YsHU=" + }, + "winston": { + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/winston/-/winston-2.4.3.tgz", + "integrity": "sha512-GYKuysPz2pxYAVJD2NPsDLP5Z79SDEzPm9/j4tCjkF/n89iBNGBMJcR+dMUqxgPNgoSs6fVygPi+Vl2oxIpBuw==", + "requires": { + "async": "~1.0.0", + "colors": "1.0.x", + "cycle": "1.0.x", + "eyes": "0.1.x", + "isstream": "0.1.x", + "stack-trace": "0.0.x" + }, + "dependencies": { + "async": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async/-/async-1.0.0.tgz", + "integrity": "sha1-+PwEyjoTeErenhZBr5hXjPvWR6k=" + }, + "colors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz", + "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=" + } + } + }, + "wrap-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", + "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", + "requires": { + "string-width": "^1.0.1", + "strip-ansi": "^3.0.1" + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "ws": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz", + "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==", + "requires": { + "async-limiter": "~1.0.0", + "safe-buffer": "~5.1.0", + "ultron": "~1.1.0" + } + }, + "xhr": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/xhr/-/xhr-2.5.0.tgz", + "integrity": "sha512-4nlO/14t3BNUZRXIXfXe+3N6w3s1KoxcJUUURctd64BLRe67E4gRwp4PjywtDY72fXpZ1y6Ch0VZQRY/gMPzzQ==", + "requires": { + "global": "~4.3.0", + "is-function": "^1.0.1", + "parse-headers": "^2.0.0", + "xtend": "^4.0.0" + } + }, + "xhr-request": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/xhr-request/-/xhr-request-1.1.0.tgz", + "integrity": "sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==", + "requires": { + "buffer-to-arraybuffer": "^0.0.5", + "object-assign": "^4.1.1", + "query-string": "^5.0.1", + "simple-get": "^2.7.0", + "timed-out": "^4.0.1", + "url-set-query": "^1.0.0", + "xhr": "^2.0.4" + } + }, + "xhr-request-promise": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/xhr-request-promise/-/xhr-request-promise-0.1.2.tgz", + "integrity": "sha1-NDxE0e53JrhkgGloLQ+EDIO0Jh0=", + "requires": { + "xhr-request": "^1.0.1" + } + }, + "xhr2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/xhr2/-/xhr2-0.1.4.tgz", + "integrity": "sha1-f4dliEdxbbUCYyOBL4GMras4el8=" + }, + "xhr2-cookies": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/xhr2-cookies/-/xhr2-cookies-1.1.0.tgz", + "integrity": "sha1-fXdEnQmZGX8VXLc7I99yUF7YnUg=", + "requires": { + "cookiejar": "^2.1.1" + } + }, + "xmlhttprequest": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz", + "integrity": "sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw=" + }, + "xregexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/xregexp/-/xregexp-2.0.0.tgz", + "integrity": "sha1-UqY+VsoLhKfzpfPWGHLxJq16WUM=" + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + }, + "y18n": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", + "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=" + }, + "yaeti": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/yaeti/-/yaeti-0.0.6.tgz", + "integrity": "sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc=" + }, + "yargs": { + "version": "4.8.1", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-4.8.1.tgz", + "integrity": "sha1-wMQpJMpKqmsObaFznfshZDn53cA=", + "requires": { + "cliui": "^3.2.0", + "decamelize": "^1.1.1", + "get-caller-file": "^1.0.1", + "lodash.assign": "^4.0.3", + "os-locale": "^1.4.0", + "read-pkg-up": "^1.0.1", + "require-directory": "^2.1.1", + "require-main-filename": "^1.0.1", + "set-blocking": "^2.0.0", + "string-width": "^1.0.1", + "which-module": "^1.0.0", + "window-size": "^0.2.0", + "y18n": "^3.2.1", + "yargs-parser": "^2.4.1" + } + }, + "yargs-parser": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-2.4.1.tgz", + "integrity": "sha1-hVaN488VD/SfpRgl8DqMiA3cxcQ=", + "requires": { + "camelcase": "^3.0.0", + "lodash.assign": "^4.0.6" + } + }, + "yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=", + "requires": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + } + } +} diff --git a/solidity/gas-price-oracle/package.json b/solidity/gas-price-oracle/package.json new file mode 100644 index 00000000..eb7bd0aa --- /dev/null +++ b/solidity/gas-price-oracle/package.json @@ -0,0 +1,38 @@ +{ + "name": "solidity-gasprice-oracle-priv", + "version": "1.0.0", + "description": "A decentralized gas price oracle, created, funded & powered by Oraclize, leveraging the EthGasStation.info api.", + "main": "index.js", + "directories": { + "doc": "docs" + }, + "dependencies": { + "ethereum-bridge": "0.6.1", + "solc": "0.4.20", + "truffle": "5.0.0-beta.0", + "truffle-hdwallet-provider": "0.0.6", + "web3": "1.0.0-beta.35" + }, + "devDependencies": {}, + "scripts": { + "bridge": "./node_modules/.bin/ethereum-bridge -a 9 -H 127.0.0.1 -p 9545 --dev", + "test": "truffle compile && truffle test" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/oraclize/solidity-gasprice-oracle-priv.git" + }, + "author": "Oraclize", + "license": "MIT", + "bugs": { + "url": "https://github.com/oraclize/solidity-gasprice-oracle-priv/issues" + }, + "homepage": "https://github.com/oraclize/solidity-gasprice-oracle-priv#readme", + "keywords": [ + "oraclize", + "gasprice", + "oracle", + "solidity", + "ethereum" + ] +} diff --git a/solidity/gas-price-oracle/test/1-gas-price-oracle-basics.test.js b/solidity/gas-price-oracle/test/1-gas-price-oracle-basics.test.js new file mode 100644 index 00000000..2706002e --- /dev/null +++ b/solidity/gas-price-oracle/test/1-gas-price-oracle-basics.test.js @@ -0,0 +1,335 @@ +const Web3 = require('web3') +const web3 = new Web3(new Web3.providers.WebsocketProvider('ws://localhost:9545')) +const gasPriceOracle = artifacts.require('GasPriceOracle.sol') +const { PREFIX, waitForEvent, increaseEVMTime, mineXBlocks} = require('./utils') +const {toBN, BN} = web3.utils + +contract('Gas Price Oracle - Basic Tests', accounts => { + + let lBefore, sBefore, fBefore, hashBefore, time, hashAfter, lAfter, sAfter, fAfter, qID, conversionFactor, qPrice, blockNum = 0 + const gasAmt = 250000 + const startingPrice = 1234 * 1e8 + const mine50Blocks = () => mineXBlocks(web3, 50) + const increase3Mins = () => increaseEVMTime(web3, 60 * 3) + const timestampDelta = new BN ((Date.now() / 1000 | 0) - 90) + const fastForwardEVM = async () => {await mine50Blocks(), await increase3Mins()} + + beforeEach(async () => ( + {contract} = await gasPriceOracle.deployed(), + {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) // overwrite to get websockets & event subscriptions + )) + + it(`Current safe low gas price should be starting price`, async () => { + lBefore = await methods.getSafeLowPrice().call() + assert.equal(lBefore, startingPrice, 'Safe low gas price not initialized correctly!') + }) + + it(`Current standard gas price should be starting price`, async () => { + sBefore = await methods.getStandardPrice().call() + assert.equal(sBefore, startingPrice, 'Standard gas price not initialized correctly!') + }) + + it(`Current fast gas price should be starting price`, async () => { + fBefore = await methods.getFastPrice().call() + assert.equal(fBefore, startingPrice, 'Fast gas price not initialized correctly!') + }) + + it(`Time last updated should be 1`, async () => { + const time = await methods.getLastUpdated().call() + assert.equal(time, 1, `Last updated should be initialised to 1!`) + }) + + it(`Should have set off a recursive query upon contract creation`, async () => { + hashBefore = await methods.nextRecursiveQuery().call() + const { + blockNumber, + returnValues: { + safeLowPrice, + standardPrice, + fastPrice, + queryID, + IPFSMultihash + } + } = await waitForEvent(events.LogGasPricesUpdated) + const timestamp = await methods.getLastUpdated().call() + const lAfterCont = await methods.getSafeLowPrice().call() + const sAfterCont = await methods.getStandardPrice().call() + const fAfterCont = await methods.getFastPrice().call() + conversionFactor = await methods.conversionFactor().call() + blockNum = blockNumber + time = timestamp + qID = queryID + lAfter = lAfterCont + sAfter = sAfterCont + fAfter = fAfterCont + assert.equal(safeLowPrice * conversionFactor, lAfterCont, `Safe low price not logged in event correctly!`) + assert.equal(standardPrice * conversionFactor, sAfterCont, `Safe low price not logged in event correctly!`) + assert.equal(fastPrice * conversionFactor, fAfterCont, `Safe low price not logged in event correctly!`) + }) + + it(`Should have a balance left in the contract`, async () => { + const balance = await web3.eth.getBalance(contract._address) + assert.isTrue(toBN(balance).gt(new BN(0)), 'No ETH left in contract!') + }) + + it(`Should retrieve all three prices and time in one call`, async () => { + const prices = await methods.getGasPrices().call() + assert.equal(prices[0], lAfter, 'Safe low gas price not returning correctly from tuple!') + assert.equal(prices[1], sAfter, 'Standard gas price not returning correctly from tuple!') + assert.equal(prices[2], fAfter, 'Fast gas price not returning correctly from tuple!') + assert.isTrue(toBN(prices[3]).gte(timestampDelta), 'Time updated not returning correctly from tuple!') + }) + + it(`Should return the time the gas prices were last updated`, async () => { + const timestamp = await methods.getLastUpdated().call() + assert.isFalse(toBN(timestamp).eq(new BN (0)), 'Timestamp is zero!') + assert.isTrue(toBN(timestamp).gte(timestampDelta), 'Time updated not returning correctly from tuple!') + }) + + it(`Should have updated the low gas price in the struct`, async () => { + const lAfterCont = await methods.getSafeLowPrice().call() + assert.notEqual(lBefore, lAfter, 'Low gas price has not been set!') + assert.isFalse(toBN(lAfterCont).eq(new BN (0)), 'Low gas price should not be zero in struct!') + assert.equal(lAfterCont, lAfter,`Low gas price didn't update properly in struct!`) + }) + + it(`Should have updated the standard gas price in the struct`, async () => { + const sAfterCont = await methods.getStandardPrice().call() + assert.notEqual(sBefore, sAfter, 'Standard gas price has not been set!') + assert.isTrue(toBN(sAfterCont).gt(new BN (0)), 'Standard gas price should not be zero in struct!') + assert.equal(sAfterCont, sAfter,`Standard gas price didn't update properly in struct!`) + }) + + it(`Should have updated the fast gas price in the struct`, async () => { + const fAfterCont = await methods.getFastPrice().call() + assert.notEqual(fBefore, fAfter, 'Fast gas price has not been set!') + assert.isTrue(toBN(fAfterCont).gt(new BN (0)), 'Fast gas price should not be zero in struct!') + assert.equal(fAfterCont, fAfter,`Fast gas price didn't update properly in struct!`) + }) + + it(`Should have updated the time updated in the struct`, async () => { + assert.isFalse(toBN(time).eq(new BN (1)), `Last updated time didn't update properly in struct!`) + assert.isTrue(toBN(time).gt(new BN (0)), `Time should not be zero in struct!`) + }) + + it(`Recursive query should not be stale`, async () => { + const recStale = await methods.isRecursiveStale().call() + assert.isFalse(recStale, 'Recursive queries should not be stale!') + }) + + it(`Should return the delay to the next interval correctly`, async () => { + const delay = await methods.getDelayToNextInterval().call() + const interval = await methods.interval().call() + const nowUTC = Math.floor(Date.now() / 1000) + const secs = Math.floor(nowUTC % 60) + const mins = Math.floor((nowUTC / 60) % 60) + const hour = Math.floor((nowUTC / 60 / 60) % 24) + const secsElapsed = ((hour * 60 * 60) + (mins * 60) + secs) + const secsInPeriod = (((Math.floor(hour / interval)) + 1) * interval) * 60 * 60 + const expectedDelay = secsInPeriod - secsElapsed + const calcDelay = expectedDelay > 600 ? new BN(`${expectedDelay}`) : new BN(`${expectedDelay + (interval * 60 * 60)}`) + const delta = calcDelay.mul(new BN(`${0.01}`)) + assert.isTrue(toBN(delay).lte(calcDelay.add(delta)), `Interval time not set correctly in struct!`) + assert.isTrue(toBN(delay).gte(calcDelay.sub(delta)), `Interval time not set correctly in struct!`) + }) + + it(`Should have sent a second recursive query`, async () => { + hashAfter = await methods.nextRecursiveQuery().call() + assert.notEqual(hashBefore, hashAfter, 'A second recursive query has not been made!') + }) + + it(`Should return a query price when supplying a gas limit`, async () => { + const gasLimit = 2e5 + qPrice = await methods.getQueryPrice(gasLimit).call() + // TODO: Calculate here to check! + assert.isTrue(toBN(qPrice).gt(new BN(0)), `Query price isn't returning correctly!`) + }) + + it(`Should return a query price when supplying a gas price & limit`, async () => { + const gasLimit = 2e5 + const gasPrice = 6e10 + const qPriceNow = await methods.getQueryPrice(gasLimit, gasPrice).call() + // TODO: Calculate here to check! + assert.isTrue(toBN(qPrice).gt(new BN (0)), `Query price isn't returning correctly!`) + assert.notEqual(qPrice, qPriceNow, 'QUery price getter is not returning correctly!') + }) + + it(`Should allow a manual query with no params if correct price is supplied`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + const account = accounts[5] + await methods.updateGasPrices().send({from: account, value: cost, gas: gasAmt}) + const {blockNumber} = await waitForEvent(events.LogGasPricesUpdated, blockNum) + time = await methods.getLastUpdated() + }) + + it(`Should refund excess ETH when querying with no params`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const account = accounts[5] + const gasPrice = new BN(`${20e9}`) + const balBefore = await web3.eth.getBalance(account) + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + const amount = new BN(cost).add(new BN(`${1e18}`)) + const {gasUsed} = await methods.updateGasPrices().send({from: account, value: amount, gas: gasAmt, gasPrice: gasPrice}) + const {returnValues: {safeLowPrice,standardPrice,fastPrice}} = await waitForEvent(events.LogGasPricesUpdated, blockNum ) + assert.notEqual(parseInt(safeLowPrice), 0, 'Safe low gas price not logged correctly!') + assert.notEqual(parseInt(standardPrice), 0, 'Standard gas price not logged correctly!') + assert.notEqual(parseInt(fastPrice), 0, 'Fast gas price not logged correctly!') + const balAfter = await web3.eth.getBalance(account) + const diff = toBN(balBefore).sub(toBN(balAfter)) + const price = new BN(`${cost}`).add(gasPrice.mul(new BN (`${gasUsed}`))) + assert.isTrue(price.sub(diff).eq(new BN(`${0}`)), `Excess ETH wasn't refunded correctly!`) + }) + + it(`Should have updated the time the gas prices were last updated`, async () => { + const timestamp = await methods.getLastUpdated().call() + assert.isFalse(new BN(`${time}`).eq(new BN(`${timestamp}`)), `Time in gas struct was not updated after manual query with no params!`) + time = timestamp + }) + + it(`Manual query with no params should not have updated the recursive query hash`, async () => { + const hash = await methods.nextRecursiveQuery().call() + assert.equal(hash, hashAfter, 'Next recursive query hash should not have been updated!') + }) + + it(`Should not allow a manual query with no params if ETH provided is < cost`, async () => { + const expErr = 'revert' + const account = accounts[5] + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + const amount = new BN(`${cost}`).sub(new BN(`${1e9}`)) + try { + await methods.updateGasPrices().send({from: account, value: amount, gas: gasAmt}) + assert.fail(`Transaction should not have succeeded!`) + } catch (e) { + assert.isTrue(e.message.startsWith(`${PREFIX}${expErr}`), `Expected ${PREFIX + expErr} but got ${e.message} instead!`) + } + }) + + it(`Should allow a manual query with a provided delay if supplied ETH = cost`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 1 + const account = accounts[5] + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + await methods.updateGasPrices(delay).send({from: account, value: cost, gas: gasAmt}) + await waitForEvent(events.LogGasPricesUpdated, blockNum) + }) + + it(`Manual query with delay should not have updated the recursive query hash`, async () => { + const hash = await methods.nextRecursiveQuery().call() + assert.equal(hash, hashAfter, 'Next recursive query hash should not have been updated!') + }) + + it(`Should have updated the time the gas prices were last updated again`, async () => { + const timestamp = await methods.getLastUpdated().call() + assert.isFalse(new BN(`${time}`).eq(new BN(`${timestamp}`)), `Time in gas struct was not updated after manual query with no params!`) + time = timestamp + }) + + it(`Should refund excess ETH when querying with "delay" param`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 30 + const account = accounts[5] + const gasPrice = new BN(`${20e9}`) + const balBefore = await web3.eth.getBalance(account) + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + const amount = new BN(cost).add(new BN(`${1e18}`)) + const {gasUsed} = await methods.updateGasPrices(delay).send({from: account, value: amount, gas: gasAmt, gasPrice: gasPrice}) + const {returnValues: {safeLowPrice,standardPrice,fastPrice}} = await waitForEvent(events.LogGasPricesUpdated, blockNum) + assert.notEqual(parseInt(safeLowPrice), 0, 'Safe low gas price not logged correctly!') + assert.notEqual(parseInt(standardPrice), 0, 'Standard gas price not logged correctly!') + assert.notEqual(parseInt(fastPrice), 0, 'Fast gas price not logged correctly!') + const balAfter = await web3.eth.getBalance(account) + const diff = toBN(balBefore).sub(toBN(balAfter)) + const price = new BN(`${cost}`).add(gasPrice.mul(new BN (`${gasUsed}`))) + assert.isTrue(price.sub(diff).eq(new BN(`${0}`)), `Excess ETH wasn't refunded correctly!`) + }) + + it(`Should have updated the time the gas prices were last updated`, async () => { + const timestamp = await methods.getLastUpdated().call() + assert.isFalse(new BN(`${time}`).eq(new BN(`${timestamp}`)), `Time in gas struct was not updated after manual query with one param!`) + time = timestamp + }) + + it(`Should not allow a manual query with a provided delay if ETH provided is < cost`, async () => { + const delay = 1 + const expErr = `revert` + const account = accounts[5] + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit).call() + const amount = new BN(`${cost}`).sub(new BN(`${1e9}`)) + try { + await methods.updateGasPrices(delay).send({from: account, value: amount, gas: gasAmt}) + } catch (e) { + assert.isTrue(e.message.startsWith(`${PREFIX}${expErr}`), `Expected ${expErr} but got ${e.message} instead!`) + } + }) + + it(`Should allow a manual query with a provided delay & custom gas price`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 1 + const gasLimit = await methods.gasLimit().call() + const gasPrice = new BN(`${40e9}`) + const cost = await methods.getQueryPrice(gasLimit, gasPrice).call() + const account = accounts[5] + await methods.updateGasPrices(delay, gasPrice).send({from: account, value: cost, gas: gasAmt}) + await waitForEvent(events.LogGasPricesUpdated, blockNum) + }) + + it(`Manual query with delay & custom gas price should not have updated the recursive query hash`, async () => { + const hash = await methods.nextRecursiveQuery().call() + assert.equal(hash, hashAfter, 'Next recursive query hash should not have been updated!') + }) + + it(`Should have updated the time the gas prices were last updated yet again`, async () => { + const timestamp = await methods.getLastUpdated().call() + assert.isFalse(new BN(`${time}`).eq(new BN(`${timestamp}`)), `Time in gas struct was not updated after manual query with two params!`) + time = timestamp + }) + + it(`Should refund excess ETH when querying with "delay" & "gasPrice" params`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 1 + const account = accounts[5] + const gasPrice = new BN(`${60e9}`) + const balBefore = await web3.eth.getBalance(account) + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit, gasPrice).call() + const amount = new BN(cost).add(new BN(`${1e18}`)) + const {gasUsed} = await methods.updateGasPrices(delay, gasPrice).send({from: account, value: amount, gas: gasAmt, gasPrice: gasPrice}) + const {returnValues: {safeLowPrice,standardPrice,fastPrice}} = await waitForEvent(events.LogGasPricesUpdated, blockNum ) + assert.notEqual(parseInt(safeLowPrice), 0, 'Safe low gas price not logged correctly!') + assert.notEqual(parseInt(standardPrice), 0, 'Standard gas price not logged correctly!') + assert.notEqual(parseInt(fastPrice), 0, 'Fast gas price not logged correctly!') + const balAfter = await web3.eth.getBalance(account) + const diff = toBN(balBefore).sub(toBN(balAfter)) + const price = new BN(`${cost}`).add(gasPrice.mul(new BN (`${gasUsed}`))) + assert.isTrue(price.sub(diff).eq(new BN(`${0}`)), `Excess ETH wasn't refunded correctly!`) + }) + + it(`Should not allow a manual query with a provided delay & custom gas price if insufficient ETH provided`, async () => { + const delay = 60 + const expErr = 'revert' + const account = accounts[5] + const gasPrice = new BN(`${20e9}`) + const gasLimit = await methods.gasLimit().call() + const cost = await methods.getQueryPrice(gasLimit, gasPrice).call() + const amount = new BN(`${cost}`).sub(new BN(`${1e9}`)) + try { + await methods.updateGasPrices(delay, gasPrice).send({from: account, value: amount, gas: gasAmt}) + assert.fail(`Transaction should not have succeeded!`) + } catch (e) { + assert.isTrue(e.message.startsWith(`${PREFIX}${expErr}`), `Expected ${expErr} but got ${e.message} instead!`) + } + }) +}) diff --git a/solidity/gas-price-oracle/test/2-gas-price-oracle-stale.test.js b/solidity/gas-price-oracle/test/2-gas-price-oracle-stale.test.js new file mode 100644 index 00000000..693d64d5 --- /dev/null +++ b/solidity/gas-price-oracle/test/2-gas-price-oracle-stale.test.js @@ -0,0 +1,149 @@ +const Web3 = require('web3') +const web3 = new Web3(new Web3.providers.WebsocketProvider('ws://localhost:9545')) +const gasPriceOracle = artifacts.require('GasPriceOracle.sol') +const {waitForEvent, increaseEVMTime, mineXBlocks} = require('./utils') +const {BN} = web3.utils + +contract('Gas Price Oracle Stale Tests', accounts => { + + let blockNum = 0 + const gasAmt = 250000 + + const mine50Blocks = () => mineXBlocks(web3, 50) + const increase3Mins = () => increaseEVMTime(web3, 60 * 3) + const fastForwardEVM = async () => {await mine50Blocks(), await increase3Mins()} + + beforeEach(async () => ( + {contract} = await gasPriceOracle.deployed(), + {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + )) + + it(`Should have set off a recursive query upon contract creation`, async () => { + const hashBefore = await methods.nextRecursiveQuery().call() + const hashAfter = await waitForEvent(events.LogGasPricesUpdated) + assert.notEqual(hashBefore, hashAfter, `Initial query should have begun recursion!`) + }) + + it(`Should advance time until the recursive query becomes stale`, async () => { + const week = 1 * 60 * 60 * 24 * 7 + await increaseEVMTime(web3, week) + await mineXBlocks(web3, 100) + const stale = await methods.isRecursiveStale().call() + assert.isTrue(stale, 'Recursive queries should now be stale!') + }) + + it(`Queries using delay of 0, sufficient ETH but gas prices < than previous recursive queries should succeed but not restart recursion`, async () => { + const delay = 0 + const account = accounts[5] + const recIDBefore = await methods.nextRecursiveQuery().call() + const structBefore = await methods.queryIDs(recIDBefore).call() + const priceToUse = new BN(`${structBefore[4]}`).sub(new BN(`${1e9}`)) + const gasLimit = await methods.gasLimitRec().call() + assert.isTrue(priceToUse.gt(new BN (0)), 'Price to use should be above zero!') + const cost = await methods.getQueryPrice(gasLimit, priceToUse).call() + await methods.updateGasPrices(delay, priceToUse).send({from: account, value: cost, gas: gasAmt}) + await waitForEvent(events.LogGasPricesUpdated, blockNum) + const stale = await methods.isRecursiveStale().call() + const recIDAfter = await methods.nextRecursiveQuery().call() + const structAfter = await methods.queryIDs(recIDAfter).call() + assert.equal(recIDBefore, recIDAfter, 'Recursive ID should not have been updated!') + assert.equal(delay, 0, 'Delay should be 0 for this test!') + assert.isFalse(structAfter[2], 'Query should not be a revival!') + assert.isTrue(stale, 'Recursive queries should still be stale!') + }) + + it(`Queries using delay of 0, sufficient ETH but gas prices = to previous recursive queries should succeed but not restart recursion`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 0 + const account = accounts[5] + const recIDBefore = await methods.nextRecursiveQuery().call() + const structBefore = await methods.queryIDs(recIDBefore).call() + const priceToUse = new BN(`${structBefore[4]}`) + const gasLimit = await methods.gasLimitRec().call() + const cost = await methods.getQueryPrice(gasLimit, priceToUse).call() + await methods.updateGasPrices(delay, priceToUse).send({from: account, value: cost, gas: gasAmt}) + await waitForEvent(events.LogGasPricesUpdated, blockNum) + const stale = await methods.isRecursiveStale().call() + const recIDAfter = await methods.nextRecursiveQuery().call() + const structAfter = await methods.queryIDs(recIDAfter).call() + assert.equal(recIDBefore, recIDAfter, 'Recursive ID should not have been updated!') + assert.equal(delay, 0, 'Delay should be 0 for this test!') + assert.isFalse(structAfter[2], 'Query should not be a revival!') + assert.isTrue(stale, 'Recursive queries should still be stale!') + }) + + it('Queries of delay > 0 & high gas prices should not successed but not restart recursion', async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const delay = 1 + const account = accounts[5] + const gasPrice = new BN(`${100e9}`) + const recIDBefore = await methods.nextRecursiveQuery().call() + const gasLimit = await methods.gasLimitRec().call() + const cost = await methods.getQueryPrice(gasLimit, gasPrice).call() + await methods.updateGasPrices(delay).send({from: account, value: cost, gas: gasAmt}) + await waitForEvent(events.LogGasPricesUpdated, blockNum) + const stale = await methods.isRecursiveStale().call() + const recIDAfter = await methods.nextRecursiveQuery().call() + const structAfter = await methods.queryIDs(recIDAfter).call() + assert.isAbove(delay, 0, 'Delay should be > 0 for this test!') + assert.isTrue(stale, 'Recursive queries should still be stale!') + assert.equal(recIDBefore, recIDAfter, 'Recursive ID should not have been updated!') + assert.isFalse(structAfter[2], 'Query should not be a revival!') + }) + + it(`Queries with delay of 0, high gas prices, but insufficient ETH should not succeed nor restart recursion`, async () => { + const delay = 0 + const account = accounts[5] + const gasPrice = new BN(`${100e9}`) + const recIDBefore = await methods.nextRecursiveQuery().call() + const gasLimit = await methods.gasLimitRec().call() + const cost = await methods.getQueryPrice(gasLimit, gasPrice).call() + const amount = new BN(`${cost}`).sub(new BN(`${1e9}`)) + try { + await methods.updateGasPrices(delay, gasPrice).send({from: account, value: amount, gas: gasAmt}) + assert.fail(`Transaction should not have succeeded!`) + } catch (e) { + const stale = await methods.isRecursiveStale().call() + assert.equal(delay, 0, 'Delay should be 0 for this test!') + assert.isTrue(stale, 'Recursive queries should still be stale!') + const recIDAfter = await methods.nextRecursiveQuery().call() + const qIDStruct = await methods.queryIDs(recIDAfter).call() + assert.equal(recIDBefore, recIDAfter, 'Recursive ID should not have been updated!') + assert.isFalse(qIDStruct[2], 'Query should not be a revival!') + } + }) + + it(`Query with delay of 0, a gas price 1Gwei higher than prior call, plus sufficient ETH supplied should succceed and restart recursion`, async () => { + await fastForwardEVM() + blockNum = await web3.eth.getBlockNumber() + const staleBefore = await methods.isRecursiveStale().call() + assert.isTrue(staleBefore, 'Recursive queries should be stale!') + const delay = 0 + const account = accounts[5] + const recIDBefore = await methods.nextRecursiveQuery().call() + const structBefore = await methods.queryIDs(recIDBefore).call() + const gasLimit = await methods.gasLimitRec().call() + const priceToUse = new BN(`${structBefore[4]}`).add(new BN(`${1e9}`)) + const cost = await methods.getQueryPrice(gasLimit, priceToUse).call() + const amount = new BN(`${cost}`).mul(new BN(`${10}`)) + await methods.updateGasPrices(delay, priceToUse).send({from: account, value: amount, gas: gasAmt}) + const interimID = await methods.nextRecursiveQuery().call() + const interimStruct = await methods.queryIDs(interimID).call() + const staleInterim = await methods.isRecursiveStale().call() + assert.isTrue(interimStruct[2], 'Query should be a revival!') + assert.isFalse(interimStruct[0], 'Despite manual, ∵ its restarting recursion, query should be an "automated" one!') + assert.notEqual(recIDBefore, interimID, 'There should be a new recursive query ID!') + assert.isTrue(staleInterim, ' Recursive queries should still be stale whilst recursive ID is a revival!') + await waitForEvent(events.LogGasPricesUpdated, blockNum) + const recIDAfter = await methods.nextRecursiveQuery().call() + const structAfter = await methods.queryIDs(recIDAfter).call() + const staleAfter = await methods.isRecursiveStale().call() + assert.equal(delay, 0, 'Delay should be 0 for this test!') + assert.notEqual(interimID, recIDAfter, 'There should be a new recursive query ID!') + assert.isFalse(staleAfter, 'Recursive queries should no longer be stale!') + assert.isFalse(structAfter[2], 'Final query should not be a be a revival!') + assert.isFalse(structAfter[0], 'Final detected query should be an automated one!') + }) +}) diff --git a/solidity/gas-price-oracle/test/utils.js b/solidity/gas-price-oracle/test/utils.js new file mode 100644 index 00000000..cff95469 --- /dev/null +++ b/solidity/gas-price-oracle/test/utils.js @@ -0,0 +1,32 @@ +const waitForEvent = (_event, _from = 0, _to = 'latest') => + new Promise ((resolve,reject) => + _event({fromBlock: _from, toBlock: _to}, (e, ev) => + e ? reject(e) : resolve(ev))) + +const PREFIX = "Returned error: VM Exception while processing transaction: " + +const increaseEVMTime = (web3, secsToIncreaseBy) => + new Promise((resolve, reject) => + web3.currentProvider.send({jsonrpc: '2.0', method: 'evm_increaseTime', params:[secsToIncreaseBy], id: Date.now()}, e => + e ? reject(e) : web3.currentProvider.send({jsonrpc: '2.0', method: 'evm_mine', params: [], id: Date.now() + 1}, (e2, res) => + e2 ? reject(e2) : resolve(res)))) + +const mineXBlocks = (web3, numBlocks) => + new Promise((resolve, reject) => + Promise.all(new Array (numBlocks).fill().map((_,i) => + new Promise ((res, rej) => + web3.currentProvider.send({jsonrpc: '2.0', method: 'evm_mine', params: [], id: Date.now() + i}, e => + e ? rej() : res())))).then(resolve).catch(reject)) + +const getTimestamp = blockNum => + new Promise ((resolve, reject) => + web3.eth.getBlock(blockNum, false, (e, b) => + e ? reject(e) : resolve(b.timestamp))) + +module.exports = { + increaseEVMTime, + getTimestamp, + waitForEvent, + mineXBlocks, + PREFIX +} \ No newline at end of file diff --git a/solidity/gas-price-oracle/truffle.js b/solidity/gas-price-oracle/truffle.js new file mode 100644 index 00000000..f0ab93ea --- /dev/null +++ b/solidity/gas-price-oracle/truffle.js @@ -0,0 +1,47 @@ +const HDWalletProvider = require("truffle-hdwallet-provider") + +// Note: If deploying to a live network, please provide a mnemonic & infura apikey. + +const apikey = '' +const mnemonic = '' + +module.exports = { + networks: { + development: { + host: "127.0.0.1", + port: 8545, + network_id: "*", + websockets: true + }, + mainnet: { + provider: () => new HDWalletProvider(mnemonic, `https://mainnet.infura.io/${apikey}`), + network_id: '1', + gas: 3e6, + gasPrice: 20e9 + }, + ropsten: { + provider: () => new HDWalletProvider(mnemonic, `https://ropsten.infura.io/${apikey}`), + network_id: '3', + gas: 47e5, + gasPrice: 20e9 + }, + rinkeby: { + provider: () => new HDWalletProvider(mnemonic, `https://rinkeby.infura.io/${apikey}`), + network_id: '4', + gas: 3e6, + gasPrice: 20e9 + } + }, + solc: { + settings: { + optimizer: { + enabled: true + } + } + }, + compilers: { + solc: { + version: '0.4.24' + } + } +} \ No newline at end of file From e7f364bb104f0b79eeb1eaec9fb4b7bb316d1cd5 Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Thu, 11 Oct 2018 16:36:42 +0100 Subject: [PATCH 09/14] make var public for automated testing --- .../computation-datasource/bitcoin/BitcoinAddressExample.sol | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol b/solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol index 037c6d95..20bcf0ef 100644 --- a/solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol +++ b/solidity/computation-datasource/bitcoin/BitcoinAddressExample.sol @@ -9,7 +9,7 @@ import "github.com/oraclize/ethereum-api/oraclizeAPI.sol"; contract BitcoinAddressExample is usingOraclize { // Address balance in Satoshis - uint256 balance; + uint256 public balance; event BitcoinAddressBalance(uint _balance); From 184adb800a171af7cf848c712193cb0bd181d9c1 Mon Sep 17 00:00:00 2001 From: gregkapka Date: Mon, 15 Oct 2018 17:00:41 +0100 Subject: [PATCH 10/14] MVP of new Truffle-examples folder --- .../truffle-examples/url-requests/README.md | 49 + .../computation-archive/archive.zip | Bin 0 -> 756 bytes .../computation-archive/src/Dockerfile | 7 + .../computation-archive/src/url-requests.py | 21 + .../url-requests/contracts/Migrations.sol | 23 + .../url-requests/contracts/UrlRequests.sol | 80 + .../url-requests/contracts/oraclizeAPI.sol | 1230 +++++++ .../migrations/1_initial_migration.js | 2 + .../migrations/2_deploy_contracts.js | 2 + .../url-requests/package-lock.json | 3192 +++++++++++++++++ .../url-requests/package.json | 23 + .../url-requests/test/url-requests-tests.js | 170 + .../url-requests/test/utils.js | 4 + .../truffle-examples/url-requests/truffle.js | 15 + .../url-requests/url-requests-tests.jpg | Bin 0 -> 126599 bytes 15 files changed, 4818 insertions(+) create mode 100644 solidity/truffle-examples/url-requests/README.md create mode 100644 solidity/truffle-examples/url-requests/computation-archive/archive.zip create mode 100644 solidity/truffle-examples/url-requests/computation-archive/src/Dockerfile create mode 100644 solidity/truffle-examples/url-requests/computation-archive/src/url-requests.py create mode 100644 solidity/truffle-examples/url-requests/contracts/Migrations.sol create mode 100644 solidity/truffle-examples/url-requests/contracts/UrlRequests.sol create mode 100644 solidity/truffle-examples/url-requests/contracts/oraclizeAPI.sol create mode 100644 solidity/truffle-examples/url-requests/migrations/1_initial_migration.js create mode 100644 solidity/truffle-examples/url-requests/migrations/2_deploy_contracts.js create mode 100644 solidity/truffle-examples/url-requests/package-lock.json create mode 100644 solidity/truffle-examples/url-requests/package.json create mode 100644 solidity/truffle-examples/url-requests/test/url-requests-tests.js create mode 100644 solidity/truffle-examples/url-requests/test/utils.js create mode 100644 solidity/truffle-examples/url-requests/truffle.js create mode 100644 solidity/truffle-examples/url-requests/url-requests-tests.jpg diff --git a/solidity/truffle-examples/url-requests/README.md b/solidity/truffle-examples/url-requests/README.md new file mode 100644 index 00000000..5aef6cee --- /dev/null +++ b/solidity/truffle-examples/url-requests/README.md @@ -0,0 +1,49 @@ +# :wrench: :construction: Testing Oraclize's Url-Requests example contracts. + +  + +This repo is to demonstrate how you would set up an Oraclize smart-contract development environment using Truffle & the Ethereum-Bridge to do most of the heavy lifting for you. Head on over to the `./test` folder to examine the javascript files that thoroughly test the smart-contract, which latter you will find in `./contracts`. + +## :page_with_curl: _Instructions_ + +**1):** Fire up your favourite console & make sure you have Truffle 5 installed: + +__`❍ npm install -g truffle@beta`__ + +**2)** Clone this repo somewhere: + +__`❍ git clone https://github.com/oraclize/ethereum-examples.git`__ + +**3)** Enter this directory & install dependencies: + +__`❍ cd ethereum-examples/truffle-examples/url-requests && npm install`__ + +**4)** Launch Truffle: + +__`❍ truffle develop`__ + +**5)** Open a _NEW_ console in the same directory & spool up the ethereum-bridge: + +__`❍ ./node_modules/.bin/ethereum-bridge -a 9 -H 127.0.0.1 -p 9545 --dev`__ + +**6)** Once the bridge is ready & listening, go back to the first console with Truffle running & set the tests going! + +__`❍ test`__ + +  + +## :camera: Passing Tests: + +![Tests!!](oraclize-truffle-tests.jpg) + +  + +## :black_nib: Notes: + +The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! + +Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! + +If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api) channel to get timely support! + +Happy developing! diff --git a/solidity/truffle-examples/url-requests/computation-archive/archive.zip b/solidity/truffle-examples/url-requests/computation-archive/archive.zip new file mode 100644 index 0000000000000000000000000000000000000000..baac65ebf029dd15748ec5d65d784618131a6101 GIT binary patch literal 756 zcmWIWW@Zs#-~hs{-X1;-P%s5Zb1^6|xa22irxvAU=A?#(@G`Jpi>rx(;nE6j21b?_ z%nS@*qL};B_fQY*Q|C2Ld-`1TKcji#jQ3UD6*?zRoHu^g> z13%C|rA0ZqMX80Qsl_G5dIgnWPr2sQM8Pncr(y$a{h1AU?ta$pv3jy@)jIhc57`+v zBKw8CR%SBi6&=~v%=Phpp+@5>?>9Hz+y1UBGL^SDYi@Vu_u@Cn2FK)o&0zU)LbX&! z)%S;)!s&SJO@_iRVv|^Sly_`NUd+E{Veg%clglNds;ld_Z@9~&m*suC^gq+}%-O65 z*gHS`nz!|UeY5mj_3er#zfP{18hT>p6<@~npI7l#9(?jb(B1v&(F0T8W;GwFIQH|; zDQycun=ee8jz7ATai#9#oj+<*Kiz7bb+T|}p_OgsRr|0>>-d}Ge@56$xTnGJdxJ8| zCr0iiRSzYky7Ep>UQGZC2TvldBJ%vSYE{9L9Jb6tJ&zZm0YK1}Z4{0=yZS zM3@mt1v$_`Nd*R$G=f;fCmdvRK~aWmCn(BbU`gWzAd|!h4De=U0~x>sgj<2MCKHGU E0B;Hno&W#< literal 0 HcmV?d00001 diff --git a/solidity/truffle-examples/url-requests/computation-archive/src/Dockerfile b/solidity/truffle-examples/url-requests/computation-archive/src/Dockerfile new file mode 100644 index 00000000..c3a04310 --- /dev/null +++ b/solidity/truffle-examples/url-requests/computation-archive/src/Dockerfile @@ -0,0 +1,7 @@ +FROM frolvlad/alpine-python3 +MAINTAINER Oraclize "info@oraclize.it" + +COPY url-requests.py / + +RUN pip3 install requests +CMD python ./url-requests.py diff --git a/solidity/truffle-examples/url-requests/computation-archive/src/url-requests.py b/solidity/truffle-examples/url-requests/computation-archive/src/url-requests.py new file mode 100644 index 00000000..c43f9039 --- /dev/null +++ b/solidity/truffle-examples/url-requests/computation-archive/src/url-requests.py @@ -0,0 +1,21 @@ +#!/usr/bin/python + +import ast +import requests +import os + +# parse env args +arg = [os.environ['ARG0'], os.environ['ARG1']] + +# parse 3rd arg into kwargs if available +if 'ARG2' in os.environ: kwargs = ast.literal_eval(os.environ['ARG2']) +else: kwargs = {} + +# attempt the request +req = requests.request(arg[0], arg[1], **kwargs) + +# print text result on single line +print(req.text.replace('\n','')) + +# option if always json +# print(json.loads(req.text)) diff --git a/solidity/truffle-examples/url-requests/contracts/Migrations.sol b/solidity/truffle-examples/url-requests/contracts/Migrations.sol new file mode 100644 index 00000000..c4efb65e --- /dev/null +++ b/solidity/truffle-examples/url-requests/contracts/Migrations.sol @@ -0,0 +1,23 @@ +pragma solidity ^0.4.23; + +contract Migrations { + address public owner; + uint public last_completed_migration; + + constructor() public { + owner = msg.sender; + } + + modifier restricted() { + if (msg.sender == owner) _; + } + + function setCompleted(uint completed) public restricted { + last_completed_migration = completed; + } + + function upgrade(address new_address) public restricted { + Migrations upgraded = Migrations(new_address); + upgraded.setCompleted(last_completed_migration); + } +} diff --git a/solidity/truffle-examples/url-requests/contracts/UrlRequests.sol b/solidity/truffle-examples/url-requests/contracts/UrlRequests.sol new file mode 100644 index 00000000..68a0b33a --- /dev/null +++ b/solidity/truffle-examples/url-requests/contracts/UrlRequests.sol @@ -0,0 +1,80 @@ +/* + Utilizies computation datasource + + Provides a fully featured HTTP library by way of the Python requests module, + allowing custom headers, auth etc... to be used as kwargs. Refer to + http://docs.python-requests.org/en/latest/api/ for full feature list +*/ +pragma solidity ^0.4.0; + +import "./oraclizeAPI.sol"; + +contract UrlRequests is usingOraclize { + + event newOraclizeQuery(string description); + event LogResult(string result); + + function UrlRequests() payable { + //oraclize_setProof(proofType_TLSNotary | proofStorage_IPFS); + } + + function __callback(bytes32 myid, string result) { + if (msg.sender != oraclize_cbAddress()) throw; + emit LogResult(result); + } + + function request(string _query, string _method, string _url, string _kwargs) payable { + if (oraclize_getPrice("computation") > this.balance) { + newOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee"); + } else { + newOraclizeQuery("Oraclize query was sent, standing by for the answer..."); + oraclize_query("computation", + [_query, + _method, + _url, + _kwargs] + ); + } + } + // sends a custom content-type in header and returns the header used as result + // wrap first arguement of computation ds with helper needed, such as json in this case + function requestCustomHeaders() payable { + request("json(QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE).headers", + "GET", + "http://httpbin.org/headers", + "{'headers': {'content-type': 'json'}}" + ); + } + + function requestBasicAuth() payable { + request("QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE", + "GET", + "http://httpbin.org/basic-auth/myuser/secretpass", + "{'auth': ('myuser','secretpass'), 'headers': {'content-type': 'json'}}" + ); + } + + function requestPost() payable { + request("QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE", + "POST", + "https://api.postcodes.io/postcodes", + '{"json": {"postcodes" : ["OX49 5NU"]}}' + ); + } + + function requestPut() payable { + request("QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE", + "PUT", + "http://httpbin.org/anything", + "{'json' : {'testing':'it works'}}" + ); + } + + function requestCookies() payable { + request("QmdKK319Veha83h6AYgQqhx9YRsJ9MJE7y33oCXyZ4MqHE", + "GET", + "http://httpbin.org/cookies", + "{'cookies' : {'thiscookie':'should be saved and visible :)'}}" + ); + } +} diff --git a/solidity/truffle-examples/url-requests/contracts/oraclizeAPI.sol b/solidity/truffle-examples/url-requests/contracts/oraclizeAPI.sol new file mode 100644 index 00000000..623c5253 --- /dev/null +++ b/solidity/truffle-examples/url-requests/contracts/oraclizeAPI.sol @@ -0,0 +1,1230 @@ +// +/* +Copyright (c) 2015-2016 Oraclize SRL +Copyright (c) 2016 Oraclize LTD + + + +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. +*/ + +// This api is currently targeted at 0.4.18, please import oraclizeAPI_pre0.4.sol or oraclizeAPI_0.4 where necessary + +pragma solidity >=0.4.18;// Incompatible compiler version... please select one stated within pragma solidity or use different oraclizeAPI version + +contract OraclizeI { + address public cbAddress; + function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id); + function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id); + function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id); + function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id); + function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id); + function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id); + function getPrice(string _datasource) public returns (uint _dsprice); + function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice); + function setProofType(byte _proofType) external; + function setCustomGasPrice(uint _gasPrice) external; + function randomDS_getSessionPubKeyHash() external constant returns(bytes32); +} + +contract OraclizeAddrResolverI { + function getAddress() public returns (address _addr); +} + +/* +Begin solidity-cborutils + +https://github.com/smartcontractkit/solidity-cborutils + +MIT License + +Copyright (c) 2018 SmartContract ChainLink, Ltd. + +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. + */ + +library Buffer { + struct buffer { + bytes buf; + uint capacity; + } + + function init(buffer memory buf, uint _capacity) internal pure { + uint capacity = _capacity; + if(capacity % 32 != 0) capacity += 32 - (capacity % 32); + // Allocate space for the buffer data + buf.capacity = capacity; + assembly { + let ptr := mload(0x40) + mstore(buf, ptr) + mstore(ptr, 0) + mstore(0x40, add(ptr, capacity)) + } + } + + function resize(buffer memory buf, uint capacity) private pure { + bytes memory oldbuf = buf.buf; + init(buf, capacity); + append(buf, oldbuf); + } + + function max(uint a, uint b) private pure returns(uint) { + if(a > b) { + return a; + } + return b; + } + + /** + * @dev Appends a byte array to the end of the buffer. Resizes if doing so + * would exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function append(buffer memory buf, bytes data) internal pure returns(buffer memory) { + if(data.length + buf.buf.length > buf.capacity) { + resize(buf, max(buf.capacity, data.length) * 2); + } + + uint dest; + uint src; + uint len = data.length; + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Start address = buffer address + buffer length + sizeof(buffer length) + dest := add(add(bufptr, buflen), 32) + // Update buffer length + mstore(bufptr, add(buflen, mload(data))) + src := add(data, 32) + } + + // Copy word-length chunks while possible + for(; len >= 32; len -= 32) { + assembly { + mstore(dest, mload(src)) + } + dest += 32; + src += 32; + } + + // Copy remaining bytes + uint mask = 256 ** (32 - len) - 1; + assembly { + let srcpart := and(mload(src), not(mask)) + let destpart := and(mload(dest), mask) + mstore(dest, or(destpart, srcpart)) + } + + return buf; + } + + /** + * @dev Appends a byte to the end of the buffer. Resizes if doing so would + * exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function append(buffer memory buf, uint8 data) internal pure { + if(buf.buf.length + 1 > buf.capacity) { + resize(buf, buf.capacity * 2); + } + + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Address = buffer address + buffer length + sizeof(buffer length) + let dest := add(add(bufptr, buflen), 32) + mstore8(dest, data) + // Update buffer length + mstore(bufptr, add(buflen, 1)) + } + } + + /** + * @dev Appends a byte to the end of the buffer. Resizes if doing so would + * exceed the capacity of the buffer. + * @param buf The buffer to append to. + * @param data The data to append. + * @return The original buffer. + */ + function appendInt(buffer memory buf, uint data, uint len) internal pure returns(buffer memory) { + if(len + buf.buf.length > buf.capacity) { + resize(buf, max(buf.capacity, len) * 2); + } + + uint mask = 256 ** len - 1; + assembly { + // Memory address of the buffer data + let bufptr := mload(buf) + // Length of existing buffer data + let buflen := mload(bufptr) + // Address = buffer address + buffer length + sizeof(buffer length) + len + let dest := add(add(bufptr, buflen), len) + mstore(dest, or(and(mload(dest), not(mask)), data)) + // Update buffer length + mstore(bufptr, add(buflen, len)) + } + return buf; + } +} + +library CBOR { + using Buffer for Buffer.buffer; + + uint8 private constant MAJOR_TYPE_INT = 0; + uint8 private constant MAJOR_TYPE_NEGATIVE_INT = 1; + uint8 private constant MAJOR_TYPE_BYTES = 2; + uint8 private constant MAJOR_TYPE_STRING = 3; + uint8 private constant MAJOR_TYPE_ARRAY = 4; + uint8 private constant MAJOR_TYPE_MAP = 5; + uint8 private constant MAJOR_TYPE_CONTENT_FREE = 7; + + function encodeType(Buffer.buffer memory buf, uint8 major, uint value) private pure { + if(value <= 23) { + buf.append(uint8((major << 5) | value)); + } else if(value <= 0xFF) { + buf.append(uint8((major << 5) | 24)); + buf.appendInt(value, 1); + } else if(value <= 0xFFFF) { + buf.append(uint8((major << 5) | 25)); + buf.appendInt(value, 2); + } else if(value <= 0xFFFFFFFF) { + buf.append(uint8((major << 5) | 26)); + buf.appendInt(value, 4); + } else if(value <= 0xFFFFFFFFFFFFFFFF) { + buf.append(uint8((major << 5) | 27)); + buf.appendInt(value, 8); + } + } + + function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure { + buf.append(uint8((major << 5) | 31)); + } + + function encodeUInt(Buffer.buffer memory buf, uint value) internal pure { + encodeType(buf, MAJOR_TYPE_INT, value); + } + + function encodeInt(Buffer.buffer memory buf, int value) internal pure { + if(value >= 0) { + encodeType(buf, MAJOR_TYPE_INT, uint(value)); + } else { + encodeType(buf, MAJOR_TYPE_NEGATIVE_INT, uint(-1 - value)); + } + } + + function encodeBytes(Buffer.buffer memory buf, bytes value) internal pure { + encodeType(buf, MAJOR_TYPE_BYTES, value.length); + buf.append(value); + } + + function encodeString(Buffer.buffer memory buf, string value) internal pure { + encodeType(buf, MAJOR_TYPE_STRING, bytes(value).length); + buf.append(bytes(value)); + } + + function startArray(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_ARRAY); + } + + function startMap(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP); + } + + function endSequence(Buffer.buffer memory buf) internal pure { + encodeIndefiniteLengthType(buf, MAJOR_TYPE_CONTENT_FREE); + } +} + +/* +End solidity-cborutils + */ + +contract usingOraclize { + uint constant day = 60*60*24; + uint constant week = 60*60*24*7; + uint constant month = 60*60*24*30; + byte constant proofType_NONE = 0x00; + byte constant proofType_TLSNotary = 0x10; + byte constant proofType_Ledger = 0x30; + byte constant proofType_Android = 0x40; + byte constant proofType_Native = 0xF0; + byte constant proofStorage_IPFS = 0x01; + uint8 constant networkID_auto = 0; + uint8 constant networkID_mainnet = 1; + uint8 constant networkID_testnet = 2; + uint8 constant networkID_morden = 2; + uint8 constant networkID_consensys = 161; + + OraclizeAddrResolverI OAR; + + OraclizeI oraclize; + modifier oraclizeAPI { + if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) + oraclize_setNetwork(networkID_auto); + + if(address(oraclize) != OAR.getAddress()) + oraclize = OraclizeI(OAR.getAddress()); + + _; + } + modifier coupon(string code){ + oraclize = OraclizeI(OAR.getAddress()); + _; + } + + function oraclize_setNetwork(uint8 networkID) internal returns(bool){ + return oraclize_setNetwork(); + networkID; // silence the warning and remain backwards compatible + } + function oraclize_setNetwork() internal returns(bool){ + if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){ //mainnet + OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed); + oraclize_setNetworkName("eth_mainnet"); + return true; + } + if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1)>0){ //ropsten testnet + OAR = OraclizeAddrResolverI(0xc03A2615D5efaf5F49F60B7BB6583eaec212fdf1); + oraclize_setNetworkName("eth_ropsten3"); + return true; + } + if (getCodeSize(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e)>0){ //kovan testnet + OAR = OraclizeAddrResolverI(0xB7A07BcF2Ba2f2703b24C0691b5278999C59AC7e); + oraclize_setNetworkName("eth_kovan"); + return true; + } + if (getCodeSize(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48)>0){ //rinkeby testnet + OAR = OraclizeAddrResolverI(0x146500cfd35B22E4A392Fe0aDc06De1a1368Ed48); + oraclize_setNetworkName("eth_rinkeby"); + return true; + } + if (getCodeSize(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)>0){ //ethereum-bridge + OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475); + return true; + } + if (getCodeSize(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF)>0){ //ether.camp ide + OAR = OraclizeAddrResolverI(0x20e12A1F859B3FeaE5Fb2A0A32C18F5a65555bBF); + return true; + } + if (getCodeSize(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA)>0){ //browser-solidity + OAR = OraclizeAddrResolverI(0x51efaF4c8B3C9AfBD5aB9F4bbC82784Ab6ef8fAA); + return true; + } + return false; + } + + function __callback(bytes32 myid, string result) public { + __callback(myid, result, new bytes(0)); + } + function __callback(bytes32 myid, string result, bytes proof) public { + return; + myid; result; proof; // Silence compiler warnings + } + + function oraclize_getPrice(string datasource) oraclizeAPI internal returns (uint){ + return oraclize.getPrice(datasource); + } + + function oraclize_getPrice(string datasource, uint gaslimit) oraclizeAPI internal returns (uint){ + return oraclize.getPrice(datasource, gaslimit); + } + + function oraclize_query(string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query.value(price)(0, datasource, arg); + } + function oraclize_query(uint timestamp, string datasource, string arg) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query.value(price)(timestamp, datasource, arg); + } + function oraclize_query(uint timestamp, string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query_withGasLimit.value(price)(timestamp, datasource, arg, gaslimit); + } + function oraclize_query(string datasource, string arg, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query_withGasLimit.value(price)(0, datasource, arg, gaslimit); + } + function oraclize_query(string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query2.value(price)(0, datasource, arg1, arg2); + } + function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2); + } + function oraclize_query(uint timestamp, string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query2_withGasLimit.value(price)(timestamp, datasource, arg1, arg2, gaslimit); + } + function oraclize_query(string datasource, string arg1, string arg2, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + return oraclize.query2_withGasLimit.value(price)(0, datasource, arg1, arg2, gaslimit); + } + function oraclize_query(string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN.value(price)(0, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, string[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN.value(price)(timestamp, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); + } + function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = stra2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); + } + function oraclize_query(string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[1] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[2] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[3] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[4] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, string[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + string[] memory dynargs = new string[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN.value(price)(0, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource); + if (price > 1 ether + tx.gasprice*200000) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN.value(price)(timestamp, datasource, args); + } + function oraclize_query(uint timestamp, string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(timestamp, datasource, args, gaslimit); + } + function oraclize_query(string datasource, bytes[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){ + uint price = oraclize.getPrice(datasource, gaslimit); + if (price > 1 ether + tx.gasprice*gaslimit) return 0; // unexpectedly high price + bytes memory args = ba2cbor(argN); + return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit); + } + function oraclize_query(string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[1] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](1); + dynargs[0] = args[0]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[2] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[2] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](2); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[3] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](3); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_query(string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[4] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[4] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](4); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + return oraclize_query(datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs); + } + function oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(timestamp, datasource, dynargs, gaslimit); + } + function oraclize_query(string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) { + bytes[] memory dynargs = new bytes[](5); + dynargs[0] = args[0]; + dynargs[1] = args[1]; + dynargs[2] = args[2]; + dynargs[3] = args[3]; + dynargs[4] = args[4]; + return oraclize_query(datasource, dynargs, gaslimit); + } + + function oraclize_cbAddress() oraclizeAPI internal returns (address){ + return oraclize.cbAddress(); + } + function oraclize_setProof(byte proofP) oraclizeAPI internal { + return oraclize.setProofType(proofP); + } + function oraclize_setCustomGasPrice(uint gasPrice) oraclizeAPI internal { + return oraclize.setCustomGasPrice(gasPrice); + } + + function oraclize_randomDS_getSessionPubKeyHash() oraclizeAPI internal returns (bytes32){ + return oraclize.randomDS_getSessionPubKeyHash(); + } + + function getCodeSize(address _addr) constant internal returns(uint _size) { + assembly { + _size := extcodesize(_addr) + } + } + + function parseAddr(string _a) internal pure returns (address){ + bytes memory tmp = bytes(_a); + uint160 iaddr = 0; + uint160 b1; + uint160 b2; + for (uint i=2; i<2+2*20; i+=2){ + iaddr *= 256; + b1 = uint160(tmp[i]); + b2 = uint160(tmp[i+1]); + if ((b1 >= 97)&&(b1 <= 102)) b1 -= 87; + else if ((b1 >= 65)&&(b1 <= 70)) b1 -= 55; + else if ((b1 >= 48)&&(b1 <= 57)) b1 -= 48; + if ((b2 >= 97)&&(b2 <= 102)) b2 -= 87; + else if ((b2 >= 65)&&(b2 <= 70)) b2 -= 55; + else if ((b2 >= 48)&&(b2 <= 57)) b2 -= 48; + iaddr += (b1*16+b2); + } + return address(iaddr); + } + + function strCompare(string _a, string _b) internal pure returns (int) { + bytes memory a = bytes(_a); + bytes memory b = bytes(_b); + uint minLength = a.length; + if (b.length < minLength) minLength = b.length; + for (uint i = 0; i < minLength; i ++) + if (a[i] < b[i]) + return -1; + else if (a[i] > b[i]) + return 1; + if (a.length < b.length) + return -1; + else if (a.length > b.length) + return 1; + else + return 0; + } + + function indexOf(string _haystack, string _needle) internal pure returns (int) { + bytes memory h = bytes(_haystack); + bytes memory n = bytes(_needle); + if(h.length < 1 || n.length < 1 || (n.length > h.length)) + return -1; + else if(h.length > (2**128 -1)) + return -1; + else + { + uint subindex = 0; + for (uint i = 0; i < h.length; i ++) + { + if (h[i] == n[0]) + { + subindex = 1; + while(subindex < n.length && (i + subindex) < h.length && h[i + subindex] == n[subindex]) + { + subindex++; + } + if(subindex == n.length) + return int(i); + } + } + return -1; + } + } + + function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string) { + bytes memory _ba = bytes(_a); + bytes memory _bb = bytes(_b); + bytes memory _bc = bytes(_c); + bytes memory _bd = bytes(_d); + bytes memory _be = bytes(_e); + string memory abcde = new string(_ba.length + _bb.length + _bc.length + _bd.length + _be.length); + bytes memory babcde = bytes(abcde); + uint k = 0; + for (uint i = 0; i < _ba.length; i++) babcde[k++] = _ba[i]; + for (i = 0; i < _bb.length; i++) babcde[k++] = _bb[i]; + for (i = 0; i < _bc.length; i++) babcde[k++] = _bc[i]; + for (i = 0; i < _bd.length; i++) babcde[k++] = _bd[i]; + for (i = 0; i < _be.length; i++) babcde[k++] = _be[i]; + return string(babcde); + } + + function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) { + return strConcat(_a, _b, _c, _d, ""); + } + + function strConcat(string _a, string _b, string _c) internal pure returns (string) { + return strConcat(_a, _b, _c, "", ""); + } + + function strConcat(string _a, string _b) internal pure returns (string) { + return strConcat(_a, _b, "", "", ""); + } + + // parseInt + function parseInt(string _a) internal pure returns (uint) { + return parseInt(_a, 0); + } + + // parseInt(parseFloat*10^_b) + function parseInt(string _a, uint _b) internal pure returns (uint) { + bytes memory bresult = bytes(_a); + uint mint = 0; + bool decimals = false; + for (uint i=0; i= 48)&&(bresult[i] <= 57)){ + if (decimals){ + if (_b == 0) break; + else _b--; + } + mint *= 10; + mint += uint(bresult[i]) - 48; + } else if (bresult[i] == 46) decimals = true; + } + if (_b > 0) mint *= 10**_b; + return mint; + } + + function uint2str(uint i) internal pure returns (string){ + if (i == 0) return "0"; + uint j = i; + uint len; + while (j != 0){ + len++; + j /= 10; + } + bytes memory bstr = new bytes(len); + uint k = len - 1; + while (i != 0){ + bstr[k--] = byte(48 + i % 10); + i /= 10; + } + return string(bstr); + } + + using CBOR for Buffer.buffer; + function stra2cbor(string[] arr) internal pure returns (bytes) { + safeMemoryCleaner(); + Buffer.buffer memory buf; + Buffer.init(buf, 1024); + buf.startArray(); + for (uint i = 0; i < arr.length; i++) { + buf.encodeString(arr[i]); + } + buf.endSequence(); + return buf.buf; + } + + function ba2cbor(bytes[] arr) internal pure returns (bytes) { + safeMemoryCleaner(); + Buffer.buffer memory buf; + Buffer.init(buf, 1024); + buf.startArray(); + for (uint i = 0; i < arr.length; i++) { + buf.encodeBytes(arr[i]); + } + buf.endSequence(); + return buf.buf; + } + + string oraclize_network_name; + function oraclize_setNetworkName(string _network_name) internal { + oraclize_network_name = _network_name; + } + + function oraclize_getNetworkName() internal view returns (string) { + return oraclize_network_name; + } + + function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){ + require((_nbytes > 0) && (_nbytes <= 32)); + // Convert from seconds to ledger timer ticks + _delay *= 10; + bytes memory nbytes = new bytes(1); + nbytes[0] = byte(_nbytes); + bytes memory unonce = new bytes(32); + bytes memory sessionKeyHash = new bytes(32); + bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash(); + assembly { + mstore(unonce, 0x20) + // the following variables can be relaxed + // check relaxed random contract under ethereum-examples repo + // for an idea on how to override and replace comit hash vars + mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp))) + mstore(sessionKeyHash, 0x20) + mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32) + } + bytes memory delay = new bytes(32); + assembly { + mstore(add(delay, 0x20), _delay) + } + + bytes memory delay_bytes8 = new bytes(8); + copyBytes(delay, 24, 8, delay_bytes8, 0); + + bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay]; + bytes32 queryId = oraclize_query("random", args, _customGasLimit); + + bytes memory delay_bytes8_left = new bytes(8); + + assembly { + let x := mload(add(delay_bytes8, 0x20)) + mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000)) + mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000)) + + } + + oraclize_randomDS_setCommitment(queryId, keccak256(delay_bytes8_left, args[1], sha256(args[0]), args[2])); + return queryId; + } + + function oraclize_randomDS_setCommitment(bytes32 queryId, bytes32 commitment) internal { + oraclize_randomDS_args[queryId] = commitment; + } + + mapping(bytes32=>bytes32) oraclize_randomDS_args; + mapping(bytes32=>bool) oraclize_randomDS_sessionKeysHashVerified; + + function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){ + bool sigok; + address signer; + + bytes32 sigr; + bytes32 sigs; + + bytes memory sigr_ = new bytes(32); + uint offset = 4+(uint(dersig[3]) - 0x20); + sigr_ = copyBytes(dersig, offset, 32, sigr_, 0); + bytes memory sigs_ = new bytes(32); + offset += 32 + 2; + sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0); + + assembly { + sigr := mload(add(sigr_, 32)) + sigs := mload(add(sigs_, 32)) + } + + + (sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs); + if (address(keccak256(pubkey)) == signer) return true; + else { + (sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs); + return (address(keccak256(pubkey)) == signer); + } + } + + function oraclize_randomDS_proofVerify__sessionKeyValidity(bytes proof, uint sig2offset) internal returns (bool) { + bool sigok; + + // Step 6: verify the attestation signature, APPKEY1 must sign the sessionKey from the correct ledger app (CODEHASH) + bytes memory sig2 = new bytes(uint(proof[sig2offset+1])+2); + copyBytes(proof, sig2offset, sig2.length, sig2, 0); + + bytes memory appkey1_pubkey = new bytes(64); + copyBytes(proof, 3+1, 64, appkey1_pubkey, 0); + + bytes memory tosign2 = new bytes(1+65+32); + tosign2[0] = byte(1); //role + copyBytes(proof, sig2offset-65, 65, tosign2, 1); + bytes memory CODEHASH = hex"fd94fa71bc0ba10d39d464d0d8f465efeef0a2764e3887fcc9df41ded20f505c"; + copyBytes(CODEHASH, 0, 32, tosign2, 1+65); + sigok = verifySig(sha256(tosign2), sig2, appkey1_pubkey); + + if (sigok == false) return false; + + + // Step 7: verify the APPKEY1 provenance (must be signed by Ledger) + bytes memory LEDGERKEY = hex"7fb956469c5c9b89840d55b43537e66a98dd4811ea0a27224272c2e5622911e8537a2f8e86a46baec82864e98dd01e9ccc2f8bc5dfc9cbe5a91a290498dd96e4"; + + bytes memory tosign3 = new bytes(1+65); + tosign3[0] = 0xFE; + copyBytes(proof, 3, 65, tosign3, 1); + + bytes memory sig3 = new bytes(uint(proof[3+65+1])+2); + copyBytes(proof, 3+65, sig3.length, sig3, 0); + + sigok = verifySig(sha256(tosign3), sig3, LEDGERKEY); + + return sigok; + } + + modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) { + // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1) + require((_proof[0] == "L") && (_proof[1] == "P") && (_proof[2] == 1)); + + bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); + require(proofVerified); + + _; + } + + function oraclize_randomDS_proofVerify__returnCode(bytes32 _queryId, string _result, bytes _proof) internal returns (uint8){ + // Step 1: the prefix has to match 'LP\x01' (Ledger Proof version 1) + if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) return 1; + + bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName()); + if (proofVerified == false) return 2; + + return 0; + } + + function matchBytes32Prefix(bytes32 content, bytes prefix, uint n_random_bytes) internal pure returns (bool){ + bool match_ = true; + + require(prefix.length == n_random_bytes); + + for (uint256 i=0; i< n_random_bytes; i++) { + if (content[i] != prefix[i]) match_ = false; + } + + return match_; + } + + function oraclize_randomDS_proofVerify__main(bytes proof, bytes32 queryId, bytes result, string context_name) internal returns (bool){ + + // Step 2: the unique keyhash has to match with the sha256 of (context name + queryId) + uint ledgerProofLength = 3+65+(uint(proof[3+65+1])+2)+32; + bytes memory keyhash = new bytes(32); + copyBytes(proof, ledgerProofLength, 32, keyhash, 0); + if (!(keccak256(keyhash) == keccak256(sha256(context_name, queryId)))) return false; + + bytes memory sig1 = new bytes(uint(proof[ledgerProofLength+(32+8+1+32)+1])+2); + copyBytes(proof, ledgerProofLength+(32+8+1+32), sig1.length, sig1, 0); + + // Step 3: we assume sig1 is valid (it will be verified during step 5) and we verify if 'result' is the prefix of sha256(sig1) + if (!matchBytes32Prefix(sha256(sig1), result, uint(proof[ledgerProofLength+32+8]))) return false; + + // Step 4: commitment match verification, keccak256(delay, nbytes, unonce, sessionKeyHash) == commitment in storage. + // This is to verify that the computed args match with the ones specified in the query. + bytes memory commitmentSlice1 = new bytes(8+1+32); + copyBytes(proof, ledgerProofLength+32, 8+1+32, commitmentSlice1, 0); + + bytes memory sessionPubkey = new bytes(64); + uint sig2offset = ledgerProofLength+32+(8+1+32)+sig1.length+65; + copyBytes(proof, sig2offset-64, 64, sessionPubkey, 0); + + bytes32 sessionPubkeyHash = sha256(sessionPubkey); + if (oraclize_randomDS_args[queryId] == keccak256(commitmentSlice1, sessionPubkeyHash)){ //unonce, nbytes and sessionKeyHash match + delete oraclize_randomDS_args[queryId]; + } else return false; + + + // Step 5: validity verification for sig1 (keyhash and args signed with the sessionKey) + bytes memory tosign1 = new bytes(32+8+1+32); + copyBytes(proof, ledgerProofLength, 32+8+1+32, tosign1, 0); + if (!verifySig(sha256(tosign1), sig1, sessionPubkey)) return false; + + // verify if sessionPubkeyHash was verified already, if not.. let's do it! + if (oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] == false){ + oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash] = oraclize_randomDS_proofVerify__sessionKeyValidity(proof, sig2offset); + } + + return oraclize_randomDS_sessionKeysHashVerified[sessionPubkeyHash]; + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + function copyBytes(bytes from, uint fromOffset, uint length, bytes to, uint toOffset) internal pure returns (bytes) { + uint minLength = length + toOffset; + + // Buffer too small + require(to.length >= minLength); // Should be a better way? + + // NOTE: the offset 32 is added to skip the `size` field of both bytes variables + uint i = 32 + fromOffset; + uint j = 32 + toOffset; + + while (i < (32 + fromOffset + length)) { + assembly { + let tmp := mload(add(from, i)) + mstore(add(to, j), tmp) + } + i += 32; + j += 32; + } + + return to; + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + // Duplicate Solidity's ecrecover, but catching the CALL return value + function safer_ecrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal returns (bool, address) { + // We do our own memory management here. Solidity uses memory offset + // 0x40 to store the current end of memory. We write past it (as + // writes are memory extensions), but don't update the offset so + // Solidity will reuse it. The memory used here is only needed for + // this context. + + // FIXME: inline assembly can't access return values + bool ret; + address addr; + + assembly { + let size := mload(0x40) + mstore(size, hash) + mstore(add(size, 32), v) + mstore(add(size, 64), r) + mstore(add(size, 96), s) + + // NOTE: we can reuse the request memory because we deal with + // the return code + ret := call(3000, 1, 0, size, 128, size, 32) + addr := mload(size) + } + + return (ret, addr); + } + + // the following function has been written by Alex Beregszaszi (@axic), use it under the terms of the MIT license + function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) { + bytes32 r; + bytes32 s; + uint8 v; + + if (sig.length != 65) + return (false, 0); + + // The signature format is a compact form of: + // {bytes32 r}{bytes32 s}{uint8 v} + // Compact means, uint8 is not padded to 32 bytes. + assembly { + r := mload(add(sig, 32)) + s := mload(add(sig, 64)) + + // Here we are loading the last 32 bytes. We exploit the fact that + // 'mload' will pad with zeroes if we overread. + // There is no 'mload8' to do this, but that would be nicer. + v := byte(0, mload(add(sig, 96))) + + // Alternative solution: + // 'byte' is not working due to the Solidity parser, so lets + // use the second best option, 'and' + // v := and(mload(add(sig, 65)), 255) + } + + // albeit non-transactional signatures are not specified by the YP, one would expect it + // to match the YP range of [27, 28] + // + // geth uses [0, 1] and some clients have followed. This might change, see: + // https://github.com/ethereum/go-ethereum/issues/2053 + if (v < 27) + v += 27; + + if (v != 27 && v != 28) + return (false, 0); + + return safer_ecrecover(hash, v, r, s); + } + + function safeMemoryCleaner() internal pure { + assembly { + let fmem := mload(0x40) + codecopy(fmem, codesize, sub(msize, fmem)) + } + } + +} +// diff --git a/solidity/truffle-examples/url-requests/migrations/1_initial_migration.js b/solidity/truffle-examples/url-requests/migrations/1_initial_migration.js new file mode 100644 index 00000000..df77f528 --- /dev/null +++ b/solidity/truffle-examples/url-requests/migrations/1_initial_migration.js @@ -0,0 +1,2 @@ +module.exports = deployer => + deployer.deploy(artifacts.require("./Migrations.sol")) diff --git a/solidity/truffle-examples/url-requests/migrations/2_deploy_contracts.js b/solidity/truffle-examples/url-requests/migrations/2_deploy_contracts.js new file mode 100644 index 00000000..07d35797 --- /dev/null +++ b/solidity/truffle-examples/url-requests/migrations/2_deploy_contracts.js @@ -0,0 +1,2 @@ +module.exports = deployer => + deployer.deploy(artifacts.require("UrlRequests.sol")) diff --git a/solidity/truffle-examples/url-requests/package-lock.json b/solidity/truffle-examples/url-requests/package-lock.json new file mode 100644 index 00000000..c3eef0ad --- /dev/null +++ b/solidity/truffle-examples/url-requests/package-lock.json @@ -0,0 +1,3192 @@ +{ + "name": "url-request-tests", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "abbrev": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-1.1.1.tgz", + "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==" + }, + "accepts": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.5.tgz", + "integrity": "sha1-63d99gEXI6OxTopywIBcjoZ0a9I=", + "requires": { + "mime-types": "~2.1.18", + "negotiator": "0.6.1" + } + }, + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "requires": { + "co": "^4.6.0", + "fast-deep-equal": "^1.0.0", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.3.0" + } + }, + "ambi": { + "version": "2.5.0", + "resolved": "http://registry.npmjs.org/ambi/-/ambi-2.5.0.tgz", + "integrity": "sha1-fI43K+SIkRV+fOoBy2+RQ9H3QiA=", + "requires": { + "editions": "^1.1.1", + "typechecker": "^4.3.0" + }, + "dependencies": { + "typechecker": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/typechecker/-/typechecker-4.6.0.tgz", + "integrity": "sha512-83OrXpyP3LNr7aRbLkt2nkjE/d7q8su8/uRvrKxCpswqVCVGOgyaKpaz8/MTjQqBYe4eLNuJ44pNakFZKqyPMA==", + "requires": { + "editions": "^2.0.2" + }, + "dependencies": { + "editions": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/editions/-/editions-2.0.2.tgz", + "integrity": "sha512-0B8aSTWUu9+JW99zHoeogavCi+lkE5l35FK0OKe0pCobixJYoeof3ZujtqYzSsU2MskhRadY5V9oWUuyG4aJ3A==", + "requires": { + "errlop": "^1.0.2", + "semver": "^5.5.0" + } + } + } + } + } + }, + "any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha1-q8av7tzqUugJzcA3au0845Y10X8=" + }, + "array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI=" + }, + "asn1": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.4.tgz", + "integrity": "sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg==", + "requires": { + "safer-buffer": "~2.1.0" + } + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", + "requires": { + "bn.js": "^4.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "async": { + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.1.tgz", + "integrity": "sha512-fNEiL2+AZt6AlAw/29Cr0UDe4sRAHCpEHh54WMz+Bb7QfNcFw4h3loofyJpLeQs4Yx7yuqu/2dLgM5hKOs6HlQ==", + "requires": { + "lodash": "^4.17.10" + } + }, + "async-limiter": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-limiter/-/async-limiter-1.0.0.tgz", + "integrity": "sha512-jp/uFnooOiO+L211eZOoSyzpOITMXx1rBITauYykG3BRYPu8h0UcxsPNB04RR5vo4Tyz3+ay17tR6JVf9qzYWg==" + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=" + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=" + }, + "aws4": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz", + "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==" + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base-x": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/base-x/-/base-x-3.0.4.tgz", + "integrity": "sha512-UYOadoSIkEI/VrRGSG6qp93rp2WdokiAiNYDfGW5qURAY8GiAQkvMbwNNSDYiVJopqv4gCna7xqf4rrNGp+5AA==", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "base64-js": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz", + "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==" + }, + "bcrypt-pbkdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz", + "integrity": "sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4=", + "requires": { + "tweetnacl": "^0.14.3" + } + }, + "bignumber.js": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-6.0.0.tgz", + "integrity": "sha512-x247jIuy60/+FtMRvscqfxtVHQf8AGx2hm9c6btkgC0x/hp9yt+teISNhvF8WlwRkCc5yF2fDECH8SIMe8j+GA==" + }, + "bindings": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.3.0.tgz", + "integrity": "sha512-DpLh5EzMR2kzvX1KIlVC0VkC3iZtHKTgdtZ0a3pglBZdaQFjt5S9g9xd1lE+YvXyfd6mtCeRnrUfOLYiTMlNSw==" + }, + "bip66": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/bip66/-/bip66-1.1.5.tgz", + "integrity": "sha1-AfqHSHhcpwlV1QESF9GzE5lpyiI=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "bitcore-lib": { + "version": "0.15.0", + "resolved": "https://registry.npmjs.org/bitcore-lib/-/bitcore-lib-0.15.0.tgz", + "integrity": "sha512-AeXLWhiivF6CDFzrABZHT4jJrflyylDWTi32o30rF92HW9msfuKpjzrHtFKYGa9w0kNVv5HABQjCB3OEav4PhQ==", + "requires": { + "bn.js": "=4.11.8", + "bs58": "=4.0.1", + "buffer-compare": "=1.1.1", + "elliptic": "=6.4.0", + "inherits": "=2.0.1", + "lodash": "=4.17.4" + }, + "dependencies": { + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" + }, + "lodash": { + "version": "4.17.4", + "resolved": "http://registry.npmjs.org/lodash/-/lodash-4.17.4.tgz", + "integrity": "sha1-eCA6TRwyiuHYbcpkYONptX9AVa4=" + } + } + }, + "bitcore-mnemonic": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/bitcore-mnemonic/-/bitcore-mnemonic-1.5.0.tgz", + "integrity": "sha512-sbeP4xwkindLMfIQhVxj6rZSDMwtiKmfc1DqvwpR6Yg+Qo4I4WHO5pvzb12Y04uDh1N3zgD45esHhfH0HHmE4g==", + "requires": { + "bitcore-lib": "^0.15.0", + "unorm": "^1.3.3" + } + }, + "bl": { + "version": "1.2.2", + "resolved": "http://registry.npmjs.org/bl/-/bl-1.2.2.tgz", + "integrity": "sha512-e8tQYnZodmebYDWGH7KMRvtzKXaJHx3BbilrgZCfvyLUYdKpK1t5PSPmpkny/SgiTSCnjfLW7v5rlONXVFkQEA==", + "requires": { + "readable-stream": "^2.3.5", + "safe-buffer": "^5.1.1" + } + }, + "block-stream": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz", + "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=", + "requires": { + "inherits": "~2.0.0" + } + }, + "bluebird": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.5.2.tgz", + "integrity": "sha512-dhHTWMI7kMx5whMQntl7Vr9C6BvV10lFXDAasnqnrMYhXVCzzk6IO9Fo2L75jXHT07WrOngL1WDXOp+yYS91Yg==" + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==" + }, + "body-parser": { + "version": "1.18.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.18.3.tgz", + "integrity": "sha1-WykhmP/dVTs6DyDe0FkrlWlVyLQ=", + "requires": { + "bytes": "3.0.0", + "content-type": "~1.0.4", + "debug": "2.6.9", + "depd": "~1.1.2", + "http-errors": "~1.6.3", + "iconv-lite": "0.4.23", + "on-finished": "~2.3.0", + "qs": "6.5.2", + "raw-body": "2.3.3", + "type-is": "~1.6.16" + } + }, + "borc": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/borc/-/borc-2.0.3.tgz", + "integrity": "sha512-2mfipKUXn7yLgwn8D5jZkJqd2ZyzqmYZQX/9d4On33oGNDLwxj5qQMst+nkKyEdaujQRFfrZCId+k8wehQVANg==", + "requires": { + "bignumber.js": "^6.0.0", + "commander": "^2.15.0", + "ieee754": "^1.1.8", + "json-text-sequence": "^0.1" + }, + "dependencies": { + "commander": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.19.0.tgz", + "integrity": "sha512-6tvAOO+D6OENvRAh524Dh9jcfKTYDQAqvqezbCW82xj5X0pSrcpxtvRKHLG0yBY6SD7PSDrJaj+0AiOcKVd1Xg==" + } + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=" + }, + "browserify-aes": { + "version": "1.2.0", + "resolved": "http://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz", + "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==", + "requires": { + "buffer-xor": "^1.0.3", + "cipher-base": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.3", + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "browserify-cipher": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.1.tgz", + "integrity": "sha512-sPhkz0ARKbf4rRQt2hTpAHqn47X3llLkUGn+xEJzLjwY8LRs2p0v7ljvI5EyoRO/mexrNunNECisZs+gw2zz1w==", + "requires": { + "browserify-aes": "^1.0.4", + "browserify-des": "^1.0.0", + "evp_bytestokey": "^1.0.0" + } + }, + "browserify-des": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.2.tgz", + "integrity": "sha512-BioO1xf3hFwz4kc6iBhI3ieDFompMhrMlnDFC4/0/vd5MokpuAc3R+LYbwTA9A5Yc9pq9UYPqffKpW2ObuwX5A==", + "requires": { + "cipher-base": "^1.0.1", + "des.js": "^1.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "http://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "requires": { + "bn.js": "^4.1.0", + "randombytes": "^2.0.1" + } + }, + "browserify-sha3": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/browserify-sha3/-/browserify-sha3-0.0.1.tgz", + "integrity": "sha1-P/NKMAbvFcD7NWflQbkaI0ASPRE=", + "requires": { + "js-sha3": "^0.3.1" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "requires": { + "bn.js": "^4.1.1", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.2", + "elliptic": "^6.0.0", + "inherits": "^2.0.1", + "parse-asn1": "^5.0.0" + } + }, + "bs58": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/bs58/-/bs58-4.0.1.tgz", + "integrity": "sha1-vhYedsNU9veIrkBx9j806MTwpCo=", + "requires": { + "base-x": "^3.0.2" + } + }, + "bson": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/bson/-/bson-1.1.0.tgz", + "integrity": "sha512-9Aeai9TacfNtWXOYarkFJRW2CWo+dRon+fuLZYJmvLV3+MiUp0bEI6IAZfXEIg7/Pl/7IWlLaDnhzTsD81etQA==", + "optional": true + }, + "buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.2.1.tgz", + "integrity": "sha512-c+Ko0loDaFfuPWiL02ls9Xd3GO3cPVmUobQ6t3rXNUk304u6hGq+8N/kFi+QEIKhzK3uwolVhLzszmfLmMLnqg==", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4" + } + }, + "buffer-alloc": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/buffer-alloc/-/buffer-alloc-1.2.0.tgz", + "integrity": "sha512-CFsHQgjtW1UChdXgbyJGtnm+O/uLQeZdtbDo8mfUgYXCHSM1wgrVxXm6bSyrUuErEb+4sYVGCzASBRot7zyrow==", + "requires": { + "buffer-alloc-unsafe": "^1.1.0", + "buffer-fill": "^1.0.0" + } + }, + "buffer-alloc-unsafe": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-alloc-unsafe/-/buffer-alloc-unsafe-1.1.0.tgz", + "integrity": "sha512-TEM2iMIEQdJ2yjPJoSIsldnleVaAk1oW3DBVUykyOLsEsFmEc9kn+SFFPz+gl54KQNxlDnAwCXosOS9Okx2xAg==" + }, + "buffer-compare": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/buffer-compare/-/buffer-compare-1.1.1.tgz", + "integrity": "sha1-W+e+hTr4kZjR9N3AkNHWakiu9ZY=" + }, + "buffer-crc32": { + "version": "0.2.13", + "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", + "integrity": "sha1-DTM+PwDqxQqhRUq9MO+MKl2ackI=" + }, + "buffer-fill": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/buffer-fill/-/buffer-fill-1.0.0.tgz", + "integrity": "sha1-+PeLdniYiO858gXNY39o5wISKyw=" + }, + "buffer-to-arraybuffer": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/buffer-to-arraybuffer/-/buffer-to-arraybuffer-0.0.5.tgz", + "integrity": "sha1-YGSkD6dutDxyOrqe+PbhIW0QURo=" + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=" + }, + "bytes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.0.0.tgz", + "integrity": "sha1-0ygVQE1olpn4Wk6k+odV3ROpYEg=" + }, + "caminte": { + "version": "0.3.7", + "resolved": "https://registry.npmjs.org/caminte/-/caminte-0.3.7.tgz", + "integrity": "sha1-7B7ARXZkoPCSZDt8ZGxFfVzW9pM=", + "requires": { + "bluebird": "^3.4.6", + "uuid": "^3.0.1" + } + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=" + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "clone": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz", + "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=" + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "colors": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.3.2.tgz", + "integrity": "sha512-rhP0JSBGYvpcNQj4s5AdShMeE5ahMop96cTeDl/v9qQQm2fYClE2QXZRi8wLzc+GmXSxdIqqbOIAhyObEXDbfQ==" + }, + "combined-stream": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.7.tgz", + "integrity": "sha512-brWl9y6vOB1xYPZcpZde3N9zDByXTosAeMDo4p1wzo6UMOX4vumB+TP1RZ76sfE6Md68Q0NJSrE/gbezd4Ul+w==", + "requires": { + "delayed-stream": "~1.0.0" + } + }, + "commander": { + "version": "2.8.1", + "resolved": "http://registry.npmjs.org/commander/-/commander-2.8.1.tgz", + "integrity": "sha1-Br42f+v9oMMwqh4qBy09yXYkJdQ=", + "requires": { + "graceful-readlink": ">= 1.0.0" + } + }, + "compare-versions": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/compare-versions/-/compare-versions-3.4.0.tgz", + "integrity": "sha512-tK69D7oNXXqUW3ZNo/z7NXTEz22TCF0pTE+YF9cxvaAM9XnkLo1fV621xCLrRR6aevJlKxExkss0vWqUCUpqdg==" + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "content-disposition": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.2.tgz", + "integrity": "sha1-DPaLud318r55YcOoUXjLhdunjLQ=" + }, + "content-type": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.4.tgz", + "integrity": "sha512-hIP3EEPs8tB9AT1L+NUqtwOAps4mk2Zob89MWXMHjHWg9milF/j4osnnQLXBCBFBk/tvIG/tUc9mOUJiPBhPXA==" + }, + "cookie": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.3.1.tgz", + "integrity": "sha1-5+Ch+e9DtMi6klxcWpboBtFoc7s=" + }, + "cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha1-4wOogrNCzD7oylE6eZmXNNqzriw=" + }, + "cookiejar": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.2.tgz", + "integrity": "sha512-Mw+adcfzPxcPeI+0WlvRrr/3lGVO0bD75SxX6811cxSh1Wbxx7xZBGK1eVtDf6si8rg2lhnUjsVLMFMfbRIuwA==" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "cors": { + "version": "2.8.4", + "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.4.tgz", + "integrity": "sha1-K9OB8usgECAQXNUOpZ2mMJBpRoY=", + "requires": { + "object-assign": "^4", + "vary": "^1" + } + }, + "create-ecdh": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz", + "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==", + "requires": { + "bn.js": "^4.1.0", + "elliptic": "^6.0.0" + } + }, + "create-hash": { + "version": "1.2.0", + "resolved": "http://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz", + "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==", + "requires": { + "cipher-base": "^1.0.1", + "inherits": "^2.0.1", + "md5.js": "^1.3.4", + "ripemd160": "^2.0.1", + "sha.js": "^2.4.0" + } + }, + "create-hmac": { + "version": "1.1.7", + "resolved": "http://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz", + "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==", + "requires": { + "cipher-base": "^1.0.3", + "create-hash": "^1.1.0", + "inherits": "^2.0.1", + "ripemd160": "^2.0.0", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "cron-parser": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/cron-parser/-/cron-parser-2.6.0.tgz", + "integrity": "sha512-KGfDDTjBIx85MnVYcdhLccoJH/7jcYW+5Z/t3Wsg2QlJhmmjf+97z+9sQftS71lopOYYapjEKEvmWaCsym5Z4g==", + "requires": { + "is-nan": "^1.2.1", + "moment-timezone": "^0.5.0" + } + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "requires": { + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" + } + }, + "crypto-js": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/crypto-js/-/crypto-js-3.1.8.tgz", + "integrity": "sha1-cV8HC/YBTyrpkqmLOSkli3E/CNU=" + }, + "crypto-random-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-1.0.0.tgz", + "integrity": "sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=" + }, + "csextends": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/csextends/-/csextends-1.2.0.tgz", + "integrity": "sha512-S/8k1bDTJIwuGgQYmsRoE+8P+ohV32WhQ0l4zqrc0XDdxOhjQQD7/wTZwCzoZX53jSX3V/qwjT+OkPTxWQcmjg==" + }, + "cycle": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cycle/-/cycle-1.0.3.tgz", + "integrity": "sha1-IegLK+hYD5i0aPN5QwZisEbDStI=" + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "requires": { + "ms": "2.0.0" + } + }, + "decode-uri-component": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/decode-uri-component/-/decode-uri-component-0.2.0.tgz", + "integrity": "sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU=" + }, + "decompress": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/decompress/-/decompress-4.2.0.tgz", + "integrity": "sha1-eu3YVCflqS2s/lVnSnxQXpbQH50=", + "requires": { + "decompress-tar": "^4.0.0", + "decompress-tarbz2": "^4.0.0", + "decompress-targz": "^4.0.0", + "decompress-unzip": "^4.0.1", + "graceful-fs": "^4.1.10", + "make-dir": "^1.0.0", + "pify": "^2.3.0", + "strip-dirs": "^2.0.0" + } + }, + "decompress-response": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-3.3.0.tgz", + "integrity": "sha1-gKTdMjdIOEv6JICDYirt7Jgq3/M=", + "requires": { + "mimic-response": "^1.0.0" + } + }, + "decompress-tar": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tar/-/decompress-tar-4.1.1.tgz", + "integrity": "sha512-JdJMaCrGpB5fESVyxwpCx4Jdj2AagLmv3y58Qy4GE6HMVjWz1FeVQk1Ct4Kye7PftcdOo/7U7UKzYBJgqnGeUQ==", + "requires": { + "file-type": "^5.2.0", + "is-stream": "^1.1.0", + "tar-stream": "^1.5.2" + } + }, + "decompress-tarbz2": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-tarbz2/-/decompress-tarbz2-4.1.1.tgz", + "integrity": "sha512-s88xLzf1r81ICXLAVQVzaN6ZmX4A6U4z2nMbOwobxkLoIIfjVMBg7TeguTUXkKeXni795B6y5rnvDw7rxhAq9A==", + "requires": { + "decompress-tar": "^4.1.0", + "file-type": "^6.1.0", + "is-stream": "^1.1.0", + "seek-bzip": "^1.0.5", + "unbzip2-stream": "^1.0.9" + }, + "dependencies": { + "file-type": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-6.2.0.tgz", + "integrity": "sha512-YPcTBDV+2Tm0VqjybVd32MHdlEGAtuxS3VAYsumFokDSMG+ROT5wawGlnHDoz7bfMcMDt9hxuXvXwoKUx2fkOg==" + } + } + }, + "decompress-targz": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/decompress-targz/-/decompress-targz-4.1.1.tgz", + "integrity": "sha512-4z81Znfr6chWnRDNfFNqLwPvm4db3WuZkqV+UgXQzSngG3CEKdBkw5jrv3axjjL96glyiiKjsxJG3X6WBZwX3w==", + "requires": { + "decompress-tar": "^4.1.1", + "file-type": "^5.2.0", + "is-stream": "^1.1.0" + } + }, + "decompress-unzip": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/decompress-unzip/-/decompress-unzip-4.0.1.tgz", + "integrity": "sha1-3qrM39FK6vhVePczroIQ+bSEj2k=", + "requires": { + "file-type": "^3.8.0", + "get-stream": "^2.2.0", + "pify": "^2.3.0", + "yauzl": "^2.4.2" + }, + "dependencies": { + "file-type": { + "version": "3.9.0", + "resolved": "http://registry.npmjs.org/file-type/-/file-type-3.9.0.tgz", + "integrity": "sha1-JXoHg4TR24CHvESdEH1SpSZyuek=" + }, + "get-stream": { + "version": "2.3.1", + "resolved": "http://registry.npmjs.org/get-stream/-/get-stream-2.3.1.tgz", + "integrity": "sha1-Xzj5PzRgCWZu4BUKBUFn+Rvdld4=", + "requires": { + "object-assign": "^4.0.1", + "pinkie-promise": "^2.0.0" + } + } + } + }, + "define-properties": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz", + "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==", + "requires": { + "object-keys": "^1.0.12" + } + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "delimit-stream": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/delimit-stream/-/delimit-stream-0.1.0.tgz", + "integrity": "sha1-m4MZR3wOX4rrPONXrjBfwl6hzSs=" + }, + "depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha1-m81S4UwJd2PnSbJ0xDRu0uVgtak=" + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "requires": { + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0" + } + }, + "destroy": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.0.4.tgz", + "integrity": "sha1-l4hXRCxEdJ5CBmE+N5RiBYJqvYA=" + }, + "diffie-hellman": { + "version": "5.0.3", + "resolved": "http://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz", + "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==", + "requires": { + "bn.js": "^4.1.0", + "miller-rabin": "^4.0.0", + "randombytes": "^2.0.0" + } + }, + "dom-walk": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.1.tgz", + "integrity": "sha1-ZyIm3HTI95mtNTB9+TaroRrNYBg=" + }, + "drbg.js": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/drbg.js/-/drbg.js-1.0.1.tgz", + "integrity": "sha1-Pja2xCs3BDgjzbwzLVjzHiRFSAs=", + "requires": { + "browserify-aes": "^1.0.6", + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4" + } + }, + "duplexer3": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer3/-/duplexer3-0.1.4.tgz", + "integrity": "sha1-7gHdHKwO08vH/b6jfcCo8c4ALOI=" + }, + "eachr": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/eachr/-/eachr-2.0.4.tgz", + "integrity": "sha1-Rm98qhBwj2EFCeMsgHqv5X/BIr8=", + "requires": { + "typechecker": "^2.0.8" + } + }, + "ecc-jsbn": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", + "integrity": "sha1-OoOpBOVDUyh4dMVkt1SThoSamMk=", + "requires": { + "jsbn": "~0.1.0", + "safer-buffer": "^2.1.0" + } + }, + "editions": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/editions/-/editions-1.3.4.tgz", + "integrity": "sha512-gzao+mxnYDzIysXKMQi/+M1mjy/rjestjg6OPoYTtI+3Izp23oiGZitsl9lPDPiTGXbcSIk1iJWhliSaglxnUg==" + }, + "ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha1-WQxhFWsK4vTwJVcyoViyZrxWsh0=" + }, + "elliptic": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz", + "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==", + "requires": { + "bn.js": "^4.4.0", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "hmac-drbg": "^1.0.0", + "inherits": "^2.0.1", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.0" + } + }, + "encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha1-rT/0yG7C0CkyL1oCw6mmBslbP1k=" + }, + "end-of-stream": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz", + "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", + "requires": { + "once": "^1.4.0" + } + }, + "errlop": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/errlop/-/errlop-1.0.3.tgz", + "integrity": "sha512-5VTnt0yikY4LlQEfCXVSqfE6oLj1HVM4zVSvAKMnoYjL/zrb6nqiLowZS4XlG7xENfyj7lpYWvT+wfSCr6dtlA==", + "requires": { + "editions": "^1.3.4" + } + }, + "escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha1-Aljq5NPQwJdN4cFpGI7wBR0dGYg=" + }, + "etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha1-Qa4u62XvpiJorr/qg6x9eSmbCIc=" + }, + "eth-lib": { + "version": "0.1.27", + "resolved": "https://registry.npmjs.org/eth-lib/-/eth-lib-0.1.27.tgz", + "integrity": "sha512-B8czsfkJYzn2UIEMwjc7Mbj+Cy72V+/OXH/tb44LV8jhrjizQJJ325xMOMyk3+ETa6r6oi0jsUY14+om8mQMWA==", + "requires": { + "bn.js": "^4.11.6", + "elliptic": "^6.4.0", + "keccakjs": "^0.2.1", + "nano-json-stream-parser": "^0.1.2", + "servify": "^0.1.12", + "ws": "^3.0.0", + "xhr-request-promise": "^0.1.2" + } + }, + "eth-lightwallet": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/eth-lightwallet/-/eth-lightwallet-3.0.1.tgz", + "integrity": "sha512-79vVCETy+4l1b6wuOWwjqPW3Bom5ZK46BgkUNwaXhiMG1rrMRHjpjYEWMqH0JHeCzOzB4HBIFz7eK1/4s6w5nA==", + "requires": { + "bitcore-lib": "^0.15.0", + "bitcore-mnemonic": "^1.5.0", + "buffer": "^4.9.0", + "crypto-js": "^3.1.5", + "elliptic": "^3.1.0", + "ethereumjs-tx": "^1.3.3", + "ethereumjs-util": "^5.1.1", + "rlp": "^2.0.0", + "scrypt-async": "^1.2.0", + "tweetnacl": "0.13.2", + "web3": "0.20.2" + }, + "dependencies": { + "bignumber.js": { + "version": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "from": "git+https://github.com/frozeman/bignumber.js-nolookahead.git" + }, + "bn.js": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-2.2.0.tgz", + "integrity": "sha1-EhYrwq5x/EClYmwzQ486h1zTdiU=" + }, + "buffer": { + "version": "4.9.1", + "resolved": "http://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "requires": { + "base64-js": "^1.0.2", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + }, + "elliptic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-3.1.0.tgz", + "integrity": "sha1-whaC73YnabVqdCAWCRBdoR1fYMw=", + "requires": { + "bn.js": "^2.0.3", + "brorand": "^1.0.1", + "hash.js": "^1.0.0", + "inherits": "^2.0.1" + } + }, + "tweetnacl": { + "version": "0.13.2", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.13.2.tgz", + "integrity": "sha1-RTFhdwRp1FzSZsNkBOK8maj6mUQ=" + }, + "web3": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/web3/-/web3-0.20.2.tgz", + "integrity": "sha1-xU2sX8DjdzmcBMGm7LsS5FEyeNY=", + "requires": { + "bignumber.js": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "crypto-js": "^3.1.4", + "utf8": "^2.1.1", + "xhr2": "*", + "xmlhttprequest": "*" + } + } + } + }, + "ethereum-bridge": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/ethereum-bridge/-/ethereum-bridge-0.6.1.tgz", + "integrity": "sha512-yDTivI85618BoLI71yNRzW6iVcVN2rjnviCIzs0QOCOENj4XpYQhMDGhdqDi8XWDdzTd0Ja/Canuuh3vfE2IcA==", + "requires": { + "async": "^2.4.1", + "borc": "^2.0.2", + "caminte": "0.3.7", + "colors": "^1.1.2", + "compare-versions": "^3.0.1", + "crypto-random-string": "^1.0.0", + "eth-lightwallet": "^3.0.1", + "ethereumjs-abi": "0.6.4", + "ethereumjs-tx": "^1.3.1", + "ethereumjs-util": "^5.2.0", + "i18n": "^0.8.3", + "moment": "^2.22.2", + "multihashes": "^0.4.5", + "node-async-loop": "^1.2.2", + "node-cache": "^4.1.1", + "node-schedule": "^1.2.3", + "pragma-singleton": "1.0.3", + "request": "^2.81.0", + "semver": "^5.5.0", + "stdio": "^0.2.7", + "tingodb": "^0.6.1", + "underscore": "^1.8.3", + "utf8": "^2.1.2", + "web3": "0.19.1", + "winston": "^2.3.1" + }, + "dependencies": { + "bignumber.js": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-4.1.0.tgz", + "integrity": "sha512-eJzYkFYy9L4JzXsbymsFn3p54D+llV27oTQ+ziJG7WFRheJcNZilgVXMG0LoZtlQSKBsJdWtLFqOD0u+U0jZKA==" + }, + "utf8": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-2.1.2.tgz", + "integrity": "sha1-H6DZJw6b6FDZsFAn9jUZv0ZFfZY=" + }, + "web3": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/web3/-/web3-0.19.1.tgz", + "integrity": "sha1-52PVsRB8S8JKvU+MvuG6Nlnm6zE=", + "requires": { + "bignumber.js": "^4.0.2", + "crypto-js": "^3.1.4", + "utf8": "^2.1.1", + "xhr2": "*", + "xmlhttprequest": "*" + } + } + } + }, + "ethereum-common": { + "version": "0.0.18", + "resolved": "https://registry.npmjs.org/ethereum-common/-/ethereum-common-0.0.18.tgz", + "integrity": "sha1-L9w1dvIykDNYl26znaeDIT/5Uj8=" + }, + "ethereumjs-abi": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.4.tgz", + "integrity": "sha1-m6G7BWSS0AwnJ59uzNTVgnWRLBo=", + "requires": { + "bn.js": "^4.10.0", + "ethereumjs-util": "^4.3.0" + }, + "dependencies": { + "ethereumjs-util": { + "version": "4.5.0", + "resolved": "http://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-4.5.0.tgz", + "integrity": "sha1-PpQosxfuvaPXJg2FT93alUsfG8Y=", + "requires": { + "bn.js": "^4.8.0", + "create-hash": "^1.1.2", + "keccakjs": "^0.2.0", + "rlp": "^2.0.0", + "secp256k1": "^3.0.1" + } + } + } + }, + "ethereumjs-tx": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/ethereumjs-tx/-/ethereumjs-tx-1.3.7.tgz", + "integrity": "sha512-wvLMxzt1RPhAQ9Yi3/HKZTn0FZYpnsmQdbKYfUUpi4j1SEIcbkd9tndVjcPrufY3V7j2IebOpC00Zp2P/Ay2kA==", + "requires": { + "ethereum-common": "^0.0.18", + "ethereumjs-util": "^5.0.0" + } + }, + "ethereumjs-util": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ethereumjs-util/-/ethereumjs-util-5.2.0.tgz", + "integrity": "sha512-CJAKdI0wgMbQFLlLRtZKGcy/L6pzVRgelIZqRqNbuVFM3K9VEnyfbcvz0ncWMRNCe4kaHWjwRYQcYMucmwsnWA==", + "requires": { + "bn.js": "^4.11.0", + "create-hash": "^1.1.2", + "ethjs-util": "^0.1.3", + "keccak": "^1.0.2", + "rlp": "^2.0.0", + "safe-buffer": "^5.1.1", + "secp256k1": "^3.0.1" + } + }, + "ethjs-unit": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-unit/-/ethjs-unit-0.1.6.tgz", + "integrity": "sha1-xmWSHkduh7ziqdWIpv4EBbLEFpk=", + "requires": { + "bn.js": "4.11.6", + "number-to-bn": "1.7.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "ethjs-util": { + "version": "0.1.6", + "resolved": "https://registry.npmjs.org/ethjs-util/-/ethjs-util-0.1.6.tgz", + "integrity": "sha512-CUnVOQq7gSpDHZVVrQW8ExxUETWrnrvXYvYz55wOU8Uj4VCgw56XC2B/fVqQN+f7gmrnRHSLVnFAwsCuNwji8w==", + "requires": { + "is-hex-prefixed": "1.0.0", + "strip-hex-prefix": "1.0.0" + } + }, + "eventemitter3": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-1.1.1.tgz", + "integrity": "sha1-R3hr2qCHyvext15zq8XH1UAVjNA=" + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "requires": { + "md5.js": "^1.3.4", + "safe-buffer": "^5.1.1" + } + }, + "express": { + "version": "4.16.4", + "resolved": "https://registry.npmjs.org/express/-/express-4.16.4.tgz", + "integrity": "sha512-j12Uuyb4FMrd/qQAm6uCHAkPtO8FDTRJZBDd5D2KOL2eLaz1yUNdUB/NOIyq0iU4q4cFarsUCrnFDPBcnksuOg==", + "requires": { + "accepts": "~1.3.5", + "array-flatten": "1.1.1", + "body-parser": "1.18.3", + "content-disposition": "0.5.2", + "content-type": "~1.0.4", + "cookie": "0.3.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "~1.1.2", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.1.1", + "fresh": "0.5.2", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.4", + "qs": "6.5.2", + "range-parser": "~1.2.0", + "safe-buffer": "5.1.2", + "send": "0.16.2", + "serve-static": "1.13.2", + "setprototypeof": "1.1.0", + "statuses": "~1.4.0", + "type-is": "~1.6.16", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "dependencies": { + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==" + }, + "extendr": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/extendr/-/extendr-2.1.0.tgz", + "integrity": "sha1-MBqgu+pWX00tyPVw8qImEahSe1Y=", + "requires": { + "typechecker": "~2.0.1" + }, + "dependencies": { + "typechecker": { + "version": "2.0.8", + "resolved": "http://registry.npmjs.org/typechecker/-/typechecker-2.0.8.tgz", + "integrity": "sha1-6D2oS7ZMWEzLNFg4V2xAsDN9uC4=" + } + } + }, + "extract-opts": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/extract-opts/-/extract-opts-2.2.0.tgz", + "integrity": "sha1-H6KOunNSxttID4hc63GkaBC+bX0=", + "requires": { + "typechecker": "~2.0.1" + }, + "dependencies": { + "typechecker": { + "version": "2.0.8", + "resolved": "http://registry.npmjs.org/typechecker/-/typechecker-2.0.8.tgz", + "integrity": "sha1-6D2oS7ZMWEzLNFg4V2xAsDN9uC4=" + } + } + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "eyes": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/eyes/-/eyes-0.1.8.tgz", + "integrity": "sha1-Ys8SAjTGg3hdkCNIqADvPgzCC8A=" + }, + "fast-deep-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", + "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=" + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=" + }, + "fd-slicer": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz", + "integrity": "sha1-JcfInLH5B3+IkbvmHY85Dq4lbx4=", + "requires": { + "pend": "~1.2.0" + } + }, + "file-type": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/file-type/-/file-type-5.2.0.tgz", + "integrity": "sha1-LdvqfHP/42No365J3DOMBYwritY=" + }, + "finalhandler": { + "version": "1.1.1", + "resolved": "http://registry.npmjs.org/finalhandler/-/finalhandler-1.1.1.tgz", + "integrity": "sha512-Y1GUDo39ez4aHAw7MysnUD5JzYX+WaIj8I57kO3aEPT1fFRL4sr7mjei97FgnwhAyyzRYmQZaTHb2+9uZ1dPtg==", + "requires": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "~2.3.0", + "parseurl": "~1.3.2", + "statuses": "~1.4.0", + "unpipe": "~1.0.0" + }, + "dependencies": { + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "requires": { + "is-callable": "^1.1.3" + } + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=" + }, + "form-data": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", + "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", + "requires": { + "asynckit": "^0.4.0", + "combined-stream": "1.0.6", + "mime-types": "^2.1.12" + }, + "dependencies": { + "combined-stream": { + "version": "1.0.6", + "resolved": "http://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", + "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", + "requires": { + "delayed-stream": "~1.0.0" + } + } + } + }, + "forwarded": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.1.2.tgz", + "integrity": "sha1-mMI9qxF1ZXuMBXPozszZGw/xjIQ=" + }, + "fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha1-PYyt2Q2XZWn6g1qx+OSyOhBWBac=" + }, + "fs-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs-constants/-/fs-constants-1.0.0.tgz", + "integrity": "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==" + }, + "fs-extra": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-2.1.2.tgz", + "integrity": "sha1-BGxwFjzvmq1GsOSn+kZ/si1x3jU=", + "requires": { + "graceful-fs": "^4.1.2", + "jsonfile": "^2.1.0" + } + }, + "fs-promise": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/fs-promise/-/fs-promise-2.0.3.tgz", + "integrity": "sha1-9k5PhUvPaJqovdy6JokW2z20aFQ=", + "requires": { + "any-promise": "^1.3.0", + "fs-extra": "^2.0.0", + "mz": "^2.6.0", + "thenify-all": "^1.6.0" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fstream": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz", + "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=", + "requires": { + "graceful-fs": "^4.1.2", + "inherits": "~2.0.0", + "mkdirp": ">=0.5 0", + "rimraf": "2" + } + }, + "get-stream": { + "version": "3.0.0", + "resolved": "http://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=" + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "requires": { + "assert-plus": "^1.0.0" + } + }, + "glob": { + "version": "7.1.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.3.tgz", + "integrity": "sha512-vcfuiIxogLV4DlGBHIUOwI0IbrJ8HWPc4MU7HzviGeNho/UJDfi6B5p3sHeWIQ0KGIU0Jpxi5ZHxemQfLkkAwQ==", + "requires": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.0.4", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + }, + "global": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/global/-/global-4.3.2.tgz", + "integrity": "sha1-52mJJopsdMOJCLEwWxD8DjlOnQ8=", + "requires": { + "min-document": "^2.19.0", + "process": "~0.5.1" + } + }, + "got": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/got/-/got-7.1.0.tgz", + "integrity": "sha512-Y5WMo7xKKq1muPsxD+KmrR8DH5auG7fBdDVueZwETwV6VytKyU9OX/ddpq2/1hp1vIPvVb4T81dKQz3BivkNLw==", + "requires": { + "decompress-response": "^3.2.0", + "duplexer3": "^0.1.4", + "get-stream": "^3.0.0", + "is-plain-obj": "^1.1.0", + "is-retry-allowed": "^1.0.0", + "is-stream": "^1.0.0", + "isurl": "^1.0.0-alpha5", + "lowercase-keys": "^1.0.0", + "p-cancelable": "^0.3.0", + "p-timeout": "^1.1.1", + "safe-buffer": "^5.0.1", + "timed-out": "^4.0.0", + "url-parse-lax": "^1.0.0", + "url-to-options": "^1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "graceful-readlink": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/graceful-readlink/-/graceful-readlink-1.0.1.tgz", + "integrity": "sha1-TK+tdrxi8C+gObL5Tpo906ORpyU=" + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=" + }, + "har-validator": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.0.tgz", + "integrity": "sha512-+qnmNjI4OfH2ipQ9VQOw23bBd/ibtfbVdK2fYbY4acTDqKTW/YDp9McimZdDbG8iV9fZizUqQMD5xvriB146TA==", + "requires": { + "ajv": "^5.3.0", + "har-schema": "^2.0.0" + } + }, + "has-symbol-support-x": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/has-symbol-support-x/-/has-symbol-support-x-1.4.2.tgz", + "integrity": "sha512-3ToOva++HaW+eCpgqZrCfN51IPB+7bJNVT6CUATzueB5Heb8o6Nam0V3HG5dlDvZU1Gn5QLcbahiKw/XVk5JJw==" + }, + "has-to-string-tag-x": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/has-to-string-tag-x/-/has-to-string-tag-x-1.4.1.tgz", + "integrity": "sha512-vdbKfmw+3LoOYVr+mtxHaX5a96+0f3DljYd8JOqvOLsf5mw2Otda2qCDT9qRqLAhrjyQ0h7ual5nOiASpsGNFw==", + "requires": { + "has-symbol-support-x": "^1.4.1" + } + }, + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "hash.js": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.5.tgz", + "integrity": "sha512-eWI5HG9Np+eHV1KQhisXWwM+4EPPYe5dFX1UZZH7k/E3JzDEazVH+VGlZi6R94ZqImq+A3D1mCEtrFIfg/E7sA==", + "requires": { + "inherits": "^2.0.3", + "minimalistic-assert": "^1.0.1" + } + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "requires": { + "hash.js": "^1.0.3", + "minimalistic-assert": "^1.0.0", + "minimalistic-crypto-utils": "^1.0.1" + } + }, + "http-errors": { + "version": "1.6.3", + "resolved": "http://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", + "integrity": "sha1-i1VoC7S+KDoLW/TqLjhYC+HZMg0=", + "requires": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": ">= 1.4.0 < 2" + } + }, + "http-https": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/http-https/-/http-https-1.0.0.tgz", + "integrity": "sha1-L5CN1fHbQGjAWM1ubUzjkskTOJs=" + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "requires": { + "assert-plus": "^1.0.0", + "jsprim": "^1.2.2", + "sshpk": "^1.7.0" + } + }, + "i18n": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/i18n/-/i18n-0.8.3.tgz", + "integrity": "sha1-LYzxwkciYCwgQdAbpq5eqlE4jw4=", + "requires": { + "debug": "*", + "make-plural": "^3.0.3", + "math-interval-parser": "^1.1.0", + "messageformat": "^0.3.1", + "mustache": "*", + "sprintf-js": ">=1.0.3" + } + }, + "iconv-lite": { + "version": "0.4.23", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.23.tgz", + "integrity": "sha512-neyTUVFtahjf0mB3dZT77u+8O0QB89jFdnBkd5P1JgYPbPaia3gXXOVL2fq8VyU2gMMD7SaN7QukTB/pmXYvDA==", + "requires": { + "safer-buffer": ">= 2.1.2 < 3" + } + }, + "ieee754": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz", + "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==" + }, + "ignorefs": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/ignorefs/-/ignorefs-1.2.0.tgz", + "integrity": "sha1-2ln7hYl25KXkNwLM0fKC/byeV1Y=", + "requires": { + "editions": "^1.3.3", + "ignorepatterns": "^1.1.0" + } + }, + "ignorepatterns": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ignorepatterns/-/ignorepatterns-1.1.0.tgz", + "integrity": "sha1-rI9DbyI5td+2bV8NOpBKh6xnzF4=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "ipaddr.js": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.8.0.tgz", + "integrity": "sha1-6qM9bd16zo9/b+DJygRA5wZzix4=" + }, + "is-callable": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.4.tgz", + "integrity": "sha512-r5p9sxJjYnArLjObpjA4xu5EKI3CuKHkJXMhT7kwbpUyIFD1n5PMAsoPvWnvtZiNz7LjkYDRZhd7FlI0eMijEA==" + }, + "is-function": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-function/-/is-function-1.0.1.tgz", + "integrity": "sha1-Es+5i2W1fdPRk6MSH19uL0N2ArU=" + }, + "is-hex-prefixed": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-hex-prefixed/-/is-hex-prefixed-1.0.0.tgz", + "integrity": "sha1-fY035q135dEnFIkTxXPggtd39VQ=" + }, + "is-nan": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-nan/-/is-nan-1.2.1.tgz", + "integrity": "sha1-n69ltvttskt/XAYoR16nH5iEAeI=", + "requires": { + "define-properties": "^1.1.1" + } + }, + "is-natural-number": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/is-natural-number/-/is-natural-number-4.0.1.tgz", + "integrity": "sha1-q5124dtM7VHjXeDHLr7PCfc0zeg=" + }, + "is-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-object/-/is-object-1.0.1.tgz", + "integrity": "sha1-iVJojF7C/9awPsyF52ngKQMINHA=" + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=" + }, + "is-retry-allowed": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-retry-allowed/-/is-retry-allowed-1.1.0.tgz", + "integrity": "sha1-EaBgVotnM5REAz0BJaYaINVk+zQ=" + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=" + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=" + }, + "isurl": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isurl/-/isurl-1.0.0.tgz", + "integrity": "sha512-1P/yWsxPlDtn7QeRD+ULKQPaIaN6yF368GZ2vDfv0AL0NwpStafjWCDDdn0k8wgFMWpVAqG7oJhxHnlud42i9w==", + "requires": { + "has-to-string-tag-x": "^1.2.0", + "is-object": "^1.0.1" + } + }, + "js-sha3": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/js-sha3/-/js-sha3-0.3.1.tgz", + "integrity": "sha1-hhIoAhQvCChQKg0d7h2V4lO7AkM=" + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=" + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=" + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=" + }, + "json-text-sequence": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/json-text-sequence/-/json-text-sequence-0.1.1.tgz", + "integrity": "sha1-py8hfcSvxGKf/1/rME3BvVGi89I=", + "requires": { + "delimit-stream": "0.1.0" + } + }, + "jsonfile": { + "version": "2.4.0", + "resolved": "http://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", + "integrity": "sha1-NzaitCi4e72gzIO1P6PWM6NcKug=", + "requires": { + "graceful-fs": "^4.1.6" + } + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "keccak": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/keccak/-/keccak-1.4.0.tgz", + "integrity": "sha512-eZVaCpblK5formjPjeTBik7TAg+pqnDrMHIffSvi9Lh7PQgM1+hSzakUeZFCk9DVVG0dacZJuaz2ntwlzZUIBw==", + "requires": { + "bindings": "^1.2.1", + "inherits": "^2.0.3", + "nan": "^2.2.1", + "safe-buffer": "^5.1.0" + } + }, + "keccakjs": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/keccakjs/-/keccakjs-0.2.1.tgz", + "integrity": "sha1-HWM6+QfvMFu/ny+mFtVsRFYd+k0=", + "requires": { + "browserify-sha3": "^0.0.1", + "sha3": "^1.1.0" + } + }, + "lodash": { + "version": "4.17.11", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz", + "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==" + }, + "long-timeout": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/long-timeout/-/long-timeout-0.1.1.tgz", + "integrity": "sha1-lyHXiLR+C8taJMLivuGg2lXatRQ=" + }, + "lowercase-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-1.0.1.tgz", + "integrity": "sha512-G2Lj61tXDnVFFOi8VZds+SoQjtQC3dgokKdDG2mTm1tx4m50NUHBOZSBwQQHyy0V12A0JTG4icfZQH+xPyh8VA==" + }, + "make-dir": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-1.3.0.tgz", + "integrity": "sha512-2w31R7SJtieJJnQtGc7RVL2StM2vGYVfqUOvUDxH6bC6aJTxPxTF0GnIgCyu7tjockiUWAYQRbxa7vKn34s5sQ==", + "requires": { + "pify": "^3.0.0" + }, + "dependencies": { + "pify": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-3.0.0.tgz", + "integrity": "sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY=" + } + } + }, + "make-plural": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/make-plural/-/make-plural-3.0.6.tgz", + "integrity": "sha1-IDOgO6wpC487uRJY9lud9+iwHKc=", + "requires": { + "minimist": "^1.2.0" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "optional": true + } + } + }, + "math-interval-parser": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-interval-parser/-/math-interval-parser-1.1.0.tgz", + "integrity": "sha1-2+2lsGsySZc8bfYXD94jhvCv2JM=", + "requires": { + "xregexp": "^2.0.0" + } + }, + "md5.js": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz", + "integrity": "sha512-xitP+WxNPcTTOgnTJcrhM0xvdPepipPSf3I8EIpGKeFLjt3PlJLIDG3u8EX53ZIubkb+5U2+3rELYpEhHhzdkg==", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha1-hxDXrwqmJvj/+hzgAWhUUmMlV0g=" + }, + "merge-descriptors": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.1.tgz", + "integrity": "sha1-sAqqVW3YtEVoFQ7J0blT8/kMu2E=" + }, + "messageformat": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/messageformat/-/messageformat-0.3.1.tgz", + "integrity": "sha1-5Y//gkXps5cXmeW0PbWLPpQX9aI=", + "requires": { + "async": "~1.5.2", + "glob": "~6.0.4", + "make-plural": "~3.0.3", + "nopt": "~3.0.6", + "watchr": "~2.4.13" + }, + "dependencies": { + "async": { + "version": "1.5.2", + "resolved": "http://registry.npmjs.org/async/-/async-1.5.2.tgz", + "integrity": "sha1-7GphrlZIDAw8skHJVhjiCJL5Zyo=" + }, + "glob": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/glob/-/glob-6.0.4.tgz", + "integrity": "sha1-DwiGD2oVUSey+t1PnOJLGqtuTSI=", + "requires": { + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "2 || 3", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + } + } + } + }, + "methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha1-VSmk1nZUE07cxSZmVoNbD4Ua/O4=" + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "requires": { + "bn.js": "^4.0.0", + "brorand": "^1.0.1" + } + }, + "mime": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz", + "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ==" + }, + "mime-db": { + "version": "1.36.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.36.0.tgz", + "integrity": "sha512-L+xvyD9MkoYMXb1jAmzI/lWYAxAMCPvIBSWur0PZ5nOf5euahRLVqH//FKW9mWp2lkqUgYiXPgkzfMUFi4zVDw==" + }, + "mime-types": { + "version": "2.1.20", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.20.tgz", + "integrity": "sha512-HrkrPaP9vGuWbLK1B1FfgAkbqNjIuy4eHlIYnFi7kamZyLLrGlo2mpcx0bBmNpKqBtYtAfGbodDddIgddSJC2A==", + "requires": { + "mime-db": "~1.36.0" + } + }, + "mimic-response": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz", + "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==" + }, + "min-document": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/min-document/-/min-document-2.19.0.tgz", + "integrity": "sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU=", + "requires": { + "dom-walk": "^0.1.0" + } + }, + "minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==" + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "^1.1.7" + } + }, + "minimist": { + "version": "0.0.8", + "resolved": "http://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "http://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "requires": { + "minimist": "0.0.8" + } + }, + "mkdirp-promise": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/mkdirp-promise/-/mkdirp-promise-5.0.1.tgz", + "integrity": "sha1-6bj2jlUsaKnBcTuEiD96HdA5uKE=", + "requires": { + "mkdirp": "*" + } + }, + "mock-fs": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/mock-fs/-/mock-fs-4.7.0.tgz", + "integrity": "sha512-WlQNtUlzMRpvLHf8dqeUmNqfdPjGY29KrJF50Ldb4AcL+vQeR8QH3wQcFMgrhTwb1gHjZn9xggho+84tBskLgA==" + }, + "moment": { + "version": "2.22.2", + "resolved": "https://registry.npmjs.org/moment/-/moment-2.22.2.tgz", + "integrity": "sha1-PCV/mDn8DpP/UxSWMiOeuQeD/2Y=" + }, + "moment-timezone": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/moment-timezone/-/moment-timezone-0.5.21.tgz", + "integrity": "sha512-j96bAh4otsgj3lKydm3K7kdtA3iKf2m6MY2iSYCzCm5a1zmHo1g+aK3068dDEeocLZQIS9kU8bsdQHLqEvgW0A==", + "requires": { + "moment": ">= 2.9.0" + } + }, + "mout": { + "version": "0.11.1", + "resolved": "https://registry.npmjs.org/mout/-/mout-0.11.1.tgz", + "integrity": "sha1-ujYR318OWx/7/QEWa48C0fX6K5k=" + }, + "ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=" + }, + "multihashes": { + "version": "0.4.14", + "resolved": "https://registry.npmjs.org/multihashes/-/multihashes-0.4.14.tgz", + "integrity": "sha512-V/g/EIN6nALXfS/xHUAgtfPP3mn3sPIF/i9beuGKf25QXS2QZYCpeVJbDPEannkz32B2fihzCe2D/KMrbcmefg==", + "requires": { + "bs58": "^4.0.1", + "varint": "^5.0.0" + } + }, + "mustache": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mustache/-/mustache-3.0.0.tgz", + "integrity": "sha512-bhBDkK/PioIbtQzRIbGUGypvc3MC4c389QnJt8KDIEJ666OidRPoXAQAHPivikfS3JkMEaWoPvcDL7YrQxtSwg==" + }, + "mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "requires": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "nan": { + "version": "2.10.0", + "resolved": "http://registry.npmjs.org/nan/-/nan-2.10.0.tgz", + "integrity": "sha512-bAdJv7fBLhWC+/Bls0Oza+mvTaNQtP+1RyhhhvD95pgUJz6XM5IzgmxOkItJ9tkoCiplvAnXI1tNmmUD/eScyA==" + }, + "nano-json-stream-parser": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/nano-json-stream-parser/-/nano-json-stream-parser-0.1.2.tgz", + "integrity": "sha1-DMj20OK2IrR5xA1JnEbWS3Vcb18=" + }, + "negotiator": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.1.tgz", + "integrity": "sha1-KzJxhOiZIQEXeyhWP7XnECrNDKk=" + }, + "node-async-loop": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/node-async-loop/-/node-async-loop-1.2.2.tgz", + "integrity": "sha1-xYcCmb9kd7eAyItDGqWzdzP1Wj0=" + }, + "node-cache": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/node-cache/-/node-cache-4.2.0.tgz", + "integrity": "sha512-obRu6/f7S024ysheAjoYFEEBqqDWv4LOMNJEuO8vMeEw2AT4z+NCzO4hlc2lhI4vATzbCQv6kke9FVdx0RbCOw==", + "requires": { + "clone": "2.x", + "lodash": "4.x" + } + }, + "node-schedule": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/node-schedule/-/node-schedule-1.3.0.tgz", + "integrity": "sha512-NNwO9SUPjBwFmPh3vXiPVEhJLn4uqYmZYvJV358SRGM06BR4UoIqxJpeJwDDXB6atULsgQA97MfD1zMd5xsu+A==", + "requires": { + "cron-parser": "^2.4.0", + "long-timeout": "0.1.1", + "sorted-array-functions": "^1.0.0" + } + }, + "nopt": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/nopt/-/nopt-3.0.6.tgz", + "integrity": "sha1-xkZdvwirzU2zWTF/eaxopkayj/k=", + "requires": { + "abbrev": "1" + } + }, + "number-to-bn": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz", + "integrity": "sha1-uzYjWS9+X54AMLGXe9QaDFP+HqA=", + "requires": { + "bn.js": "4.11.6", + "strip-hex-prefix": "1.0.0" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "oauth-sign": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.9.0.tgz", + "integrity": "sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ==" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-keys": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", + "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==" + }, + "oboe": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/oboe/-/oboe-2.1.3.tgz", + "integrity": "sha1-K0hl29Rr6BIlcT9Om/5Lz09oCk8=", + "requires": { + "http-https": "^1.0.0" + } + }, + "on-finished": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.3.0.tgz", + "integrity": "sha1-IPEzZIGwg811M3mSoWlxqi2QaUc=", + "requires": { + "ee-first": "1.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1" + } + }, + "p-cancelable": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-0.3.0.tgz", + "integrity": "sha512-RVbZPLso8+jFeq1MfNvgXtCRED2raz/dKpacfTNxsx6pLEpEomM7gah6VeHSYV3+vo0OAi4MkArtQcWWXuQoyw==" + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=" + }, + "p-timeout": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/p-timeout/-/p-timeout-1.2.1.tgz", + "integrity": "sha1-XrOzU7f86Z8QGhA4iAuwVOu+o4Y=", + "requires": { + "p-finally": "^1.0.0" + } + }, + "parse-asn1": { + "version": "5.1.1", + "resolved": "http://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz", + "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==", + "requires": { + "asn1.js": "^4.0.0", + "browserify-aes": "^1.0.0", + "create-hash": "^1.1.0", + "evp_bytestokey": "^1.0.0", + "pbkdf2": "^3.0.3" + } + }, + "parse-headers": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.1.tgz", + "integrity": "sha1-aug6eqJanZtwCswoaYzR8e1+lTY=", + "requires": { + "for-each": "^0.3.2", + "trim": "0.0.1" + } + }, + "parseurl": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.2.tgz", + "integrity": "sha1-/CidTtiZMRlGDBViUyYs3I3mW/M=" + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-to-regexp": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.7.tgz", + "integrity": "sha1-32BBeABfUi8V60SQ5yR6G/qmf4w=" + }, + "pbkdf2": { + "version": "3.0.17", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz", + "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==", + "requires": { + "create-hash": "^1.1.2", + "create-hmac": "^1.1.4", + "ripemd160": "^2.0.1", + "safe-buffer": "^5.0.1", + "sha.js": "^2.4.8" + } + }, + "pend": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz", + "integrity": "sha1-elfrVQpng/kRUzH89GY9XI4AelA=" + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=" + }, + "pinkie": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/pinkie/-/pinkie-2.0.4.tgz", + "integrity": "sha1-clVrgM+g1IqXToDnckjoDtT3+HA=" + }, + "pinkie-promise": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/pinkie-promise/-/pinkie-promise-2.0.1.tgz", + "integrity": "sha1-ITXW36ejWMBprJsXh3YogihFD/o=", + "requires": { + "pinkie": "^2.0.0" + } + }, + "pragma-singleton": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/pragma-singleton/-/pragma-singleton-1.0.3.tgz", + "integrity": "sha1-aJQxe7jUcVflneKkoAnbfm9j4w4=" + }, + "prepend-http": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/prepend-http/-/prepend-http-1.0.4.tgz", + "integrity": "sha1-1PRWKwzjaW5BrFLQ4ALlemNdxtw=" + }, + "process": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/process/-/process-0.5.2.tgz", + "integrity": "sha1-FjjYqONML0QKkduVq5rrZ3/Bhc8=" + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + }, + "proxy-addr": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.4.tgz", + "integrity": "sha512-5erio2h9jp5CHGwcybmxmVqHmnCBZeewlfJ0pex+UW7Qny7OOZXTtH56TGNyBizkgiOwhJtMKrVzDTeKcySZwA==", + "requires": { + "forwarded": "~0.1.2", + "ipaddr.js": "1.8.0" + } + }, + "psl": { + "version": "1.1.29", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.29.tgz", + "integrity": "sha512-AeUmQ0oLN02flVHXWh9sSJF7mcdFq0ppid/JkErufc3hGIV/AMa8Fo9VgDo/cT2jFdOWoFvHp90qqBH54W+gjQ==" + }, + "public-encrypt": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz", + "integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==", + "requires": { + "bn.js": "^4.1.0", + "browserify-rsa": "^4.0.0", + "create-hash": "^1.1.0", + "parse-asn1": "^5.0.0", + "randombytes": "^2.0.1", + "safe-buffer": "^5.1.2" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + }, + "qs": { + "version": "6.5.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.2.tgz", + "integrity": "sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA==" + }, + "query-string": { + "version": "5.1.1", + "resolved": "http://registry.npmjs.org/query-string/-/query-string-5.1.1.tgz", + "integrity": "sha512-gjWOsm2SoGlgLEdAGt7a6slVOk9mGiXmPFMqrEhLQ68rhQuBnpfs3+EmlvqKyxnCo9/PPlF+9MtY02S1aFg+Jw==", + "requires": { + "decode-uri-component": "^0.2.0", + "object-assign": "^4.1.0", + "strict-uri-encode": "^1.0.0" + } + }, + "randombytes": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz", + "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", + "requires": { + "safe-buffer": "^5.1.0" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "requires": { + "randombytes": "^2.0.5", + "safe-buffer": "^5.1.0" + } + }, + "randomhex": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/randomhex/-/randomhex-0.1.5.tgz", + "integrity": "sha1-us7vmCMpCRQA8qKRLGzQLxCU9YU=" + }, + "range-parser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.0.tgz", + "integrity": "sha1-9JvmtIeJTdxA3MlKMi9hEJLgDV4=" + }, + "raw-body": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.3.3.tgz", + "integrity": "sha512-9esiElv1BrZoI3rCDuOuKCBRbuApGGaDPQfjSflGxdy4oyzqghxu6klEkkVIvBje+FF0BX9coEv8KqW6X/7njw==", + "requires": { + "bytes": "3.0.0", + "http-errors": "1.6.3", + "iconv-lite": "0.4.23", + "unpipe": "1.0.0" + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "request": { + "version": "2.88.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz", + "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==", + "requires": { + "aws-sign2": "~0.7.0", + "aws4": "^1.8.0", + "caseless": "~0.12.0", + "combined-stream": "~1.0.6", + "extend": "~3.0.2", + "forever-agent": "~0.6.1", + "form-data": "~2.3.2", + "har-validator": "~5.1.0", + "http-signature": "~1.2.0", + "is-typedarray": "~1.0.0", + "isstream": "~0.1.2", + "json-stringify-safe": "~5.0.1", + "mime-types": "~2.1.19", + "oauth-sign": "~0.9.0", + "performance-now": "^2.1.0", + "qs": "~6.5.2", + "safe-buffer": "^5.1.2", + "tough-cookie": "~2.4.3", + "tunnel-agent": "^0.6.0", + "uuid": "^3.3.2" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "requires": { + "glob": "^7.0.5" + } + }, + "ripemd160": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.2.tgz", + "integrity": "sha512-ii4iagi25WusVoiC4B4lq7pbXfAp3D9v5CwfkY33vffw2+pkDjY1D8GaN7spsxvCSx8dkPqOZCEZyfxcmJG2IA==", + "requires": { + "hash-base": "^3.0.0", + "inherits": "^2.0.1" + } + }, + "rlp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/rlp/-/rlp-2.1.0.tgz", + "integrity": "sha512-93U7IKH5j7nmXFVg19MeNBGzQW5uXW1pmCuKY8veeKIhYTE32C2d0mOegfiIAfXcHOKJjjPlJisn8iHDF5AezA==", + "requires": { + "safe-buffer": "^5.1.1" + } + }, + "safe": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/safe/-/safe-0.4.6.tgz", + "integrity": "sha1-HVWAzyY1xcuUDqSPtQga48JbG+E=" + }, + "safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==" + }, + "safefs": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/safefs/-/safefs-3.2.2.tgz", + "integrity": "sha1-gXDBRE1wOOCMrqBaN0+uL6NJ4Vw=", + "requires": { + "graceful-fs": "*" + } + }, + "safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==" + }, + "scandirectory": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/scandirectory/-/scandirectory-2.5.0.tgz", + "integrity": "sha1-bOA/VKCQtmjjy+2/IO354xBZPnI=", + "requires": { + "ignorefs": "^1.0.0", + "safefs": "^3.1.2", + "taskgroup": "^4.0.5" + } + }, + "scrypt": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/scrypt/-/scrypt-6.0.3.tgz", + "integrity": "sha1-BOAUpWgrU/pQwtXM4WfXGcBthw0=", + "requires": { + "nan": "^2.0.8" + } + }, + "scrypt-async": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/scrypt-async/-/scrypt-async-1.3.1.tgz", + "integrity": "sha1-oR/W+smBtLgj7gHe4CIRaVAN2uk=" + }, + "scrypt.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/scrypt.js/-/scrypt.js-0.2.0.tgz", + "integrity": "sha1-r40UZbcemZARC+38WTuUeeA6ito=", + "requires": { + "scrypt": "^6.0.2", + "scryptsy": "^1.2.1" + } + }, + "scryptsy": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/scryptsy/-/scryptsy-1.2.1.tgz", + "integrity": "sha1-oyJfpLJST4AnAHYeKFW987LZIWM=", + "requires": { + "pbkdf2": "^3.0.3" + } + }, + "secp256k1": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/secp256k1/-/secp256k1-3.5.2.tgz", + "integrity": "sha512-iin3kojdybY6NArd+UFsoTuapOF7bnJNf2UbcWXaY3z+E1sJDipl60vtzB5hbO/uquBu7z0fd4VC4Irp+xoFVQ==", + "requires": { + "bindings": "^1.2.1", + "bip66": "^1.1.3", + "bn.js": "^4.11.3", + "create-hash": "^1.1.2", + "drbg.js": "^1.0.1", + "elliptic": "^6.2.3", + "nan": "^2.2.1", + "safe-buffer": "^5.1.0" + } + }, + "seek-bzip": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/seek-bzip/-/seek-bzip-1.0.5.tgz", + "integrity": "sha1-z+kXyz0nS8/6x5J1ivUxc+sfq9w=", + "requires": { + "commander": "~2.8.1" + } + }, + "semver": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz", + "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==" + }, + "send": { + "version": "0.16.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.16.2.tgz", + "integrity": "sha512-E64YFPUssFHEFBvpbbjr44NCLtI1AohxQ8ZSiJjQLskAdKuriYEP6VyGEsRDH8ScozGpkaX1BGvhanqCwkcEZw==", + "requires": { + "debug": "2.6.9", + "depd": "~1.1.2", + "destroy": "~1.0.4", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "~1.6.2", + "mime": "1.4.1", + "ms": "2.0.0", + "on-finished": "~2.3.0", + "range-parser": "~1.2.0", + "statuses": "~1.4.0" + }, + "dependencies": { + "statuses": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.4.0.tgz", + "integrity": "sha512-zhSCtt8v2NDrRlPQpCNtw/heZLtfUDqxBM1udqikb/Hbk52LK4nQSwr10u77iopCW5LsyHpuXS0GnEc48mLeew==" + } + } + }, + "serve-static": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.13.2.tgz", + "integrity": "sha512-p/tdJrO4U387R9oMjb1oj7qSMaMfmOyd4j9hOFoxZe2baQszgHcSWjuya/CiT5kgZZKRudHNOA0pYXOl8rQ5nw==", + "requires": { + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.2", + "send": "0.16.2" + } + }, + "servify": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/servify/-/servify-0.1.12.tgz", + "integrity": "sha512-/xE6GvsKKqyo1BAY+KxOWXcLpPsUUyji7Qg3bVD7hh1eRze5bR1uYiuDA/k3Gof1s9BTzQZEJK8sNcNGFIzeWw==", + "requires": { + "body-parser": "^1.16.0", + "cors": "^2.8.1", + "express": "^4.14.0", + "request": "^2.79.0", + "xhr": "^2.3.3" + } + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=" + }, + "setprototypeof": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==" + }, + "sha.js": { + "version": "2.4.11", + "resolved": "http://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz", + "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==", + "requires": { + "inherits": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "sha3": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/sha3/-/sha3-1.2.2.tgz", + "integrity": "sha1-pmxQmN5MJbyIM27ItIF9AFvKe6k=", + "requires": { + "nan": "2.10.0" + } + }, + "simple-concat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.0.tgz", + "integrity": "sha1-c0TLuLbib7J9ZrL8hvn21Zl1IcY=" + }, + "simple-get": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/simple-get/-/simple-get-2.8.1.tgz", + "integrity": "sha512-lSSHRSw3mQNUGPAYRqo7xy9dhKmxFXIjLjp4KHpf99GEH2VH7C3AM+Qfx6du6jhfUi6Vm7XnbEVEf7Wb6N8jRw==", + "requires": { + "decompress-response": "^3.3.0", + "once": "^1.3.1", + "simple-concat": "^1.0.0" + } + }, + "sorted-array-functions": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/sorted-array-functions/-/sorted-array-functions-1.2.0.tgz", + "integrity": "sha512-sWpjPhIZJtqO77GN+LD8dDsDKcWZ9GCOJNqKzi1tvtjGIzwfoyuRH8S0psunmc6Z5P+qfDqztSbwYR5X/e1UTg==" + }, + "sprintf-js": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.1.tgz", + "integrity": "sha1-Nr54Mgr+WAH2zqPueLblqrlA6gw=" + }, + "sshpk": { + "version": "1.15.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.15.1.tgz", + "integrity": "sha512-mSdgNUaidk+dRU5MhYtN9zebdzF2iG0cNPWy8HG+W8y+fT1JnSkh0fzzpjOa0L7P8i1Rscz38t0h4gPcKz43xA==", + "requires": { + "asn1": "~0.2.3", + "assert-plus": "^1.0.0", + "bcrypt-pbkdf": "^1.0.0", + "dashdash": "^1.12.0", + "ecc-jsbn": "~0.1.1", + "getpass": "^0.1.1", + "jsbn": "~0.1.0", + "safer-buffer": "^2.0.2", + "tweetnacl": "~0.14.0" + } + }, + "stack-trace": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.10.tgz", + "integrity": "sha1-VHxws0fo0ytOEI6hoqFZ5f3eGcA=" + }, + "statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha1-Fhx9rBd2Wf2YEfQ3cfqZOBR4Yow=" + }, + "stdio": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/stdio/-/stdio-0.2.7.tgz", + "integrity": "sha1-ocV9oQ/hz6oMO/aDydB0PRtmCDk=" + }, + "strict-uri-encode": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/strict-uri-encode/-/strict-uri-encode-1.1.0.tgz", + "integrity": "sha1-J5siXfHVgrH1TmWt3UNS4Y+qBxM=" + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "~5.1.0" + } + }, + "strip-dirs": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/strip-dirs/-/strip-dirs-2.1.0.tgz", + "integrity": "sha512-JOCxOeKLm2CAS73y/U4ZeZPTkE+gNVCzKt7Eox84Iej1LT/2pTWYpZKJuxwQpvX1LiZb1xokNR7RLfuBAa7T3g==", + "requires": { + "is-natural-number": "^4.0.1" + } + }, + "strip-hex-prefix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", + "integrity": "sha1-DF8VX+8RUTczd96du1iNoFUA428=", + "requires": { + "is-hex-prefixed": "1.0.0" + } + }, + "swarm-js": { + "version": "0.1.37", + "resolved": "https://registry.npmjs.org/swarm-js/-/swarm-js-0.1.37.tgz", + "integrity": "sha512-G8gi5fcXP/2upwiuOShJ258sIufBVztekgobr3cVgYXObZwJ5AXLqZn52AI+/ffft29pJexF9WNdUxjlkVehoQ==", + "requires": { + "bluebird": "^3.5.0", + "buffer": "^5.0.5", + "decompress": "^4.0.0", + "eth-lib": "^0.1.26", + "fs-extra": "^2.1.2", + "fs-promise": "^2.0.0", + "got": "^7.1.0", + "mime-types": "^2.1.16", + "mkdirp-promise": "^5.0.1", + "mock-fs": "^4.1.0", + "setimmediate": "^1.0.5", + "tar.gz": "^1.0.5", + "xhr-request-promise": "^0.1.2" + } + }, + "tar": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tar/-/tar-2.2.1.tgz", + "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=", + "requires": { + "block-stream": "*", + "fstream": "^1.0.2", + "inherits": "2" + } + }, + "tar-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/tar-stream/-/tar-stream-1.6.2.tgz", + "integrity": "sha512-rzS0heiNf8Xn7/mpdSVVSMAWAoy9bfb1WOTYC78Z0UQKeKa/CWS8FOq0lKGNa8DWKAn9gxjCvMLYc5PGXYlK2A==", + "requires": { + "bl": "^1.0.0", + "buffer-alloc": "^1.2.0", + "end-of-stream": "^1.0.0", + "fs-constants": "^1.0.0", + "readable-stream": "^2.3.0", + "to-buffer": "^1.1.1", + "xtend": "^4.0.0" + } + }, + "tar.gz": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/tar.gz/-/tar.gz-1.0.7.tgz", + "integrity": "sha512-uhGatJvds/3diZrETqMj4RxBR779LKlIE74SsMcn5JProZsfs9j0QBwWO1RW+IWNJxS2x8Zzra1+AW6OQHWphg==", + "requires": { + "bluebird": "^2.9.34", + "commander": "^2.8.1", + "fstream": "^1.0.8", + "mout": "^0.11.0", + "tar": "^2.1.1" + }, + "dependencies": { + "bluebird": { + "version": "2.11.0", + "resolved": "http://registry.npmjs.org/bluebird/-/bluebird-2.11.0.tgz", + "integrity": "sha1-U0uQM8AiyVecVro7Plpcqvu2UOE=" + } + } + }, + "taskgroup": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/taskgroup/-/taskgroup-4.3.1.tgz", + "integrity": "sha1-feGT/r12gnPEV3MElwJNUSwnkVo=", + "requires": { + "ambi": "^2.2.0", + "csextends": "^1.0.3" + } + }, + "thenify": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.0.tgz", + "integrity": "sha1-5p44obq+lpsBCCB5eLn2K4hgSDk=", + "requires": { + "any-promise": "^1.0.0" + } + }, + "thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha1-GhkY1ALY/D+Y+/I02wvMjMEOlyY=", + "requires": { + "thenify": ">= 3.1.0 < 4" + } + }, + "through": { + "version": "2.3.8", + "resolved": "http://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "timed-out": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/timed-out/-/timed-out-4.0.1.tgz", + "integrity": "sha1-8y6srFoXW+ol1/q1Zas+2HQe9W8=" + }, + "tingodb": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/tingodb/-/tingodb-0.6.1.tgz", + "integrity": "sha1-9jM2JZr336bJDf4lVqDfsNTu3lk=", + "requires": { + "bson": "^1.0.4", + "lodash": "^4.17.5", + "safe": "^0.4.5", + "safe-buffer": "^5.1.1" + } + }, + "to-buffer": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/to-buffer/-/to-buffer-1.1.1.tgz", + "integrity": "sha512-lx9B5iv7msuFYE3dytT+KE5tap+rNYw+K4jVkb9R/asAb+pbBSM17jtunHplhBe6RRJdZx3Pn2Jph24O32mOVg==" + }, + "tough-cookie": { + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz", + "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==", + "requires": { + "psl": "^1.1.24", + "punycode": "^1.4.1" + } + }, + "trim": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz", + "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=" + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "requires": { + "safe-buffer": "^5.0.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=" + }, + "type-is": { + "version": "1.6.16", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.16.tgz", + "integrity": "sha512-HRkVv/5qY2G6I8iab9cI7v1bOIdhm94dVjQCPFElW9W+3GeDOSHmy2EBYe4VTApuzolPcmgFTN3ftVJRKR2J9Q==", + "requires": { + "media-typer": "0.3.0", + "mime-types": "~2.1.18" + } + }, + "typechecker": { + "version": "2.1.0", + "resolved": "http://registry.npmjs.org/typechecker/-/typechecker-2.1.0.tgz", + "integrity": "sha1-0cIJOlT/ihn1jP+HfuqlTyJC04M=" + }, + "typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "requires": { + "is-typedarray": "^1.0.0" + } + }, + "ultron": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", + "integrity": "sha512-UIEXBNeYmKptWH6z8ZnqTeS8fV74zG0/eRU9VGkpzz+LIJNs8W/zM/L+7ctCkRrgbNnnR0xxw4bKOr0cW0N0Og==" + }, + "unbzip2-stream": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/unbzip2-stream/-/unbzip2-stream-1.3.1.tgz", + "integrity": "sha512-fIZnvdjblYs7Cru/xC6tCPVhz7JkYcVQQkePwMLyQELzYTds2Xn8QefPVnvdVhhZqubxNA1cASXEH5wcK0Bucw==", + "requires": { + "buffer": "^3.0.1", + "through": "^2.3.6" + }, + "dependencies": { + "base64-js": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-0.0.8.tgz", + "integrity": "sha1-EQHpVE9KdrG8OybUUsqW16NeeXg=" + }, + "buffer": { + "version": "3.6.0", + "resolved": "http://registry.npmjs.org/buffer/-/buffer-3.6.0.tgz", + "integrity": "sha1-pyyTb3e5a/UvX357RnGAYoVR3vs=", + "requires": { + "base64-js": "0.0.8", + "ieee754": "^1.1.4", + "isarray": "^1.0.0" + } + } + } + }, + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + }, + "unorm": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/unorm/-/unorm-1.4.1.tgz", + "integrity": "sha1-NkIA1fE2RsqLzURJAnEzVhR5IwA=" + }, + "unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha1-sr9O6FFKrmFltIF4KdIbLvSZBOw=" + }, + "url-parse-lax": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-parse-lax/-/url-parse-lax-1.0.0.tgz", + "integrity": "sha1-evjzA2Rem9eaJy56FKxovAYJ2nM=", + "requires": { + "prepend-http": "^1.0.1" + } + }, + "url-set-query": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/url-set-query/-/url-set-query-1.0.0.tgz", + "integrity": "sha1-AW6M/Xwg7gXK/neV6JK9BwL6ozk=" + }, + "url-to-options": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/url-to-options/-/url-to-options-1.0.1.tgz", + "integrity": "sha1-FQWgOiiaSMvXpDTvuu7FBV9WM6k=" + }, + "utf8": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/utf8/-/utf8-2.1.1.tgz", + "integrity": "sha1-LgHbAvfY0JRPdxBPFgnrDDBM92g=" + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha1-n5VxD1CiZ5R7LMwSR0HBAoQn5xM=" + }, + "uuid": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz", + "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==" + }, + "varint": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/varint/-/varint-5.0.0.tgz", + "integrity": "sha1-2Ca4n3SQcy+rwMDtaT7Uddyynr8=" + }, + "vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha1-IpnwLG3tMNSllhsLn3RSShj2NPw=" + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "requires": { + "assert-plus": "^1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "^1.2.0" + } + }, + "watchr": { + "version": "2.4.13", + "resolved": "https://registry.npmjs.org/watchr/-/watchr-2.4.13.tgz", + "integrity": "sha1-10hHu01vkPYf4sdPn2hmKqDgdgE=", + "requires": { + "eachr": "^2.0.2", + "extendr": "^2.1.0", + "extract-opts": "^2.2.0", + "ignorefs": "^1.0.0", + "safefs": "^3.1.2", + "scandirectory": "^2.5.0", + "taskgroup": "^4.2.0", + "typechecker": "^2.0.8" + } + }, + "web3": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3/-/web3-1.0.0-beta.35.tgz", + "integrity": "sha512-xwDmUhvTcHQvvNnOPcPZZgCxKUsI2e+GbHy7JkTK3/Rmnutazy8x7fsAXT9myw7V1qpi3GgLoZ3fkglSUbg1Mg==", + "requires": { + "web3-bzz": "1.0.0-beta.35", + "web3-core": "1.0.0-beta.35", + "web3-eth": "1.0.0-beta.35", + "web3-eth-personal": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-shh": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-bzz": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-bzz/-/web3-bzz-1.0.0-beta.35.tgz", + "integrity": "sha512-BhAU0qhlr8zltm4gs/+P1gki2VkxHJaM2Rrh4DGesDW0lzwufRoNvWFlwx1bKHoFPWNbSmm9PRkHOYOINL/Tgw==", + "requires": { + "got": "7.1.0", + "swarm-js": "0.1.37", + "underscore": "1.8.3" + } + }, + "web3-core": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core/-/web3-core-1.0.0-beta.35.tgz", + "integrity": "sha512-ayGavbgVk4KL9Y88Uv411fBJ0SVgVfKhKEBweKYzmP0zOqneMzWt6YsyD1n6kRvjAbqA0AfUPEOKyMNjcx2tjw==", + "requires": { + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-requestmanager": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-core-helpers": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-helpers/-/web3-core-helpers-1.0.0-beta.35.tgz", + "integrity": "sha512-APOu3sEsamyqWt//8o4yq9KF25/uqGm+pQShson/sC4gKzmfJB07fLo2ond0X30E8fIqAPeVCotPXQxGciGUmA==", + "requires": { + "underscore": "1.8.3", + "web3-eth-iban": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-core-method": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-method/-/web3-core-method-1.0.0-beta.35.tgz", + "integrity": "sha512-jidImCide8q0GpfsO4L73qoHrbkeWgwU3uOH5DKtJtv0ccmG086knNMRgryb/o9ZgetDWLmDEsJnHjBSoIwcbA==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-promievent": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-core-promievent": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-promievent/-/web3-core-promievent-1.0.0-beta.35.tgz", + "integrity": "sha512-GvqXqKq07OmHuVi5uNRg6k79a1/CI0ViCC+EtNv4CORHtDRmYEt5Bvdv6z6FJEiaaQkD0lKbFwNhLxutx7HItw==", + "requires": { + "any-promise": "1.3.0", + "eventemitter3": "1.1.1" + } + }, + "web3-core-requestmanager": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-requestmanager/-/web3-core-requestmanager-1.0.0-beta.35.tgz", + "integrity": "sha512-S+zW2h17ZZQU9oe3yaCJE0E7aJS4C3Kf4kGPDv+nXjW0gKhQQhgVhw1Doq/aYQGqNSWJp7f1VHkz5gQWwg6RRg==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-providers-http": "1.0.0-beta.35", + "web3-providers-ipc": "1.0.0-beta.35", + "web3-providers-ws": "1.0.0-beta.35" + } + }, + "web3-core-subscriptions": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-core-subscriptions/-/web3-core-subscriptions-1.0.0-beta.35.tgz", + "integrity": "sha512-gXzLrWvcGkGiWq1y33Z4Y80XI8XMrwowiQJkrPSjQ81K5PBKquOGwcMffLaKcwdmEy/NpsOXDeFo3eLE1Ghvvw==", + "requires": { + "eventemitter3": "1.1.1", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35" + } + }, + "web3-eth": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth/-/web3-eth-1.0.0-beta.35.tgz", + "integrity": "sha512-04mcb2nGPXThawuuYICPOxv0xOHofvQKsjZeIq+89nyOC8DQMGTAErDkGyMHQYtjpth5XDhic0wuEsA80AmFZA==", + "requires": { + "underscore": "1.8.3", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-eth-abi": "1.0.0-beta.35", + "web3-eth-accounts": "1.0.0-beta.35", + "web3-eth-contract": "1.0.0-beta.35", + "web3-eth-iban": "1.0.0-beta.35", + "web3-eth-personal": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-eth-abi": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-abi/-/web3-eth-abi-1.0.0-beta.35.tgz", + "integrity": "sha512-KUDC+EtFFYG8z01ZleKrASdjj327/rtWHzEt6RWsEj7bBa0bGp9nEh+nqdZx/Sdgz1O8tnfFzJlrRcXpfr1vGg==", + "requires": { + "bn.js": "4.11.6", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "web3-eth-accounts": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-accounts/-/web3-eth-accounts-1.0.0-beta.35.tgz", + "integrity": "sha512-duIgRsfht/0kAW/eQ0X9lKtVIykbETrnM2H7EnvplCzPHtQLodpib4o9JXfh9n6ZDgdDC7cuJoiVB9QJg089ew==", + "requires": { + "any-promise": "1.3.0", + "crypto-browserify": "3.12.0", + "eth-lib": "0.2.7", + "scrypt.js": "0.2.0", + "underscore": "1.8.3", + "uuid": "2.0.1", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "eth-lib": { + "version": "0.2.7", + "resolved": "https://registry.npmjs.org/eth-lib/-/eth-lib-0.2.7.tgz", + "integrity": "sha1-L5Pxex4jrsN1nNSj/iDBKGo/wco=", + "requires": { + "bn.js": "^4.11.6", + "elliptic": "^6.4.0", + "xhr-request-promise": "^0.1.2" + } + }, + "uuid": { + "version": "2.0.1", + "resolved": "http://registry.npmjs.org/uuid/-/uuid-2.0.1.tgz", + "integrity": "sha1-wqMN7bPlNdcsz4LjQ5QaULqFM6w=" + } + } + }, + "web3-eth-contract": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-contract/-/web3-eth-contract-1.0.0-beta.35.tgz", + "integrity": "sha512-foPohOg5O1UCGKGZOIs+kQK5IZdV2QQ7pAWwNxH8WHplUA+fre1MurXNpoxknUmH6mYplFhXjqgYq2MsrBpHrA==", + "requires": { + "underscore": "1.8.3", + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-promievent": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-eth-abi": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-eth-iban": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-iban/-/web3-eth-iban-1.0.0-beta.35.tgz", + "integrity": "sha512-H5wkcNcAIc+h/WoDIKv7ZYmrM2Xqu3O7jBQl1IWo73EDVQji+AoB2i3J8tuwI1yZRInRwrfpI3Zuwuf54hXHmQ==", + "requires": { + "bn.js": "4.11.6", + "web3-utils": "1.0.0-beta.35" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "web3-eth-personal": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-eth-personal/-/web3-eth-personal-1.0.0-beta.35.tgz", + "integrity": "sha512-AcM9nnlxu7ZRRxPvkrFB9eLxMM4A2cPfj2aCg21Wb2EpMnhR+b/O1cT33k7ApRowoMpM+T9M8vx2oPNwXfaCOQ==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-helpers": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-net": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-net/-/web3-net-1.0.0-beta.35.tgz", + "integrity": "sha512-bbwaQ/KohGjIJ6HAKbZ6KrklCAaG6/B7hIbAbVLSFLxF+Yz9lmAgQYaDInpidpC/NLb3WOmcbRF+P77J4qMVIA==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-utils": "1.0.0-beta.35" + } + }, + "web3-providers-http": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-http/-/web3-providers-http-1.0.0-beta.35.tgz", + "integrity": "sha512-DcIMFq52Fb08UpWyZ3ZlES6NsNqJnco4hBS/Ej6eOcASfuUayPI+GLkYVZsnF3cBYqlH+DOKuArcKSuIxK7jIA==", + "requires": { + "web3-core-helpers": "1.0.0-beta.35", + "xhr2-cookies": "1.1.0" + } + }, + "web3-providers-ipc": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-ipc/-/web3-providers-ipc-1.0.0-beta.35.tgz", + "integrity": "sha512-iB0FG0HcpUnayfa8pn4guqEQ4Y1nrroi/jffdtQgFkrNt0sD3fMSwwC0AbmECqj3tDLl0e1slBR0RENll+ZF0g==", + "requires": { + "oboe": "2.1.3", + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35" + } + }, + "web3-providers-ws": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-providers-ws/-/web3-providers-ws-1.0.0-beta.35.tgz", + "integrity": "sha512-Cx64NgDStynKaUGDIIOfaCd0fZusL8h5avKTkdTjUu2aHhFJhZoVBGVLhoDtUaqZGWIZGcBJOoVf2JkGUOjDRQ==", + "requires": { + "underscore": "1.8.3", + "web3-core-helpers": "1.0.0-beta.35", + "websocket": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2" + } + }, + "web3-shh": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-shh/-/web3-shh-1.0.0-beta.35.tgz", + "integrity": "sha512-8qSonk/x0xabERS9Sr6AIADN/Ty+5KwARkkGIfSYHKqFpdMDz+76F7cUCxtoCZoS8K04xgZlDKYe0TJXLYA0Fw==", + "requires": { + "web3-core": "1.0.0-beta.35", + "web3-core-method": "1.0.0-beta.35", + "web3-core-subscriptions": "1.0.0-beta.35", + "web3-net": "1.0.0-beta.35" + } + }, + "web3-utils": { + "version": "1.0.0-beta.35", + "resolved": "https://registry.npmjs.org/web3-utils/-/web3-utils-1.0.0-beta.35.tgz", + "integrity": "sha512-Dq6f0SOKj3BDFRgOPnE6ALbzBDCKVIW8mKWVf7tGVhTDHf+wQaWwQSC3aArFSqdExB75BPBPyDpuMTNszhljpA==", + "requires": { + "bn.js": "4.11.6", + "eth-lib": "0.1.27", + "ethjs-unit": "0.1.6", + "number-to-bn": "1.7.0", + "randomhex": "0.1.5", + "underscore": "1.8.3", + "utf8": "2.1.1" + }, + "dependencies": { + "bn.js": { + "version": "4.11.6", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.6.tgz", + "integrity": "sha1-UzRK2xRhehP26N0s4okF0cC6MhU=" + } + } + }, + "websocket": { + "version": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2", + "from": "git://github.com/frozeman/WebSocket-Node.git#browserifyCompatible", + "requires": { + "debug": "^2.2.0", + "nan": "^2.3.3", + "typedarray-to-buffer": "^3.1.2", + "yaeti": "^0.0.6" + } + }, + "winston": { + "version": "2.4.4", + "resolved": "https://registry.npmjs.org/winston/-/winston-2.4.4.tgz", + "integrity": "sha512-NBo2Pepn4hK4V01UfcWcDlmiVTs7VTB1h7bgnB0rgP146bYhMxX0ypCz3lBOfNxCO4Zuek7yeT+y/zM1OfMw4Q==", + "requires": { + "async": "~1.0.0", + "colors": "1.0.x", + "cycle": "1.0.x", + "eyes": "0.1.x", + "isstream": "0.1.x", + "stack-trace": "0.0.x" + }, + "dependencies": { + "async": { + "version": "1.0.0", + "resolved": "http://registry.npmjs.org/async/-/async-1.0.0.tgz", + "integrity": "sha1-+PwEyjoTeErenhZBr5hXjPvWR6k=" + }, + "colors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/colors/-/colors-1.0.3.tgz", + "integrity": "sha1-BDP0TYCWgP3rYO0mDxsMJi6CpAs=" + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "ws": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-3.3.3.tgz", + "integrity": "sha512-nnWLa/NwZSt4KQJu51MYlCcSQ5g7INpOrOMt4XV8j4dqTXdmlUmSHQ8/oLC069ckre0fRsgfvsKwbTdtKLCDkA==", + "requires": { + "async-limiter": "~1.0.0", + "safe-buffer": "~5.1.0", + "ultron": "~1.1.0" + } + }, + "xhr": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/xhr/-/xhr-2.5.0.tgz", + "integrity": "sha512-4nlO/14t3BNUZRXIXfXe+3N6w3s1KoxcJUUURctd64BLRe67E4gRwp4PjywtDY72fXpZ1y6Ch0VZQRY/gMPzzQ==", + "requires": { + "global": "~4.3.0", + "is-function": "^1.0.1", + "parse-headers": "^2.0.0", + "xtend": "^4.0.0" + } + }, + "xhr-request": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/xhr-request/-/xhr-request-1.1.0.tgz", + "integrity": "sha512-Y7qzEaR3FDtL3fP30k9wO/e+FBnBByZeybKOhASsGP30NIkRAAkKD/sCnLvgEfAIEC1rcmK7YG8f4oEnIrrWzA==", + "requires": { + "buffer-to-arraybuffer": "^0.0.5", + "object-assign": "^4.1.1", + "query-string": "^5.0.1", + "simple-get": "^2.7.0", + "timed-out": "^4.0.1", + "url-set-query": "^1.0.0", + "xhr": "^2.0.4" + } + }, + "xhr-request-promise": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/xhr-request-promise/-/xhr-request-promise-0.1.2.tgz", + "integrity": "sha1-NDxE0e53JrhkgGloLQ+EDIO0Jh0=", + "requires": { + "xhr-request": "^1.0.1" + } + }, + "xhr2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/xhr2/-/xhr2-0.1.4.tgz", + "integrity": "sha1-f4dliEdxbbUCYyOBL4GMras4el8=" + }, + "xhr2-cookies": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/xhr2-cookies/-/xhr2-cookies-1.1.0.tgz", + "integrity": "sha1-fXdEnQmZGX8VXLc7I99yUF7YnUg=", + "requires": { + "cookiejar": "^2.1.1" + } + }, + "xmlhttprequest": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/xmlhttprequest/-/xmlhttprequest-1.8.0.tgz", + "integrity": "sha1-Z/4HXFwk/vOfnWX197f+dRcZaPw=" + }, + "xregexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/xregexp/-/xregexp-2.0.0.tgz", + "integrity": "sha1-UqY+VsoLhKfzpfPWGHLxJq16WUM=" + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + }, + "yaeti": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/yaeti/-/yaeti-0.0.6.tgz", + "integrity": "sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc=" + }, + "yauzl": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", + "integrity": "sha1-x+sXyT4RLLEIb6bY5R+wZnt5pfk=", + "requires": { + "buffer-crc32": "~0.2.3", + "fd-slicer": "~1.1.0" + } + } + } +} diff --git a/solidity/truffle-examples/url-requests/package.json b/solidity/truffle-examples/url-requests/package.json new file mode 100644 index 00000000..22b80140 --- /dev/null +++ b/solidity/truffle-examples/url-requests/package.json @@ -0,0 +1,23 @@ +{ + "name": "Oraclize Examples using Truffle: Computation-Datasource - Url Requests", + "version": "0.1.0", + "description": "Testing set up for Oraclize's Url-Requests example contract", + "main": "README.md", + "directories": { + "test": "test" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/n/a.git" + }, + "author": "Oraclize - Greg Kapka", + "license": "MIT", + "bugs": { + "url": "https://github.com/n/a/issues" + }, + "homepage": "https://github.com/n/a#readme", + "dependencies": { + "ethereum-bridge": "0.6.1", + "web3": "1.0.0-beta.35" + } +} diff --git a/solidity/truffle-examples/url-requests/test/url-requests-tests.js b/solidity/truffle-examples/url-requests/test/url-requests-tests.js new file mode 100644 index 00000000..2ab48c12 --- /dev/null +++ b/solidity/truffle-examples/url-requests/test/url-requests-tests.js @@ -0,0 +1,170 @@ +const Web3 = require('web3') +const waitForEvent = require('./utils') +const urlRequests = artifacts.require('./UrlRequests.sol') +const web3 = new Web3(new Web3.providers.WebsocketProvider('ws://localhost:9545')) + +contract('Oraclize Example using Truffle', async accounts => { + + describe("URL Requests Tests", async () => { + + const gasAmt = 3e6 + const addr = accounts[0] + const urlReq = new Array(5).fill() + + it('Should log a new query upon a request for custom headers', async () => { + const {contract} = await urlRequests.new() + const {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + urlReq[0] = {methods,events} + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await methods.requestCustomHeaders().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was sent, standing by for the answer...', 'Oraclize query incorrectly logged!') + }) + + it('Should log a new query upon a basic auth request', async () => { + const {contract} = await urlRequests.new() + const {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + urlReq[1] = {methods,events} + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await methods.requestBasicAuth().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was sent, standing by for the answer...', 'Oraclize query incorrectly logged!') + }) + + it('Should log a new query upon a POST request', async () => { + const {contract} = await urlRequests.new() + const {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + urlReq[2] = {methods,events} + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await methods.requestPost().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was sent, standing by for the answer...', 'Oraclize query incorrectly logged!') + }) + + it('Should log a new query upon a PUT request', async () => { + const {contract} = await urlRequests.new() + const {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + urlReq[3] = {methods,events} + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await methods.requestPut().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was sent, standing by for the answer...', 'Oraclize query incorrectly logged!') + }) + + it('Should log a new query upon a for request cookies', async () => { + const {contract} = await urlRequests.new() + const {methods, events} = new web3.eth.Contract(contract._jsonInterface, contract._address) + urlReq[4] = {methods,events} + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await methods.requestCookies().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was sent, standing by for the answer...', 'Oraclize query incorrectly logged!') + }) + + it('Should log a failed second request for custom headers due to lack of funds', async () => { + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await urlReq[0].methods.requestCustomHeaders().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was NOT sent, please add some ETH to cover for the query fee', 'Oraclize query incorrectly logged!') + }) + + it('Should log a failed second basic auth request due to lack of funds', async () => { + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await urlReq[1].methods.requestBasicAuth().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was NOT sent, please add some ETH to cover for the query fee', 'Oraclize query incorrectly logged!') + }) + + it('Should log a failed second POST request due to lack of funds', async () => { + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await urlReq[2].methods.requestPost().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was NOT sent, please add some ETH to cover for the query fee', 'Oraclize query incorrectly logged!') + }) + + it('Should log a failed second PUT request due to lack of funds', async () => { + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await urlReq[3].methods.requestPut().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was NOT sent, please add some ETH to cover for the query fee', 'Oraclize query incorrectly logged!') + }) + + it('Should log a failed second request for cookies due to lack of funds', async () => { + const {events:{newOraclizeQuery:{returnValues:{description}}}} = await urlReq[4].methods.requestCookies().send({from: addr, gas: gasAmt}) + assert.equal(description, 'Oraclize query was NOT sent, please add some ETH to cover for the query fee', 'Oraclize query incorrectly logged!') + }) + + it('Should emit result from request for custom headers', async () => { + const {returnValues:{result}} = await waitForEvent(urlReq[0].events.emitResult) + const expRes = '{"Accept-Encoding": "gzip, deflate", "Host": "httpbin.org", "Accept": "*/*", "User-Agent": "python-requests/2.19.1", "Connection": "close", "Content-Type": "json"}' + assert.equal(expRes, result, 'Incorrect result from custom header request!') + }) + + it('Should emit result from basic auth request', async () => { + const {returnValues:{result}} = await waitForEvent(urlReq[1].events.emitResult) + const expRes = '{ \"authenticated\": true, \"user\": \"myuser\"}' + assert.equal(expRes, result, 'Incorrect result from basic auth request!') + }) + + it('Should emit result from POST request', async () => { + const {returnValues:{result}} = await waitForEvent(urlReq[2].events.emitResult) + const expRes = { + "status": 200, + "result": [{ + "query": "OX49 5NU", + "result": { + "postcode": "OX49 5NU", + "quality": 1, + "eastings": 464447, + "northings": 195647, + "country": "England", + "nhs_ha": "South Central", + "longitude": -1.069752, + "latitude": 51.655929, + "european_electoral_region": "South East", + "primary_care_trust": "Oxfordshire", + "region": "South East", + "lsoa": "South Oxfordshire 011B", + "msoa": "South Oxfordshire 011", + "incode": "5NU", + "outcode": "OX49", + "parliamentary_constituency": "Henley", + "admin_district": "South Oxfordshire", + "parish": "Brightwell Baldwin", + "admin_county": "Oxfordshire", + "admin_ward": "Chalgrove", + "ccg": "NHS Oxfordshire", + "nuts": "Oxfordshire", + "codes": { + "admin_district": "E07000179", + "admin_county": "E10000025", + "admin_ward": "E05009735", + "parish": "E04008109", + "parliamentary_constituency": "E14000742", + "ccg": "E38000136", + "nuts": "UKJ14" + } + } + }] + } + assert.equal(JSON.stringify(expRes).slice(0,85), result.slice(0,85), 'Incorrect result from POST request!') // Note: The long. & lat. can change hence the slice! + }) + + it('Should emit result from PUT request', async () => { + const {returnValues:{result}} = await waitForEvent(urlReq[3].events.emitResult) + const expRes = { + "args": {}, + "data": "{\"testing\": \"it works\"}", + "files": {}, + "form": {}, + "headers": { + "Accept": "*/*", + "Accept-Encoding": "gzip, deflate", + "Connection": "close", + "Content-Length": "23", + "Content-Type": "application/json", + "Host": "httpbin.org", + "User-Agent": "python-requests/2.19.1" + }, + "json": { + "testing": "it works" + }, + "method": "PUT", + "origin": "n/a", + "url": "http://httpbin.org/anything" + } + const expResSerialized = JSON.stringify(expRes) + const resDeserialized = JSON.parse(result) + const resSerialized = JSON.stringify(resDeserialized) // Sigh. Look what we have to resort to! + assert.equal(expResSerialized.slice(0,50), resSerialized.slice(0,50), 'Incorrect result from PUT request!') + }) + + it('Should emit result from cookie request', async () => { + const {returnValues:{result}} = await waitForEvent(urlReq[4].events.emitResult) + const expRes = `{ "cookies": { "thiscookie": "should be saved and visible :)" }}` + assert.equal(expRes, result, 'Incorrect result from cookie request!') + }) + }) +}) diff --git a/solidity/truffle-examples/url-requests/test/utils.js b/solidity/truffle-examples/url-requests/test/utils.js new file mode 100644 index 00000000..53f799f8 --- /dev/null +++ b/solidity/truffle-examples/url-requests/test/utils.js @@ -0,0 +1,4 @@ +module.exports = (_event, _from = 0, _to = 'latest') => + new Promise ((resolve,reject) => + _event({fromBlock: _from, toBlock: _to}, (e, ev) => + e ? reject(e) : resolve(ev))) diff --git a/solidity/truffle-examples/url-requests/truffle.js b/solidity/truffle-examples/url-requests/truffle.js new file mode 100644 index 00000000..5a25e00f --- /dev/null +++ b/solidity/truffle-examples/url-requests/truffle.js @@ -0,0 +1,15 @@ +module.exports = { + networks: { + development: { + host: "127.0.0.1", + port: 8545, + network_id: "*", + websockets: true + } + }, + compilers: { + solc: { + version: '0.4.25' + } + } +} diff --git a/solidity/truffle-examples/url-requests/url-requests-tests.jpg b/solidity/truffle-examples/url-requests/url-requests-tests.jpg new file mode 100644 index 0000000000000000000000000000000000000000..8d2e5242170d4e5e0011bc3056918fed2b24597f GIT binary patch literal 126599 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 literal 0 HcmV?d00001 From ed1d7b1df7541f3398c6ec6c70cab70e339f67d0 Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Mon, 15 Oct 2018 17:11:29 +0100 Subject: [PATCH 11/14] tweak readme --- solidity/truffle-examples/url-requests/README.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/solidity/truffle-examples/url-requests/README.md b/solidity/truffle-examples/url-requests/README.md index 5aef6cee..efc7c66c 100644 --- a/solidity/truffle-examples/url-requests/README.md +++ b/solidity/truffle-examples/url-requests/README.md @@ -1,4 +1,4 @@ -# :wrench: :construction: Testing Oraclize's Url-Requests example contracts. +# :wrench: :construction: Testing Oraclize's Url-Requests Example.   @@ -22,7 +22,7 @@ __`❍ cd ethereum-examples/truffle-examples/url-requests && npm install`__ __`❍ truffle develop`__ -**5)** Open a _NEW_ console in the same directory & spool up the ethereum-bridge: +**5)** Open a _new_ console in the same directory & spool up the ethereum-bridge: __`❍ ./node_modules/.bin/ethereum-bridge -a 9 -H 127.0.0.1 -p 9545 --dev`__ @@ -34,16 +34,16 @@ __`❍ test`__ ## :camera: Passing Tests: -![Tests!!](oraclize-truffle-tests.jpg) +[The passing tests!](https://github.com/oraclize/ethereum-examples/solidity/truffle-examples/url-requests/url-requests-tests.jpg)   ## :black_nib: Notes: -The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! +__❍__ The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! -Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! +__❍__ Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! -If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api) channel to get timely support! +__❍__ If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api?raw=true) channel to get timely support! -Happy developing! +__*Happy developing!*__ From e1c241f9788087f0cd1ef5ac60f63c7e2448f4d6 Mon Sep 17 00:00:00 2001 From: gregkapka Date: Wed, 17 Oct 2018 17:07:45 +0100 Subject: [PATCH 12/14] add gitignore and fix wrong event name in contract tests --- .gitignore | 3 ++ .../truffle-examples/url-requests/README.md | 16 +++--- .../url-requests/package-lock.json | 49 ++++++++----------- .../url-requests/package.json | 2 +- .../url-requests/test/url-requests-tests.js | 12 ++--- .../url-requests/test/utils.js | 6 ++- 6 files changed, 44 insertions(+), 44 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..e1bb7ff4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +**/node_modules +*.sw* +*.log diff --git a/solidity/truffle-examples/url-requests/README.md b/solidity/truffle-examples/url-requests/README.md index 5aef6cee..7d125dbb 100644 --- a/solidity/truffle-examples/url-requests/README.md +++ b/solidity/truffle-examples/url-requests/README.md @@ -1,4 +1,4 @@ -# :wrench: :construction: Testing Oraclize's Url-Requests example contracts. +# :wrench: :construction: Testing Oraclize's Url-Requests Example.   @@ -16,13 +16,13 @@ __`❍ git clone https://github.com/oraclize/ethereum-examples.git`__ **3)** Enter this directory & install dependencies: -__`❍ cd ethereum-examples/truffle-examples/url-requests && npm install`__ +__`❍ cd ethereum-examples/solidity/truffle-examples/url-requests && npm install`__ **4)** Launch Truffle: __`❍ truffle develop`__ -**5)** Open a _NEW_ console in the same directory & spool up the ethereum-bridge: +**5)** Open a _new_ console in the same directory & spool up the ethereum-bridge: __`❍ ./node_modules/.bin/ethereum-bridge -a 9 -H 127.0.0.1 -p 9545 --dev`__ @@ -34,16 +34,16 @@ __`❍ test`__ ## :camera: Passing Tests: -![Tests!!](oraclize-truffle-tests.jpg) +[The passing tests!](https://github.com/oraclize/ethereum-examples/solidity/truffle-examples/url-requests/url-requests-tests.jpg)   ## :black_nib: Notes: -The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! +__❍__ The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! -Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! +__❍__ Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! -If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api) channel to get timely support! +__❍__ If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api?raw=true) channel to get timely support! -Happy developing! +__*Happy developing!*__ diff --git a/solidity/truffle-examples/url-requests/package-lock.json b/solidity/truffle-examples/url-requests/package-lock.json index c3eef0ad..8eeee260 100644 --- a/solidity/truffle-examples/url-requests/package-lock.json +++ b/solidity/truffle-examples/url-requests/package-lock.json @@ -1,6 +1,6 @@ { - "name": "url-request-tests", - "version": "1.0.0", + "name": "oraclize-examples-using-truffle__computation-datasource-url-requests", + "version": "0.1.0", "lockfileVersion": 1, "requires": true, "dependencies": { @@ -925,11 +925,16 @@ "resolved": "https://registry.npmjs.org/web3/-/web3-0.20.2.tgz", "integrity": "sha1-xU2sX8DjdzmcBMGm7LsS5FEyeNY=", "requires": { - "bignumber.js": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", "crypto-js": "^3.1.4", "utf8": "^2.1.1", "xhr2": "*", "xmlhttprequest": "*" + }, + "dependencies": { + "bignumber.js": { + "version": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934", + "from": "git+https://github.com/frozeman/bignumber.js-nolookahead.git#57692b3ecfc98bbdd6b3a516cb2353652ea49934" + } } } } @@ -2663,14 +2668,6 @@ "resolved": "http://registry.npmjs.org/typechecker/-/typechecker-2.1.0.tgz", "integrity": "sha1-0cIJOlT/ihn1jP+HfuqlTyJC04M=" }, - "typedarray-to-buffer": { - "version": "3.1.5", - "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", - "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", - "requires": { - "is-typedarray": "^1.0.0" - } - }, "ultron": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.1.1.tgz", @@ -3027,8 +3024,19 @@ "integrity": "sha512-Cx64NgDStynKaUGDIIOfaCd0fZusL8h5avKTkdTjUu2aHhFJhZoVBGVLhoDtUaqZGWIZGcBJOoVf2JkGUOjDRQ==", "requires": { "underscore": "1.8.3", - "web3-core-helpers": "1.0.0-beta.35", - "websocket": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2" + "web3-core-helpers": "1.0.0-beta.35" + }, + "dependencies": { + "websocket": { + "version": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2", + "from": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2", + "requires": { + "debug": "^2.2.0", + "nan": "^2.3.3", + "typedarray-to-buffer": "^3.1.2", + "yaeti": "^0.0.6" + } + } } }, "web3-shh": { @@ -3063,16 +3071,6 @@ } } }, - "websocket": { - "version": "git://github.com/frozeman/WebSocket-Node.git#6c72925e3f8aaaea8dc8450f97627e85263999f2", - "from": "git://github.com/frozeman/WebSocket-Node.git#browserifyCompatible", - "requires": { - "debug": "^2.2.0", - "nan": "^2.3.3", - "typedarray-to-buffer": "^3.1.2", - "yaeti": "^0.0.6" - } - }, "winston": { "version": "2.4.4", "resolved": "https://registry.npmjs.org/winston/-/winston-2.4.4.tgz", @@ -3174,11 +3172,6 @@ "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" }, - "yaeti": { - "version": "0.0.6", - "resolved": "https://registry.npmjs.org/yaeti/-/yaeti-0.0.6.tgz", - "integrity": "sha1-8m9ITXJoTPQr7ft2lwqhYI+/lXc=" - }, "yauzl": { "version": "2.10.0", "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz", diff --git a/solidity/truffle-examples/url-requests/package.json b/solidity/truffle-examples/url-requests/package.json index 22b80140..4813fa57 100644 --- a/solidity/truffle-examples/url-requests/package.json +++ b/solidity/truffle-examples/url-requests/package.json @@ -1,5 +1,5 @@ { - "name": "Oraclize Examples using Truffle: Computation-Datasource - Url Requests", + "name": "oraclize-examples-using-truffle__computation-datasource-url-requests", "version": "0.1.0", "description": "Testing set up for Oraclize's Url-Requests example contract", "main": "README.md", diff --git a/solidity/truffle-examples/url-requests/test/url-requests-tests.js b/solidity/truffle-examples/url-requests/test/url-requests-tests.js index 2ab48c12..1a629711 100644 --- a/solidity/truffle-examples/url-requests/test/url-requests-tests.js +++ b/solidity/truffle-examples/url-requests/test/url-requests-tests.js @@ -1,5 +1,5 @@ const Web3 = require('web3') -const waitForEvent = require('./utils') +const {waitForEvent} = require('./utils') const urlRequests = artifacts.require('./UrlRequests.sol') const web3 = new Web3(new Web3.providers.WebsocketProvider('ws://localhost:9545')) @@ -77,19 +77,19 @@ contract('Oraclize Example using Truffle', async accounts => { }) it('Should emit result from request for custom headers', async () => { - const {returnValues:{result}} = await waitForEvent(urlReq[0].events.emitResult) + const {returnValues:{result}} = await waitForEvent(urlReq[0].events.LogResult) const expRes = '{"Accept-Encoding": "gzip, deflate", "Host": "httpbin.org", "Accept": "*/*", "User-Agent": "python-requests/2.19.1", "Connection": "close", "Content-Type": "json"}' assert.equal(expRes, result, 'Incorrect result from custom header request!') }) it('Should emit result from basic auth request', async () => { - const {returnValues:{result}} = await waitForEvent(urlReq[1].events.emitResult) + const {returnValues:{result}} = await waitForEvent(urlReq[1].events.LogResult) const expRes = '{ \"authenticated\": true, \"user\": \"myuser\"}' assert.equal(expRes, result, 'Incorrect result from basic auth request!') }) it('Should emit result from POST request', async () => { - const {returnValues:{result}} = await waitForEvent(urlReq[2].events.emitResult) + const {returnValues:{result}} = await waitForEvent(urlReq[2].events.LogResult) const expRes = { "status": 200, "result": [{ @@ -133,7 +133,7 @@ contract('Oraclize Example using Truffle', async accounts => { }) it('Should emit result from PUT request', async () => { - const {returnValues:{result}} = await waitForEvent(urlReq[3].events.emitResult) + const {returnValues:{result}} = await waitForEvent(urlReq[3].events.LogResult) const expRes = { "args": {}, "data": "{\"testing\": \"it works\"}", @@ -162,7 +162,7 @@ contract('Oraclize Example using Truffle', async accounts => { }) it('Should emit result from cookie request', async () => { - const {returnValues:{result}} = await waitForEvent(urlReq[4].events.emitResult) + const {returnValues:{result}} = await waitForEvent(urlReq[4].events.LogResult) const expRes = `{ "cookies": { "thiscookie": "should be saved and visible :)" }}` assert.equal(expRes, result, 'Incorrect result from cookie request!') }) diff --git a/solidity/truffle-examples/url-requests/test/utils.js b/solidity/truffle-examples/url-requests/test/utils.js index 53f799f8..af5ed205 100644 --- a/solidity/truffle-examples/url-requests/test/utils.js +++ b/solidity/truffle-examples/url-requests/test/utils.js @@ -1,4 +1,8 @@ -module.exports = (_event, _from = 0, _to = 'latest') => +const waitForEvent = (_event, _from = 0, _to = 'latest') => new Promise ((resolve,reject) => _event({fromBlock: _from, toBlock: _to}, (e, ev) => e ? reject(e) : resolve(ev))) + +module.exports = { + waitForEvent +} From be34eadb2e3005a044dc84084d7f2885093859f8 Mon Sep 17 00:00:00 2001 From: Greg Kapka Date: Wed, 17 Oct 2018 21:16:40 +0100 Subject: [PATCH 13/14] tweak README to display tests image --- solidity/truffle-examples/url-requests/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/solidity/truffle-examples/url-requests/README.md b/solidity/truffle-examples/url-requests/README.md index 7d125dbb..b6ce7bbc 100644 --- a/solidity/truffle-examples/url-requests/README.md +++ b/solidity/truffle-examples/url-requests/README.md @@ -34,7 +34,7 @@ __`❍ test`__ ## :camera: Passing Tests: -[The passing tests!](https://github.com/oraclize/ethereum-examples/solidity/truffle-examples/url-requests/url-requests-tests.jpg) +![The passing tests!](url-requests-tests.jpg)   @@ -42,7 +42,7 @@ __`❍ test`__ __❍__ The computation data-source combined with the ethereum-bridge in a development environment can make for a slightly slower than usual response time for the Oraclize `__callback` - please be patient whilst this occurs! -__❍__ Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof is disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs is _not_ recommended, so don't forget to re-enable them for live deployments! +__❍__ Note also that the `UrlRequests.sol` smart-contract in `./contracts` has the proof-type commented out in the constructor. This is because the TLS-Notary proof has been disabled on test-nets due to abuse. Using Oraclize on the ethereum main-net _without_ proofs however is _not_ recommended, so don't forget to re-enable them for live deployments! __❍__ If you have any further issues, head on over to our [Gitter](https://gitter.im/oraclize/ethereum-api?raw=true) channel to get timely support! From 7616fa3e342a03827e3e2b3f29b01539c4de5e3c Mon Sep 17 00:00:00 2001 From: gregkapka Date: Thu, 18 Oct 2018 17:56:12 +0100 Subject: [PATCH 14/14] add slice to assertion to account for changes in module versions --- .../truffle-examples/url-requests/test/url-requests-tests.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/solidity/truffle-examples/url-requests/test/url-requests-tests.js b/solidity/truffle-examples/url-requests/test/url-requests-tests.js index 1a629711..95aba80f 100644 --- a/solidity/truffle-examples/url-requests/test/url-requests-tests.js +++ b/solidity/truffle-examples/url-requests/test/url-requests-tests.js @@ -79,7 +79,7 @@ contract('Oraclize Example using Truffle', async accounts => { it('Should emit result from request for custom headers', async () => { const {returnValues:{result}} = await waitForEvent(urlReq[0].events.LogResult) const expRes = '{"Accept-Encoding": "gzip, deflate", "Host": "httpbin.org", "Accept": "*/*", "User-Agent": "python-requests/2.19.1", "Connection": "close", "Content-Type": "json"}' - assert.equal(expRes, result, 'Incorrect result from custom header request!') + assert.equal(expRes.slice(0, 50), result.slice(0, 50), 'Incorrect result from custom header request!') }) it('Should emit result from basic auth request', async () => {