New Migrations

package.json

@@ -4,8 +4,9 @@
     "build:debugger": "cd packages/truffle-debugger && npm run build",
     "lerna:bootstrap": "lerna bootstrap",
     "bootstrap": "npm run lerna:bootstrap && npm run build:debugger",
-    "test": "lerna run test --stream -- --colors",
-    "ci": "./scripts/ci.sh"
+    "test": "lerna run test --stream --concurrency=1 -- --colors",
+    "ci": "./scripts/ci.sh",
+    "geth": "./scripts/geth.sh"
   },
   "devDependencies": {
     "lerna": "^2.11.0"
@@ -14,5 +15,6 @@
     "packages": [
       "packages/*"
     ]
-  }
+  },
+  "dependencies": {}
 }

packages/truffle-box/test/unbox.js

@@ -9,13 +9,8 @@ var TRUFFLE_BOX_DEFAULT = "git@github.com:trufflesuite/truffle-init-default.git"
 describe("Unbox", function() {
   var destination = path.join(__dirname, ".truffle_test_tmp");
 
-  before("mkdir", function(done) {
-    fs.ensureDir(destination, done);
-  });
-
-  after("remove tmp dir", function(done) {
-    fs.remove(destination, done);
-  });
+  before("mkdir", async() => fs.ensureDir(destination));
+  after("remove tmp dir", async() => fs.remove(destination));
 
   it("unboxes truffle box from github", function() {
     this.timeout(5000);
@@ -48,9 +43,7 @@ describe("Unbox", function() {
     // Assert our precondition
     assert(fs.existsSync(contracts_directory), "contracts directory should exist for this test to be meaningful");
 
-    fs.remove(contracts_directory, function(err) {
-      if (err) return done(err);
-
+    fs.remove(contracts_directory).then(() => {
       Box.unbox(TRUFFLE_BOX_DEFAULT, destination)
         .then(function(boxConfig) {
           assert(

packages/truffle-compile/scripts/test.sh

@@ -3,7 +3,7 @@
 set -o errexit
 
 if [ "$CI" = true ]; then
-  mocha --timeout 5000
+  mocha --timeout 10000
 else
-  mocha --invert --grep native --timeout 5000
+  mocha --invert --grep native --timeout 10000
 fi

packages/truffle-config/index.js

@@ -16,7 +16,7 @@ function Config(truffle_directory, working_directory, network) {
   var default_tx_values = {
     gas: 6721975,
     gasPrice: 100000000000, // 100 Shannon,
-    from: null
+    from: null,
   };
 
   this._values = {
@@ -28,6 +28,9 @@ function Config(truffle_directory, working_directory, network) {
     gas: null,
     gasPrice: null,
     from: null,
+    confirmations: 0,
+    timeoutBlocks: 0,
+    production: false,
     build: null,
     resolver: null,
     artifactor: null,
@@ -167,6 +170,42 @@ function Config(truffle_directory, working_directory, network) {
       set: function(val) {
         throw new Error("Don't set config.provider directly. Instead, set config.networks and then set config.networks[<network name>].provider")
       }
+    },
+    confirmations: {
+      get: function() {
+        try {
+          return self.network_config.confirmations;
+        } catch (e) {
+          return 0;
+        }
+      },
+      set: function(val) {
+        throw new Error("Don't set config.confirmations directly. Instead, set config.networks and then config.networks[<network name>].confirmations")
+      }
+    },
+    production: {
+      get: function() {
+        try {
+          return self.network_config.production;
+        } catch (e) {
+          return false;
+        }
+      },
+      set: function(val) {
+        throw new Error("Don't set config.production directly. Instead, set config.networks and then config.networks[<network name>].production")
+      }
+    },
+    timeoutBlocks: {
+      get: function(){
+        try {
+          return self.network_config.timeoutBlocks;
+        } catch (e) {
+          return 0;
+        }
+      },
+      set: function(val) {
+        throw new Error("Don't set config.timeoutBlocks directly. Instead, set config.networks and then config.networks[<network name>].timeoutBlocks")
+      }
     }
   };
 

packages/truffle-contract/lib/execute.js

@@ -5,12 +5,13 @@ var StatusError = require("./statuserror");
 var handlers = require("./handlers");
 var override = require("./override");
 
+var util = require('util');
 var execute = {
 
   // -----------------------------------  Helpers --------------------------------------------------
-
   /**
    * Retrieves gas estimate multiplied by the set gas multiplier for a `sendTransaction` call.
+   * We're using low level rpc calls here
    * @param  {Object} params     `sendTransaction` parameters
    * @param  {Number} blockLimit  most recent network block.blockLimit
    * @return {Number}             gas estimate
@@ -20,23 +21,44 @@ var execute = {
     var web3 = this.web3;
 
     return new Promise(function(accept, reject){
-      // Always prefer specified gas - this includes gas set by class_defaults
-      if (params.gas)           return accept(params.gas);
-      if (!constructor.autoGas) return accept();
-
-      web3.eth
-        .estimateGas(params)
-        .then(gas => {
-          var bestEstimate = Math.floor(constructor.gasMultiplier * gas);
-
-          // Don't go over blockLimit
-          (bestEstimate >= blockLimit)
-            ? accept(blockLimit - 1)
-            : accept(bestEstimate);
-
-        // We need to let txs that revert through.
-        // Often that's exactly what you are testing.
-        }).catch(err => accept());
+      let reason;
+
+      const packet = {
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [params],
+        id: new Date().getTime(),
+      }
+
+      // This rpc call extracts the reason string
+      web3.currentProvider.send(packet, (err, response) => {
+        if (response && (response.error || response.result)) {
+          reason = execute.extractReason(response, web3)
+        }
+
+        web3
+          .eth
+          .estimateGas(params)
+          .then(gas => {
+            // Always prefer specified gas - this includes gas set by class_defaults
+            if (params.gas)           return accept({gas: params.gas, error: null});
+            if (!constructor.autoGas) return accept({gas: null, error: null});
+
+            var bestEstimate = Math.floor(constructor.gasMultiplier * gas);
+
+            // Don't go over blockLimit
+            (bestEstimate >= blockLimit)
+              ? accept({gas: blockLimit - 1, error: null})
+              : accept({gas: bestEstimate, error: null});
+          })
+          .catch(err => {
+            err.reason = reason;
+
+            (params.gas)
+              ? accept({gas: params.gas, error: err})
+              : accept({gas: null, error: err});
+          })
+      })
     })
   },
 
@@ -65,6 +87,29 @@ var execute = {
     return utils.is_object(arg) && !utils.is_big_number(arg);
   },
 
+  /**
+   * Processes .call/.estimateGas errors and extracts a reason string if
+   *
+   * @param  {[type]} err [description]
+   * @return {[type]}     [description]
+   */
+  extractReason(res, web3){
+    const isObject = res && typeof res === 'object' && res.error && res.error.data;
+    const isString = res && typeof res === 'object' && typeof res.result === 'string';
+
+    if (isObject) {
+      const data = res.error.data;
+      const hash = Object.keys(data)[0];
+
+      if (data[hash].return && data[hash].return.includes('0x08c379a0')){
+        return web3.eth.abi.decodeParameter('string', data[hash].return.slice(10))
+      }
+
+    } else if (isString && res.result.includes('0x08c379a0')){
+      return web3.eth.abi.decodeParameter('string', res.result.slice(10))
+    }
+  },
+
   /**
    * Parses function arguments to discover if the terminal argument specifies the `defaultBlock`
    * to execute a call at.
@@ -131,6 +176,7 @@ var execute = {
       var args = Array.prototype.slice.call(arguments);
       var params = utils.getTxParams.call(constructor, args);
       var promiEvent = new Web3PromiEvent();
+      var reason;
 
       var context = {
         contract: constructor,   // Can't name this field `constructor` or `_constructor`
@@ -145,10 +191,21 @@ var execute = {
         execute
           .getGasEstimate
           .call(constructor, params, network.blockLimit)
-          .then(gas => {
-            params.gas = gas
+          .then(result => {
+            (result.error)
+              ? context.reason = result.error.reason
+              : context.reason = null;
+
+            params.gas = result.gas || undefined;
             deferred = web3.eth.sendTransaction(params);
-            deferred.catch(override.start.bind(constructor, context));
+
+            // vmErrorsOnResponse path. Client emulator will
+            // reject via the receipt handler
+            deferred.catch(err => {
+              err.reason = (result.error) ? result.error.reason : null;
+              override.start.call(constructor, context, err)
+            });
+
             handlers.setup(deferred, context);
           })
           .catch(promiEvent.reject)
@@ -173,6 +230,7 @@ var execute = {
     var web3 = constructor.web3;
     var params = utils.getTxParams.call(constructor, args);
     var deferred;
+    var reason;
 
     var options = {
       data: constructor.binary,
@@ -185,14 +243,17 @@ var execute = {
     execute
       .getGasEstimate
       .call(constructor, params, blockLimit)
-      .then(gas => {
-        params.gas = gas;
+      .then(result => {
+        if (result.error) reason = result.error.reason;
+
+        params.gas = result.gas || undefined;
         deferred = web3.eth.sendTransaction(params);
         handlers.setup(deferred, context);
 
         deferred.then(receipt => {
           if (parseInt(receipt.status) == 0){
             var error = new StatusError(params, context.transactionHash, receipt);
+            error.reason = reason;
             return context.promiEvent.reject(error)
           }
 
@@ -201,9 +262,12 @@ var execute = {
 
           context.promiEvent.resolve(new constructor(web3Instance));
 
-        // Manage web3's 50 blocks' timeout error.
-        // Web3's own subscriptions go dead here.
-        }).catch(override.start.bind(constructor, context))
+        // Manage web3's 50 blocks' timeout error. Web3's own subscriptions go dead here.
+        // Also propagate any reason strings captured during estimate gas.
+        }).catch(err => {
+          err.reason = reason;
+          override.start.call(constructor, context, err)
+        })
       }).catch(context.promiEvent.reject);
   },
 

packages/truffle-contract/lib/handlers.js

@@ -104,6 +104,7 @@ var handlers = {
     // .method(): resolve/reject receipt in handler
     if (parseInt(receipt.status) == 0 && !context.onlyEmitReceipt){
       var error = new StatusError(context.params, receipt.transactionHash, receipt);
+      error.reason = context.reason;
       return context.promiEvent.reject(error)
     }
 

packages/truffle-contract/lib/override.js

@@ -2,8 +2,9 @@ var subscriptions = require("./subscriptions");
 
 var override = {
 
-  timeoutMessage: '50 blocks', // Substring of timeout err fired by web3
-  defaultMaxBlocks: 50,        // Max # of blocks web3 will wait for a tx
+  timeoutMessage: 'not mined within', // Substring of timeout err fired by web3
+  defaultMaxBlocks: 50,               // Max # of blocks web3 will wait for a tx
+  pollingInterval: 1000,
 
   /**
    * Fired after web3 ceases to support subscriptions if user has specified
@@ -14,7 +15,7 @@ var override = {
    * @param  {Object} context execution state
    * @param  {Object} err     error
    */
-  start: function(context, web3Error){
+  start: async function(context, web3Error){
     var constructor = this;
     var blockNumber = null;
     var currentBlock = override.defaultMaxBlocks;
@@ -27,23 +28,19 @@ var override = {
     if (!timedOut || !shouldWait) return context.promiEvent.reject(web3Error);
 
     // This will run every block from now until contract.timeoutBlocks
-    var listener = function(err, data){
+    var listener = function(pollID){
       var self = this;
       currentBlock++;
 
       if (currentBlock > constructor.timeoutBlocks){
-        subscriptions.unsubscribe(constructor, id);
-        self.removeListener('data', listener);
-        context.promiEvent.reject(err);
+        clearInterval(pollID)
         return;
       }
 
       constructor.web3.eth.getTransactionReceipt(context.transactionHash)
         .then(result => {
           if (!result) return;
 
-          //self.removeListener('data', listener);
-
           (result.contractAddress)
             ? constructor
                 .at(result.contractAddress)
@@ -52,16 +49,35 @@ var override = {
 
             : constructor.promiEvent.resolve(result);
 
-        }).catch(err => {
-          //self.removeListener('data', listener);
+        })
+        .catch(err => {
+          clearInterval(pollID)
           context.promiEvent.reject(err);
         });
     };
 
+    // Start polling
+    let currentPollingBlock = await constructor.web3.eth.getBlockNumber();
+
+    const pollID = setInterval(async() => {
+      const newBlock = await constructor.web3.eth.getBlockNumber();
+
+      if(newBlock > currentPollingBlock){
+        currentPollingBlock = newBlock;
+        listener(pollID);
+      }
+    }, override.pollingInterval);
+
+
+    // Temporarily disabled new_head subscription. There are bugs at Web3 and at
+    // Geth that impair the reliablility of this sub atm.
+
+    /*
     var id = new Date().getTime();
     subscriptions.subscribe(constructor, 'newHeads', id)
       .then(result => constructor.web3.currentProvider.on('data', listener))
       .catch(context.promiEvent.reject);
+    */
   },
 }