1935

pending completion

Build # 1935

Build Type

Pull #1409

travis-ci

Committed by

web-flow

Commit Message

Convert BN/BigNumber input params to Ethers BN

Signed-off-by: Ben Burns <benjamin.c.burns@gmail.com>

Pull Request Pull Request #1409: web3 1.0.0-beta.36 - enables ABIv2 struct params

Run Details

1573 of 2699 branches covered (58.28%)

Branch coverage included in aggregate %.

96 of 96 new or added lines in 2 files covered. (100.0%)

4887 of 6938 relevant lines covered (70.44%)

13408.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.09

/packages/truffle-contract/lib/execute.js

var Web3PromiEvent = require("web3-core-promievent");
var EventEmitter = require("events");
var utils = require("./utils");
var StatusError = require("./statuserror");
var Reason = require("./reason");
var handlers = require("./handlers");
var override = require("./override");
var reformat = require("./reformat");

var execute = {
  // -----------------------------------  Helpers --------------------------------------------------
  /**
   * Retrieves gas estimate multiplied by the set gas multiplier for a `sendTransaction` call.
   * @param  {Object} params     `sendTransaction` parameters
   * @param  {Number} blockLimit  most recent network block.blockLimit
   * @return {Number}             gas estimate
   */
  getGasEstimate: function(params, blockLimit) {
    var constructor = this;
    var web3 = this.web3;

    return new Promise(function(accept) {
      // 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(() => accept());
    });
  },

  /**
   * Prepares simple wrapped calls by checking network and organizing the method inputs into
   * objects web3 can consume.
   * @param  {Object} constructor   TruffleContract constructor
   * @param  {Array}  _arguments    Arguments passed to method invocation
   * @return {Promise}              Resolves object w/ tx params disambiguated from arguments
   */
  prepareCall: function(constructor, _arguments) {
    var args = Array.prototype.slice.call(_arguments);
    var params = utils.getTxParams.call(constructor, args);

    args = utils.convertToEthersBN(args);

    return constructor.detectNetwork().then(() => {
      return { args: args, params: params };
    });
  },

  /**
   * Disambiguates between transaction parameter objects and BN / BigNumber objects
   * @param  {Any}  arg
   * @return {Boolean}
   */
  hasTxParams: function(arg) {
    return utils.is_object(arg) && !utils.is_big_number(arg);
  },

  /**
   * Parses function arguments to discover if the terminal argument specifies the `defaultBlock`
   * to execute a call at.
   * @param  {Array}  args      `arguments` that were passed to method
   * @param  {Any}    lastArg    terminal argument passed to method
   * @param  {Array}  inputs     ABI segment defining method arguments
   * @return {Boolean}           true if final argument is `defaultBlock`
   */
  hasDefaultBlock: function(args, lastArg, inputs) {
    var hasDefaultBlock =
      !execute.hasTxParams(lastArg) && args.length > inputs.length;
    var hasDefaultBlockWithParams =
      execute.hasTxParams(lastArg) && args.length - 1 > inputs.length;
    return hasDefaultBlock || hasDefaultBlockWithParams;
  },

  // -----------------------------------  Methods --------------------------------------------------

  /**
   * Executes method as .call and processes optional `defaultBlock` argument.
   * @param  {Function} fn         method
   * @param  {Object}   methodABI  function ABI segment w/ inputs & outputs keys.
   * @return {Promise}             Return value of the call.
   */
  call: function(fn, methodABI, address) {
    var constructor = this;

    return function() {
      var params = {};
      var defaultBlock = "latest";
      var args = Array.prototype.slice.call(arguments);
      var lastArg = args[args.length - 1];

      // Extract defaultBlock parameter
      if (execute.hasDefaultBlock(args, lastArg, methodABI.inputs)) {
        defaultBlock = args.pop();
      }

      // Extract tx params
      if (execute.hasTxParams(lastArg)) {
        params = args.pop();
      }

      params.to = address;
      params = utils.merge(constructor.class_defaults, params);

      return new Promise(async (resolve, reject) => {
        let result;
        try {
          await constructor.detectNetwork();
          args = utils.convertToEthersBN(args);
          result = await fn(...args).call(params, defaultBlock);
          result = reformat.numbers.call(
            constructor,
            result,
            methodABI.outputs
          );
          resolve(result);
        } catch (err) {
          reject(err);
        }
      });
    };
  },

  /**
   * Executes method as .send
   * @param  {Function}   fn       Method to invoke
   * @param  {String}     address  Deployed address of the targeted instance
   * @return {PromiEvent}          Resolves a transaction receipt (via the receipt handler)
   */
  send: function(fn, address) {
    var constructor = this;
    var web3 = constructor.web3;

    return function() {
      var deferred;
      var args = Array.prototype.slice.call(arguments);
      var params = utils.getTxParams.call(constructor, args);
      var promiEvent = new Web3PromiEvent();

      var context = {
        contract: constructor, // Can't name this field `constructor` or `_constructor`
        promiEvent: promiEvent,
        params: params
      };

      constructor
        .detectNetwork()
        .then(network => {
          args = utils.convertToEthersBN(args);
          params.to = address;
          params.data = fn ? fn(...args).encodeABI() : undefined;

          execute.getGasEstimate
            .call(constructor, params, network.blockLimit)
            .then(gas => {
              params.gas = gas;
              deferred = web3.eth.sendTransaction(params);
              deferred.catch(override.start.bind(constructor, context));
              handlers.setup(deferred, context);
            })
            .catch(promiEvent.reject);
        })
        .catch(promiEvent.reject);

      return promiEvent.eventEmitter;
    };
  },

  /**
   * Deploys an instance. Network detection for `.new` happens before invocation at `contract.js`
   * where we check the libraries.
   * @param  {Object} args        Deployment options;
   * @param  {Object} context     Context object that exposes execution state to event handlers.
   * @param  {Number} blockLimit  `block.gasLimit`
   * @return {PromiEvent}         Resolves a TruffleContract instance
   */
  deploy: function(args, context, blockLimit) {
    var constructor = this;
    var abi = constructor.abi;
    var web3 = constructor.web3;
    var params = utils.getTxParams.call(constructor, args);
    var deferred;

    var options = {
      data: constructor.binary,
      arguments: utils.convertToEthersBN(args)
    };

    var contract = new web3.eth.Contract(abi);
    params.data = contract.deploy(options).encodeABI();

    execute.getGasEstimate
      .call(constructor, params, blockLimit)
      .then(gas => {
        params.gas = gas;
        context.params = params;
        deferred = web3.eth.sendTransaction(params);
        handlers.setup(deferred, context);

        deferred
          .then(async receipt => {
            if (receipt.status !== undefined && !receipt.status) {
              var reason = await Reason.get(params, web3);

              var error = new StatusError(
                params,
                context.transactionHash,
                receipt,
                reason
              );

              return context.promiEvent.reject(error);
            }

            var web3Instance = new web3.eth.Contract(
              abi,
              receipt.contractAddress
            );
            web3Instance.transactionHash = context.transactionHash;

            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));
      })
      .catch(context.promiEvent.reject);
  },

  /**
   * Begins listening for an event OR manages the event callback
   * @param  {Function} fn  Solidity event method
   * @return {Emitter}      Event emitter
   */
  event: function(fn) {
    var constructor = this;
    var decode = utils.decodeLogs;
    var currentLogID = null;

    // Someone upstream is firing duplicates :/
    function dedupe(id) {
      return id === currentLogID ? false : (currentLogID = id);
    }

    return function(params, callback) {
      if (typeof params == "function") {
        callback = params;
        params = {};
      }

      // As callback
      if (callback !== undefined) {
        var intermediary = function(err, e) {
          if (err) callback(err);
          var event = dedupe(e.id) && decode.call(constructor, e, true)[0];
          callback(null, event);
        };

        return constructor
          .detectNetwork()
          .then(() => fn.call(constructor.events, params, intermediary));
      }

      // As EventEmitter
      var emitter = new EventEmitter();

      constructor.detectNetwork().then(() => {
        var event = fn(params);

        event.on(
          "data",
          e =>
            dedupe(e.id) &&
            emitter.emit("data", decode.call(constructor, e, true)[0])
        );
        event.on(
          "changed",
          e =>
            dedupe(e.id) &&
            emitter.emit("changed", decode.call(constructor, e, true)[0])
        );
        event.on("error", e => emitter.emit("error", e));
      });

      return emitter;
    };
  },

  /**
   * Wraps web3 `allEvents`, with additional log decoding
   * @return {PromiEvent}  EventEmitter
   */
  allEvents: function(web3Instance) {
    var constructor = this;
    var decode = utils.decodeLogs;
    var currentLogID = null;

    // Someone upstream is firing duplicates :/
    function dedupe(id) {
      return id === currentLogID ? false : (currentLogID = id);
    }

    return function(params) {
      var emitter = new EventEmitter();

      constructor.detectNetwork().then(() => {
        var event = web3Instance.events.allEvents(params);

        event.on(
          "data",
          e =>
            dedupe(e.id) &&
            emitter.emit("data", decode.call(constructor, e, true)[0])
        );
        event.on(
          "changed",
          e =>
            dedupe(e.id) &&
            emitter.emit("changed", decode.call(constructor, e, true)[0])
        );
        event.on("error", e => emitter.emit("error", e));
      });

      return emitter;
    };
  },

  /**
   * Wraps web3 `getPastEvents`, with additional log decoding
   * @return {Promise}  Resolves array of event objects
   */
  getPastEvents: function(web3Instance) {
    var constructor = this;
    var decode = utils.decodeLogs;

    return function(event, options) {
      return web3Instance
        .getPastEvents(event, options)
        .then(events => decode.call(constructor, events, false));
    };
  },

  /**
   * Estimates gas cost of a method invocation
   * @param  {Function} fn  Method to target
   * @return {Promise}
   */
  estimate: function(fn) {
    var constructor = this;
    return function() {
      return execute
        .prepareCall(constructor, arguments)
        .then(res => fn(...res.args).estimateGas(res.params));
    };
  },

  request: function(fn) {
    var constructor = this;
    return function() {
      return execute
        .prepareCall(constructor, arguments)
        .then(res => fn(...res.args).request(res.params));
    };
  },

  // This gets attached to `.new` (declared as a static_method in `contract`)
  // during bootstrapping as `estimate`
  estimateDeployment: function() {
    var constructor = this;
    return execute.prepareCall(constructor, arguments).then(res => {
      var options = {
        data: constructor.binary,
        arguments: res.args
      };

      delete res.params["data"]; // Is this necessary?

      var instance = new constructor.web3.eth.Contract(
        constructor.abi,
        res.params
      );
      return instance.deploy(options).estimateGas(res.params);
    });
  }
};

