4057

pending completion

Build # 4057

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #2000 from ethereum/ethereumProvider

EthereumProvider and the related refactoring

Run Details

1056 of 1346 branches covered (78.45%)

2636 of 2636 new or added lines in 149 files covered. (100.0%)

2465 of 2659 relevant lines covered (92.7%)

60.94 hits per line

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

90.48

/packages/web3-core-method/src/workflows/TransactionConfirmationWorkflow.js

/*
    This file is part of web3.js.

    web3.js is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    web3.js is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
*/
/**
 * @file TransactionConfirmationWorkflow.js
 * @author Samuel Furter <samuel@ethereum.org>
 * @date 2018
 */

export default class TransactionConfirmationWorkflow {
    /**
     * @param {TransactionReceiptValidator} transactionReceiptValidator
     * @param {NewHeadsWatcher} newHeadsWatcher
     * @param {GetTransactionReceiptMethod} getTransactionReceiptMethod
     *
     * @constructor
     */
    constructor(transactionReceiptValidator, newHeadsWatcher, getTransactionReceiptMethod) {
        this.transactionReceiptValidator = transactionReceiptValidator;
        this.newHeadsWatcher = newHeadsWatcher;
        this.timeoutCounter = 0;
        this.confirmationsCounter = 0;
        this.getTransactionReceiptMethod = getTransactionReceiptMethod;
    }

    /**
     * TODO: Remove callback method here and do it with a promise.
     *
     * Executes the transaction confirmation workflow
     *
     * @method execute
     *
     * @param {AbstractMethod} method
     * @param {AbstractWeb3Module} moduleInstance
     * @param {String} transactionHash
     * @param {PromiEvent} promiEvent
     *
     * @callback callback callback(error, result)
     */
    execute(method, moduleInstance, transactionHash, promiEvent) {
        this.getTransactionReceiptMethod.parameters = [transactionHash];

        this.getTransactionReceiptMethod.execute(moduleInstance).then((receipt) => {
            if (receipt && receipt.blockHash) {
                const validationResult = this.transactionReceiptValidator.validate(receipt, method.parameters);
                if (validationResult === true) {
                    this.handleSuccessState(receipt, method, promiEvent);

                    return;
                }

                this.handleErrorState(validationResult, method, promiEvent);

                return;
            }

            this.newHeadsWatcher.watch(moduleInstance).on('newHead', () => {
                this.timeoutCounter++;
                if (!this.isTimeoutTimeExceeded(moduleInstance, this.newHeadsWatcher.isPolling)) {
                    this.getTransactionReceiptMethod.execute(moduleInstance).then((receipt) => {
                        const validationResult = this.transactionReceiptValidator.validate(receipt, method.parameters);

                        if (validationResult === true) {
                            this.confirmationsCounter++;
                            promiEvent.emit('confirmation', this.confirmationsCounter, receipt);

                            if (this.isConfirmed(moduleInstance)) {
                                this.handleSuccessState(receipt, method, promiEvent);
                            }

                            return;
                        }

                        this.handleErrorState(validationResult, method, promiEvent);
                    });

                    return;
                }

                let error = new Error(
                    `Transaction was not mined within ${
                        moduleInstance.transactionBlockTimeout
                    } blocks, please make sure your transaction was properly sent. Be aware that it might still be mined!`
                );

                if (this.newHeadsWatcher.isPolling) {
                    error = new Error(
                        `Transaction was not mined within ${
                            moduleInstance.transactionPollingTimeout
                        } seconds, please make sure your transaction was properly sent. Be aware that it might still be mined!`
                    );
                }

                this.handleErrorState(error, method, promiEvent);
            });
        });
    }

    /**
     * Checks if the transaction has enough confirmations
     *
     * @method isConfirmed
     *
     * @param {AbstractWeb3Module} moduleInstance
     *
     * @returns {Boolean}
     */
    isConfirmed(moduleInstance) {
        return this.confirmationsCounter === moduleInstance.transactionConfirmationBlocks;
    }

    /**
     * Checks if the timeout time is reached
     *
     * @method isTimeoutTimeExceeded
     *
     * @param {AbstractWeb3Module} moduleInstance
     * @param {Boolean} watcherIsPolling
     *
     * @returns {Boolean}
     */
    isTimeoutTimeExceeded(moduleInstance, watcherIsPolling) {
        let timeout = moduleInstance.transactionBlockTimeout;
        if (watcherIsPolling) {
            timeout = moduleInstance.transactionPollingTimeout;
        }

        return this.timeoutCounter > timeout;
    }

    /**
     * Resolves promise, emits receipt event, calls callback and removes all the listeners.
     *
     * @method handleSuccessState
     *
     * @param {Object} receipt
     * @param {AbstractMethod} method
     * @param {PromiEvent} promiEvent
     *
     * @callback callback callback(error, result)
     */
    handleSuccessState(receipt, method, promiEvent) {
        this.timeoutCounter = 0;
        this.confirmationsCounter = 0;
        this.newHeadsWatcher.stop();

        if (method.constructor.name === 'ContractDeployMethod') {
            if (method.callback) {
                method.callback(false, receipt);
            }

            promiEvent.resolve(method.afterExecution(receipt));
            promiEvent.emit('receipt', receipt);
            promiEvent.removeAllListeners();

            return;
        }

        const mappedReceipt = method.afterExecution(receipt);

        if (method.callback) {
            method.callback(false, mappedReceipt);
        }

        promiEvent.resolve(mappedReceipt);
        promiEvent.emit('receipt', mappedReceipt);
        promiEvent.removeAllListeners();
    }

    /**
     * Rejects promise, emits error event, calls callback and removes all the listeners.
     *
     * @method handleErrorState
     *
     * @param {Error} error
     * @param {AbstractMethod} method
     * @param {PromiEvent} promiEvent
     *
     * @callback callback callback(error, result)
     */
    handleErrorState(error, method, promiEvent) {
        this.timeoutCounter = 0;
        this.confirmationsCounter = 0;
        this.newHeadsWatcher.stop();

        if (method.callback) {
            method.callback(error, null);
        }

        promiEvent.reject(error);
        promiEvent.emit('error', error);
        promiEvent.removeAllListeners();
    }
}

1	/*
2	This file is part of web3.js.
3
4	web3.js is free software: you can redistribute it and/or modify
5	it under the terms of the GNU Lesser General Public License as published by
6	the Free Software Foundation, either version 3 of the License, or
7	(at your option) any later version.
8
9	web3.js is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	GNU Lesser General Public License for more details.
13
14	You should have received a copy of the GNU Lesser General Public License
15	along with web3.js. If not, see <http://www.gnu.org/licenses/>.
16	*/
17	/**
18	* @file TransactionConfirmationWorkflow.js
19	* @author Samuel Furter <samuel@ethereum.org>
20	* @date 2018
21	*/
22
23	export default class TransactionConfirmationWorkflow {
24	/**
25	* @param {TransactionReceiptValidator} transactionReceiptValidator
26	* @param {NewHeadsWatcher} newHeadsWatcher
27	* @param {GetTransactionReceiptMethod} getTransactionReceiptMethod
28	*
29	* @constructor
30	*/
31	constructor(transactionReceiptValidator, newHeadsWatcher, getTransactionReceiptMethod) {
32	this.transactionReceiptValidator = transactionReceiptValidator;	48✔
33	this.newHeadsWatcher = newHeadsWatcher;	48✔
34	this.timeoutCounter = 0;	48✔
35	this.confirmationsCounter = 0;	48✔
36	this.getTransactionReceiptMethod = getTransactionReceiptMethod;	48✔
37	}
38
39	/**
40	* TODO: Remove callback method here and do it with a promise.
41	*
42	* Executes the transaction confirmation workflow
43	*
44	* @method execute
45	*
46	* @param {AbstractMethod} method
47	* @param {AbstractWeb3Module} moduleInstance
48	* @param {String} transactionHash
49	* @param {PromiEvent} promiEvent
50	*
51	* @callback callback callback(error, result)
52	*/
53	execute(method, moduleInstance, transactionHash, promiEvent) {
54	this.getTransactionReceiptMethod.parameters = [transactionHash];	36✔
55
56	this.getTransactionReceiptMethod.execute(moduleInstance).then((receipt) => {	36✔
57	if (receipt && receipt.blockHash) {	36✔
58	const validationResult = this.transactionReceiptValidator.validate(receipt, method.parameters);	18✔
59	if (validationResult === true) {	18✔
60	this.handleSuccessState(receipt, method, promiEvent);	12✔
61
62	return;	×
63	}
64
65	this.handleErrorState(validationResult, method, promiEvent);	6✔
66
67	return;	6✔
68	}
69
70	this.newHeadsWatcher.watch(moduleInstance).on('newHead', () => {	18✔
71	this.timeoutCounter++;	18✔
72	if (!this.isTimeoutTimeExceeded(moduleInstance, this.newHeadsWatcher.isPolling)) {	18✔
73	this.getTransactionReceiptMethod.execute(moduleInstance).then((receipt) => {	12✔
74	const validationResult = this.transactionReceiptValidator.validate(receipt, method.parameters);	12✔
75
76	if (validationResult === true) {	12✔
77	this.confirmationsCounter++;	6✔
78	promiEvent.emit('confirmation', this.confirmationsCounter, receipt);	6✔
79
80	if (this.isConfirmed(moduleInstance)) {	6!
81	this.handleSuccessState(receipt, method, promiEvent);	6✔
82	}
83
84	return;	6✔
85	}
86
87	this.handleErrorState(validationResult, method, promiEvent);	6✔
88	});
89
90	return;	12✔
91	}
92
93	let error = new Error(	6✔
94	`Transaction was not mined within ${
95	moduleInstance.transactionBlockTimeout
96	} blocks, please make sure your transaction was properly sent. Be aware that it might still be mined!`
97	);
98
99	if (this.newHeadsWatcher.isPolling) {	6!
100	error = new Error(	6✔
101	`Transaction was not mined within ${
102	moduleInstance.transactionPollingTimeout
103	} seconds, please make sure your transaction was properly sent. Be aware that it might still be mined!`
104	);
105	}
106
107	this.handleErrorState(error, method, promiEvent);	6✔
108	});
109	});
110	}
111
112	/**
113	* Checks if the transaction has enough confirmations
114	*
115	* @method isConfirmed
116	*
117	* @param {AbstractWeb3Module} moduleInstance
118	*
119	* @returns {Boolean}
120	*/
121	isConfirmed(moduleInstance) {
122	return this.confirmationsCounter === moduleInstance.transactionConfirmationBlocks;	6✔
123	}
124
125	/**
126	* Checks if the timeout time is reached
127	*
128	* @method isTimeoutTimeExceeded
129	*
130	* @param {AbstractWeb3Module} moduleInstance
131	* @param {Boolean} watcherIsPolling
132	*
133	* @returns {Boolean}
134	*/
135	isTimeoutTimeExceeded(moduleInstance, watcherIsPolling) {
136	let timeout = moduleInstance.transactionBlockTimeout;	18✔
137	if (watcherIsPolling) {	18✔
138	timeout = moduleInstance.transactionPollingTimeout;	12✔
139	}
140
141	return this.timeoutCounter > timeout;	18✔
142	}
143
144	/**
145	* Resolves promise, emits receipt event, calls callback and removes all the listeners.
146	*
147	* @method handleSuccessState
148	*
149	* @param {Object} receipt
150	* @param {AbstractMethod} method
151	* @param {PromiEvent} promiEvent
152	*
153	* @callback callback callback(error, result)
154	*/
155	handleSuccessState(receipt, method, promiEvent) {
156	this.timeoutCounter = 0;	18✔
157	this.confirmationsCounter = 0;	18✔
158	this.newHeadsWatcher.stop();	18✔
159
160	if (method.constructor.name === 'ContractDeployMethod') {	18✔
161	if (method.callback) {	6!
162	method.callback(false, receipt);	6✔
163	}
164
165	promiEvent.resolve(method.afterExecution(receipt));	6✔
166	promiEvent.emit('receipt', receipt);	6✔
167	promiEvent.removeAllListeners();	×
168
169	return;	×
170	}
171
172	const mappedReceipt = method.afterExecution(receipt);	12✔
173
174	if (method.callback) {	12!
175	method.callback(false, mappedReceipt);	12✔
176	}
177
178	promiEvent.resolve(mappedReceipt);	12✔
179	promiEvent.emit('receipt', mappedReceipt);	12✔
180	promiEvent.removeAllListeners();	6✔
181	}
182
183	/**
184	* Rejects promise, emits error event, calls callback and removes all the listeners.
185	*
186	* @method handleErrorState
187	*
188	* @param {Error} error
189	* @param {AbstractMethod} method
190	* @param {PromiEvent} promiEvent
191	*
192	* @callback callback callback(error, result)
193	*/
194	handleErrorState(error, method, promiEvent) {
195	this.timeoutCounter = 0;	18✔
196	this.confirmationsCounter = 0;	18✔
197	this.newHeadsWatcher.stop();	18✔
198
199	if (method.callback) {	18!
200	method.callback(error, null);	18✔
201	}
202
203	promiEvent.reject(error);	18✔
204	promiEvent.emit('error', error);	18✔
205	promiEvent.removeAllListeners();	18✔
206	}
207	}

ethereum / web3.js / 4057

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