module.exports = execute;

1	var Web3PromiEvent = require("web3-core-promievent");	105✔
2	var EventEmitter = require("events");	105✔
3	var utils = require("./utils");	105✔
4	var StatusError = require("./statuserror");	105✔
5	var Reason = require("./reason");	105✔
6	var handlers = require("./handlers");	105✔
7	var override = require("./override");	105✔
8	var reformat = require("./reformat");	105✔
9
10	var execute = {	105✔
11	// ----------------------------------- Helpers --------------------------------------------------
12	/**
13	* Retrieves gas estimate multiplied by the set gas multiplier for a `sendTransaction` call.
14	* @param {Object} params `sendTransaction` parameters
15	* @param {Number} blockLimit most recent network block.blockLimit
16	* @return {Number} gas estimate
17	*/
18	getGasEstimate: function(params, blockLimit) {
19	var constructor = this;	411✔
20	var web3 = this.web3;	411✔
21
22	return new Promise(function(accept) {	411✔
23	// Always prefer specified gas - this includes gas set by class_defaults
24	if (params.gas) return accept(params.gas);	411✔
25	if (!constructor.autoGas) return accept();	144✔
26
27	web3.eth	143✔
28	.estimateGas(params)
29	.then(gas => {
30	var bestEstimate = Math.floor(constructor.gasMultiplier * gas);	126✔
31
32	// Don't go over blockLimit
33	bestEstimate >= blockLimit	126✔
34	? accept(blockLimit - 1)
35	: accept(bestEstimate);
36
37	// We need to let txs that revert through.
38	// Often that's exactly what you are testing.
39	})
40	.catch(() => accept());	17✔
41	});
42	},
43
44	/**
45	* Prepares simple wrapped calls by checking network and organizing the method inputs into
46	* objects web3 can consume.
47	* @param {Object} constructor TruffleContract constructor
48	* @param {Array} _arguments Arguments passed to method invocation
49	* @return {Promise} Resolves object w/ tx params disambiguated from arguments
50	*/
51	prepareCall: function(constructor, _arguments) {
52	var args = Array.prototype.slice.call(_arguments);	173✔
53	var params = utils.getTxParams.call(constructor, args);	173✔
54
55	args = utils.convertToEthersBN(args);	173✔
56
57	return constructor.detectNetwork().then(() => {	173✔
58	return { args: args, params: params };	173✔
59	});
60	},
61
62	/**
63	* Disambiguates between transaction parameter objects and BN / BigNumber objects
64	* @param {Any} arg
65	* @return {Boolean}
66	*/
67	hasTxParams: function(arg) {
68	return utils.is_object(arg) && !utils.is_big_number(arg);	435✔
69	},
70
71	/**
72	* Parses function arguments to discover if the terminal argument specifies the `defaultBlock`
73	* to execute a call at.
74	* @param {Array} args `arguments` that were passed to method
75	* @param {Any} lastArg terminal argument passed to method
76	* @param {Array} inputs ABI segment defining method arguments
77	* @return {Boolean} true if final argument is `defaultBlock`
78	*/
79	hasDefaultBlock: function(args, lastArg, inputs) {
80	var hasDefaultBlock =
81	!execute.hasTxParams(lastArg) && args.length > inputs.length;	145✔
82	var hasDefaultBlockWithParams =
83	execute.hasTxParams(lastArg) && args.length - 1 > inputs.length;	145✔
84	return hasDefaultBlock \|\| hasDefaultBlockWithParams;	145✔
85	},
86
87	// ----------------------------------- Methods --------------------------------------------------
88
89	/**
90	* Executes method as .call and processes optional `defaultBlock` argument.
91	* @param {Function} fn method
92	* @param {Object} methodABI function ABI segment w/ inputs & outputs keys.
93	* @return {Promise} Return value of the call.
94	*/
95	call: function(fn, methodABI, address) {
96	var constructor = this;	10,587✔
97
98	return function() {	10,587✔
99	var params = {};	145✔
100	var defaultBlock = "latest";	145✔
101	var args = Array.prototype.slice.call(arguments);	145✔
102	var lastArg = args[args.length - 1];	145✔
103
104	// Extract defaultBlock parameter
105	if (execute.hasDefaultBlock(args, lastArg, methodABI.inputs)) {	145✔
106	defaultBlock = args.pop();	4✔
107	}
108
109	// Extract tx params
110	if (execute.hasTxParams(lastArg)) {	145✔
111	params = args.pop();	2✔
112	}
113
114	params.to = address;	145✔
115	params = utils.merge(constructor.class_defaults, params);	145✔
116
117	return new Promise(async (resolve, reject) => {	145✔
118	let result;
119	try {	145✔
120	await constructor.detectNetwork();	145✔
121	args = utils.convertToEthersBN(args);	145✔
122	result = await fn(...args).call(params, defaultBlock);	145✔
123	result = reformat.numbers.call(	143✔
124	constructor,
125	result,
126	methodABI.outputs
127	);
128	resolve(result);	143✔
129	} catch (err) {
130	reject(err);	2✔
131	}
132	});
133	};
134	},
135
136	/**
137	* Executes method as .send
138	* @param {Function} fn Method to invoke
139	* @param {String} address Deployed address of the targeted instance
140	* @return {PromiEvent} Resolves a transaction receipt (via the receipt handler)
141	*/
142	send: function(fn, address) {
143	var constructor = this;	11,423✔
144	var web3 = constructor.web3;	11,423✔
145
146	return function() {	11,423✔
147	var deferred;
148	var args = Array.prototype.slice.call(arguments);	149✔
149	var params = utils.getTxParams.call(constructor, args);	149✔
150	var promiEvent = new Web3PromiEvent();	149✔
151
152	var context = {	149✔
153	contract: constructor, // Can't name this field `constructor` or `_constructor`
154	promiEvent: promiEvent,
155	params: params
156	};
157
158	constructor	149✔
159	.detectNetwork()
160	.then(network => {
161	args = utils.convertToEthersBN(args);	149✔
162	params.to = address;	149✔
163	params.data = fn ? fn(...args).encodeABI() : undefined;	149✔
164
165	execute.getGasEstimate	147✔
166	.call(constructor, params, network.blockLimit)
167	.then(gas => {
168	params.gas = gas;	147✔
169	deferred = web3.eth.sendTransaction(params);	147✔
170	deferred.catch(override.start.bind(constructor, context));	147✔
171	handlers.setup(deferred, context);	147✔
172	})
173	.catch(promiEvent.reject);
174	})
175	.catch(promiEvent.reject);
176
177	return promiEvent.eventEmitter;	149✔
178	};
179	},
180
181	/**
182	* Deploys an instance. Network detection for `.new` happens before invocation at `contract.js`
183	* where we check the libraries.
184	* @param {Object} args Deployment options;
185	* @param {Object} context Context object that exposes execution state to event handlers.
186	* @param {Number} blockLimit `block.gasLimit`
187	* @return {PromiEvent} Resolves a TruffleContract instance
188	*/
189	deploy: function(args, context, blockLimit) {
190	var constructor = this;	266✔
191	var abi = constructor.abi;	266✔
192	var web3 = constructor.web3;	266✔
193	var params = utils.getTxParams.call(constructor, args);	266✔
194	var deferred;
195
196	var options = {	266✔
197	data: constructor.binary,
198	arguments: utils.convertToEthersBN(args)
199	};
200
201	var contract = new web3.eth.Contract(abi);	266✔
202	params.data = contract.deploy(options).encodeABI();	266✔
203
204	execute.getGasEstimate	264✔
205	.call(constructor, params, blockLimit)
206	.then(gas => {
207	params.gas = gas;	264✔
208	context.params = params;	264✔
209	deferred = web3.eth.sendTransaction(params);	264✔
210	handlers.setup(deferred, context);	264✔
211
212	deferred	264✔
213	.then(async receipt => {
214	if (receipt.status !== undefined && !receipt.status) {	238✔
215	var reason = await Reason.get(params, web3);	4✔
216
217	var error = new StatusError(	4✔
218	params,
219	context.transactionHash,
220	receipt,
221	reason
222	);
223
224	return context.promiEvent.reject(error);	4✔
225	}
226
227	var web3Instance = new web3.eth.Contract(	234✔
228	abi,
229	receipt.contractAddress
230	);
231	web3Instance.transactionHash = context.transactionHash;	234✔
232
233	context.promiEvent.resolve(new constructor(web3Instance));	234✔
234
235	// Manage web3's 50 blocks' timeout error.
236	// Web3's own subscriptions go dead here.
237	})
238	.catch(override.start.bind(constructor, context));
239	})
240	.catch(context.promiEvent.reject);
241	},
242
243	/**
244	* Begins listening for an event OR manages the event callback
245	* @param {Function} fn Solidity event method
246	* @return {Emitter} Event emitter
247	*/
248	event: function(fn) {
249	var constructor = this;	396✔
250	var decode = utils.decodeLogs;	396✔
251	var currentLogID = null;	396✔
252
253	// Someone upstream is firing duplicates :/
254	function dedupe(id) {
255	return id === currentLogID ? false : (currentLogID = id);	8!
256	}
257
258	return function(params, callback) {	396✔
259	if (typeof params == "function") {	6✔
260	callback = params;	1✔
261	params = {};	1✔
262	}
263
264	// As callback
265	if (callback !== undefined) {	6✔
266	var intermediary = function(err, e) {	1✔
267	if (err) callback(err);	1!
268	var event = dedupe(e.id) && decode.call(constructor, e, true)[0];	1✔
269	callback(null, event);	1✔
270	};
271
272	return constructor	1✔
273	.detectNetwork()
274	.then(() => fn.call(constructor.events, params, intermediary));	1✔
275	}
276
277	// As EventEmitter
278	var emitter = new EventEmitter();	5✔
279
280	constructor.detectNetwork().then(() => {	5✔
281	var event = fn(params);	5✔
282
283	event.on(	5✔
284	"data",
285	e =>
286	dedupe(e.id) &&	7✔
287	emitter.emit("data", decode.call(constructor, e, true)[0])
288	);
289	event.on(	5✔
290	"changed",
291	e =>
292	dedupe(e.id) &&	×
293	emitter.emit("changed", decode.call(constructor, e, true)[0])
294	);
295	event.on("error", e => emitter.emit("error", e));	5✔
296	});
297
298	return emitter;	5✔
299	};
300	},
301
302	/**
303	* Wraps web3 `allEvents`, with additional log decoding
304	* @return {PromiEvent} EventEmitter
305	*/
306	allEvents: function(web3Instance) {
307	var constructor = this;	380✔
308	var decode = utils.decodeLogs;	380✔
309	var currentLogID = null;	380✔
310
311	// Someone upstream is firing duplicates :/
312	function dedupe(id) {
313	return id === currentLogID ? false : (currentLogID = id);	2!
314	}
315
316	return function(params) {	380✔
317	var emitter = new EventEmitter();	1✔
318
319	constructor.detectNetwork().then(() => {	1✔
320	var event = web3Instance.events.allEvents(params);	1✔
321
322	event.on(	1✔
323	"data",
324	e =>
325	dedupe(e.id) &&	2✔
326	emitter.emit("data", decode.call(constructor, e, true)[0])
327	);
328	event.on(	1✔
329	"changed",
330	e =>
331	dedupe(e.id) &&	×
332	emitter.emit("changed", decode.call(constructor, e, true)[0])
333	);
334	event.on("error", e => emitter.emit("error", e));	1✔
335	});
336
337	return emitter;	1✔
338	};
339	},
340
341	/**
342	* Wraps web3 `getPastEvents`, with additional log decoding
343	* @return {Promise} Resolves array of event objects
344	*/
345	getPastEvents: function(web3Instance) {
346	var constructor = this;	380✔
347	var decode = utils.decodeLogs;	380✔
348
349	return function(event, options) {	380✔
350	return web3Instance	4✔
351	.getPastEvents(event, options)
352	.then(events => decode.call(constructor, events, false));	4✔
353	};
354	},
355
356	/**
357	* Estimates gas cost of a method invocation
358	* @param {Function} fn Method to target
359	* @return {Promise}
360	*/
361	estimate: function(fn) {
362	var constructor = this;	7,210✔
363	return function() {	7,210✔
364	return execute	2✔
365	.prepareCall(constructor, arguments)
366	.then(res => fn(...res.args).estimateGas(res.params));	2✔
367	};
368	},
369
370	request: function(fn) {
371	var constructor = this;	7,210✔
372	return function() {	7,210✔
373	return execute	×
374	.prepareCall(constructor, arguments)
375	.then(res => fn(...res.args).request(res.params));	×
376	};
377	},
378
379	// This gets attached to `.new` (declared as a static_method in `contract`)
380	// during bootstrapping as `estimate`
381	estimateDeployment: function() {
382	var constructor = this;	171✔
383	return execute.prepareCall(constructor, arguments).then(res => {	171✔
384	var options = {	171✔
385	data: constructor.binary,
386	arguments: res.args
387	};
388
389	delete res.params["data"]; // Is this necessary?	171✔
390
391	var instance = new constructor.web3.eth.Contract(	171✔
392	constructor.abi,
393	res.params
394	);
395	return instance.deploy(options).estimateGas(res.params);	171✔
396	});
397	}
398	};
399
400	module.exports = execute;	105✔

trufflesuite / truffle / 1935

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous