1 | "use strict";
|
2 | var __read = (this && this.__read) || function (o, n) {
|
3 | var m = typeof Symbol === "function" && o[Symbol.iterator];
|
4 | if (!m) return o;
|
5 | var i = m.call(o), r, ar = [], e;
|
6 | try {
|
7 | while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
8 | }
|
9 | catch (error) { e = { error: error }; }
|
10 | finally {
|
11 | try {
|
12 | if (r && !r.done && (m = i["return"])) m.call(i);
|
13 | }
|
14 | finally { if (e) throw e.error; }
|
15 | }
|
16 | return ar;
|
17 | };
|
18 | var __spreadArray = (this && this.__spreadArray) || function (to, from) {
|
19 | for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
|
20 | to[j] = from[i];
|
21 | return to;
|
22 | };
|
23 | var __values = (this && this.__values) || function(o) {
|
24 | var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
25 | if (m) return m.call(o);
|
26 | if (o && typeof o.length === "number") return {
|
27 | next: function () {
|
28 | if (o && i >= o.length) o = void 0;
|
29 | return { value: o && o[i++], done: !o };
|
30 | }
|
31 | };
|
32 | throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
33 | };
|
34 | Object.defineProperty(exports, "__esModule", { value: true });
|
35 | exports.signatureToString = exports.stringToSignature = exports.privateKeyToString = exports.privateKeyToLegacyString = exports.stringToPrivateKey = exports.convertLegacyPublicKeys = exports.convertLegacyPublicKey = exports.publicKeyToString = exports.publicKeyToLegacyString = exports.stringToPublicKey = exports.signatureDataSize = exports.privateKeyDataSize = exports.publicKeyDataSize = exports.KeyType = exports.base64ToBinary = exports.binaryToBase58 = exports.base58ToBinary = exports.signedBinaryToDecimal = exports.binaryToDecimal = exports.signedDecimalToBinary = exports.decimalToBinary = exports.negate = exports.isNegative = void 0;
|
36 |
|
37 |
|
38 |
|
39 | var hash_js_1 = require("hash.js");
|
40 |
|
41 | var ripemd160 = require('./ripemd').RIPEMD160.hash;
|
42 | var base58Chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
|
43 | var base64Chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
44 | var create_base58_map = function () {
|
45 | var base58M = Array(256).fill(-1);
|
46 | for (var i = 0; i < base58Chars.length; ++i) {
|
47 | base58M[base58Chars.charCodeAt(i)] = i;
|
48 | }
|
49 | return base58M;
|
50 | };
|
51 | var base58Map = create_base58_map();
|
52 | var create_base64_map = function () {
|
53 | var base64M = Array(256).fill(-1);
|
54 | for (var i = 0; i < base64Chars.length; ++i) {
|
55 | base64M[base64Chars.charCodeAt(i)] = i;
|
56 | }
|
57 | base64M['='.charCodeAt(0)] = 0;
|
58 | return base64M;
|
59 | };
|
60 | var base64Map = create_base64_map();
|
61 |
|
62 | var isNegative = function (bignum) {
|
63 | return (bignum[bignum.length - 1] & 0x80) !== 0;
|
64 | };
|
65 | exports.isNegative = isNegative;
|
66 |
|
67 | var negate = function (bignum) {
|
68 | var carry = 1;
|
69 | for (var i = 0; i < bignum.length; ++i) {
|
70 | var x = (~bignum[i] & 0xff) + carry;
|
71 | bignum[i] = x;
|
72 | carry = x >> 8;
|
73 | }
|
74 | };
|
75 | exports.negate = negate;
|
76 |
|
77 |
|
78 |
|
79 |
|
80 |
|
81 | var decimalToBinary = function (size, s) {
|
82 | var result = new Uint8Array(size);
|
83 | for (var i = 0; i < s.length; ++i) {
|
84 | var srcDigit = s.charCodeAt(i);
|
85 | if (srcDigit < '0'.charCodeAt(0) || srcDigit > '9'.charCodeAt(0)) {
|
86 | throw new Error('invalid number');
|
87 | }
|
88 | var carry = srcDigit - '0'.charCodeAt(0);
|
89 | for (var j = 0; j < size; ++j) {
|
90 | var x = result[j] * 10 + carry;
|
91 | result[j] = x;
|
92 | carry = x >> 8;
|
93 | }
|
94 | if (carry) {
|
95 | throw new Error('number is out of range');
|
96 | }
|
97 | }
|
98 | return result;
|
99 | };
|
100 | exports.decimalToBinary = decimalToBinary;
|
101 |
|
102 |
|
103 |
|
104 |
|
105 |
|
106 | var signedDecimalToBinary = function (size, s) {
|
107 | var negative = s[0] === '-';
|
108 | if (negative) {
|
109 | s = s.substr(1);
|
110 | }
|
111 | var result = exports.decimalToBinary(size, s);
|
112 | if (negative) {
|
113 | exports.negate(result);
|
114 | if (!exports.isNegative(result)) {
|
115 | throw new Error('number is out of range');
|
116 | }
|
117 | }
|
118 | else if (exports.isNegative(result)) {
|
119 | throw new Error('number is out of range');
|
120 | }
|
121 | return result;
|
122 | };
|
123 | exports.signedDecimalToBinary = signedDecimalToBinary;
|
124 |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 | var binaryToDecimal = function (bignum, minDigits) {
|
130 | if (minDigits === void 0) { minDigits = 1; }
|
131 | var result = Array(minDigits).fill('0'.charCodeAt(0));
|
132 | for (var i = bignum.length - 1; i >= 0; --i) {
|
133 | var carry = bignum[i];
|
134 | for (var j = 0; j < result.length; ++j) {
|
135 | var x = ((result[j] - '0'.charCodeAt(0)) << 8) + carry;
|
136 | result[j] = '0'.charCodeAt(0) + x % 10;
|
137 | carry = (x / 10) | 0;
|
138 | }
|
139 | while (carry) {
|
140 | result.push('0'.charCodeAt(0) + carry % 10);
|
141 | carry = (carry / 10) | 0;
|
142 | }
|
143 | }
|
144 | result.reverse();
|
145 | return String.fromCharCode.apply(String, __spreadArray([], __read(result)));
|
146 | };
|
147 | exports.binaryToDecimal = binaryToDecimal;
|
148 |
|
149 |
|
150 |
|
151 |
|
152 |
|
153 | var signedBinaryToDecimal = function (bignum, minDigits) {
|
154 | if (minDigits === void 0) { minDigits = 1; }
|
155 | if (exports.isNegative(bignum)) {
|
156 | var x = bignum.slice();
|
157 | exports.negate(x);
|
158 | return '-' + exports.binaryToDecimal(x, minDigits);
|
159 | }
|
160 | return exports.binaryToDecimal(bignum, minDigits);
|
161 | };
|
162 | exports.signedBinaryToDecimal = signedBinaryToDecimal;
|
163 | var base58ToBinaryVarSize = function (s) {
|
164 | var e_1, _a;
|
165 | var result = [];
|
166 | for (var i = 0; i < s.length; ++i) {
|
167 | var carry = base58Map[s.charCodeAt(i)];
|
168 | if (carry < 0) {
|
169 | throw new Error('invalid base-58 value');
|
170 | }
|
171 | for (var j = 0; j < result.length; ++j) {
|
172 | var x = result[j] * 58 + carry;
|
173 | result[j] = x & 0xff;
|
174 | carry = x >> 8;
|
175 | }
|
176 | if (carry) {
|
177 | result.push(carry);
|
178 | }
|
179 | }
|
180 | try {
|
181 | for (var s_1 = __values(s), s_1_1 = s_1.next(); !s_1_1.done; s_1_1 = s_1.next()) {
|
182 | var ch = s_1_1.value;
|
183 | if (ch === '1') {
|
184 | result.push(0);
|
185 | }
|
186 | else {
|
187 | break;
|
188 | }
|
189 | }
|
190 | }
|
191 | catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
192 | finally {
|
193 | try {
|
194 | if (s_1_1 && !s_1_1.done && (_a = s_1.return)) _a.call(s_1);
|
195 | }
|
196 | finally { if (e_1) throw e_1.error; }
|
197 | }
|
198 | result.reverse();
|
199 | return new Uint8Array(result);
|
200 | };
|
201 |
|
202 |
|
203 |
|
204 |
|
205 |
|
206 | var base58ToBinary = function (size, s) {
|
207 | if (!size) {
|
208 | return base58ToBinaryVarSize(s);
|
209 | }
|
210 | var result = new Uint8Array(size);
|
211 | for (var i = 0; i < s.length; ++i) {
|
212 | var carry = base58Map[s.charCodeAt(i)];
|
213 | if (carry < 0) {
|
214 | throw new Error('invalid base-58 value');
|
215 | }
|
216 | for (var j = 0; j < size; ++j) {
|
217 | var x = result[j] * 58 + carry;
|
218 | result[j] = x;
|
219 | carry = x >> 8;
|
220 | }
|
221 | if (carry) {
|
222 | throw new Error('base-58 value is out of range');
|
223 | }
|
224 | }
|
225 | result.reverse();
|
226 | return result;
|
227 | };
|
228 | exports.base58ToBinary = base58ToBinary;
|
229 |
|
230 |
|
231 |
|
232 |
|
233 |
|
234 | var binaryToBase58 = function (bignum, minDigits) {
|
235 | var e_2, _a, e_3, _b;
|
236 | if (minDigits === void 0) { minDigits = 1; }
|
237 | var result = [];
|
238 | try {
|
239 | for (var bignum_1 = __values(bignum), bignum_1_1 = bignum_1.next(); !bignum_1_1.done; bignum_1_1 = bignum_1.next()) {
|
240 | var byte = bignum_1_1.value;
|
241 | var carry = byte;
|
242 | for (var j = 0; j < result.length; ++j) {
|
243 | var x = (base58Map[result[j]] << 8) + carry;
|
244 | result[j] = base58Chars.charCodeAt(x % 58);
|
245 | carry = (x / 58) | 0;
|
246 | }
|
247 | while (carry) {
|
248 | result.push(base58Chars.charCodeAt(carry % 58));
|
249 | carry = (carry / 58) | 0;
|
250 | }
|
251 | }
|
252 | }
|
253 | catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
254 | finally {
|
255 | try {
|
256 | if (bignum_1_1 && !bignum_1_1.done && (_a = bignum_1.return)) _a.call(bignum_1);
|
257 | }
|
258 | finally { if (e_2) throw e_2.error; }
|
259 | }
|
260 | try {
|
261 | for (var bignum_2 = __values(bignum), bignum_2_1 = bignum_2.next(); !bignum_2_1.done; bignum_2_1 = bignum_2.next()) {
|
262 | var byte = bignum_2_1.value;
|
263 | if (byte) {
|
264 | break;
|
265 | }
|
266 | else {
|
267 | result.push('1'.charCodeAt(0));
|
268 | }
|
269 | }
|
270 | }
|
271 | catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
272 | finally {
|
273 | try {
|
274 | if (bignum_2_1 && !bignum_2_1.done && (_b = bignum_2.return)) _b.call(bignum_2);
|
275 | }
|
276 | finally { if (e_3) throw e_3.error; }
|
277 | }
|
278 | result.reverse();
|
279 | return String.fromCharCode.apply(String, __spreadArray([], __read(result)));
|
280 | };
|
281 | exports.binaryToBase58 = binaryToBase58;
|
282 |
|
283 | var base64ToBinary = function (s) {
|
284 | var len = s.length;
|
285 | if ((len & 3) === 1 && s[len - 1] === '=') {
|
286 | len -= 1;
|
287 | }
|
288 | if ((len & 3) !== 0) {
|
289 | throw new Error('base-64 value is not padded correctly');
|
290 | }
|
291 | var groups = len >> 2;
|
292 | var bytes = groups * 3;
|
293 | if (len > 0 && s[len - 1] === '=') {
|
294 | if (s[len - 2] === '=') {
|
295 | bytes -= 2;
|
296 | }
|
297 | else {
|
298 | bytes -= 1;
|
299 | }
|
300 | }
|
301 | var result = new Uint8Array(bytes);
|
302 | for (var group = 0; group < groups; ++group) {
|
303 | var digit0 = base64Map[s.charCodeAt(group * 4 + 0)];
|
304 | var digit1 = base64Map[s.charCodeAt(group * 4 + 1)];
|
305 | var digit2 = base64Map[s.charCodeAt(group * 4 + 2)];
|
306 | var digit3 = base64Map[s.charCodeAt(group * 4 + 3)];
|
307 | result[group * 3 + 0] = (digit0 << 2) | (digit1 >> 4);
|
308 | if (group * 3 + 1 < bytes) {
|
309 | result[group * 3 + 1] = ((digit1 & 15) << 4) | (digit2 >> 2);
|
310 | }
|
311 | if (group * 3 + 2 < bytes) {
|
312 | result[group * 3 + 2] = ((digit2 & 3) << 6) | digit3;
|
313 | }
|
314 | }
|
315 | return result;
|
316 | };
|
317 | exports.base64ToBinary = base64ToBinary;
|
318 |
|
319 | var KeyType;
|
320 | (function (KeyType) {
|
321 | KeyType[KeyType["k1"] = 0] = "k1";
|
322 | KeyType[KeyType["r1"] = 1] = "r1";
|
323 | KeyType[KeyType["wa"] = 2] = "wa";
|
324 | })(KeyType = exports.KeyType || (exports.KeyType = {}));
|
325 |
|
326 | exports.publicKeyDataSize = 33;
|
327 |
|
328 | exports.privateKeyDataSize = 32;
|
329 |
|
330 | exports.signatureDataSize = 65;
|
331 | var digestSuffixRipemd160 = function (data, suffix) {
|
332 | var d = new Uint8Array(data.length + suffix.length);
|
333 | for (var i = 0; i < data.length; ++i) {
|
334 | d[i] = data[i];
|
335 | }
|
336 | for (var i = 0; i < suffix.length; ++i) {
|
337 | d[data.length + i] = suffix.charCodeAt(i);
|
338 | }
|
339 | return ripemd160(d);
|
340 | };
|
341 | var stringToKey = function (s, type, size, suffix) {
|
342 | var whole = exports.base58ToBinary(size ? size + 4 : 0, s);
|
343 | var result = { type: type, data: new Uint8Array(whole.buffer, 0, whole.length - 4) };
|
344 | var digest = new Uint8Array(digestSuffixRipemd160(result.data, suffix));
|
345 | if (digest[0] !== whole[whole.length - 4] || digest[1] !== whole[whole.length - 3]
|
346 | || digest[2] !== whole[whole.length - 2] || digest[3] !== whole[whole.length - 1]) {
|
347 | throw new Error('checksum doesn\'t match');
|
348 | }
|
349 | return result;
|
350 | };
|
351 | var keyToString = function (key, suffix, prefix) {
|
352 | var digest = new Uint8Array(digestSuffixRipemd160(key.data, suffix));
|
353 | var whole = new Uint8Array(key.data.length + 4);
|
354 | for (var i = 0; i < key.data.length; ++i) {
|
355 | whole[i] = key.data[i];
|
356 | }
|
357 | for (var i = 0; i < 4; ++i) {
|
358 | whole[i + key.data.length] = digest[i];
|
359 | }
|
360 | return prefix + exports.binaryToBase58(whole);
|
361 | };
|
362 |
|
363 | var stringToPublicKey = function (s) {
|
364 | if (typeof s !== 'string') {
|
365 | throw new Error('expected string containing public key');
|
366 | }
|
367 | if (s.substr(0, 3) === 'EOS') {
|
368 | var whole = exports.base58ToBinary(exports.publicKeyDataSize + 4, s.substr(3));
|
369 | var key = { type: KeyType.k1, data: new Uint8Array(exports.publicKeyDataSize) };
|
370 | for (var i = 0; i < exports.publicKeyDataSize; ++i) {
|
371 | key.data[i] = whole[i];
|
372 | }
|
373 | var digest = new Uint8Array(ripemd160(key.data));
|
374 | if (digest[0] !== whole[exports.publicKeyDataSize] || digest[1] !== whole[34]
|
375 | || digest[2] !== whole[35] || digest[3] !== whole[36]) {
|
376 | throw new Error('checksum doesn\'t match');
|
377 | }
|
378 | return key;
|
379 | }
|
380 | else if (s.substr(0, 7) === 'PUB_K1_') {
|
381 | return stringToKey(s.substr(7), KeyType.k1, exports.publicKeyDataSize, 'K1');
|
382 | }
|
383 | else if (s.substr(0, 7) === 'PUB_R1_') {
|
384 | return stringToKey(s.substr(7), KeyType.r1, exports.publicKeyDataSize, 'R1');
|
385 | }
|
386 | else if (s.substr(0, 7) === 'PUB_WA_') {
|
387 | return stringToKey(s.substr(7), KeyType.wa, 0, 'WA');
|
388 | }
|
389 | else {
|
390 | throw new Error('unrecognized public key format');
|
391 | }
|
392 | };
|
393 | exports.stringToPublicKey = stringToPublicKey;
|
394 |
|
395 | var publicKeyToLegacyString = function (key) {
|
396 | if (key.type === KeyType.k1 && key.data.length === exports.publicKeyDataSize) {
|
397 | return keyToString(key, '', 'EOS');
|
398 | }
|
399 | else if (key.type === KeyType.r1 || key.type === KeyType.wa) {
|
400 | throw new Error('Key format not supported in legacy conversion');
|
401 | }
|
402 | else {
|
403 | throw new Error('unrecognized public key format');
|
404 | }
|
405 | };
|
406 | exports.publicKeyToLegacyString = publicKeyToLegacyString;
|
407 |
|
408 | var publicKeyToString = function (key) {
|
409 | if (key.type === KeyType.k1 && key.data.length === exports.publicKeyDataSize) {
|
410 | return keyToString(key, 'K1', 'PUB_K1_');
|
411 | }
|
412 | else if (key.type === KeyType.r1 && key.data.length === exports.publicKeyDataSize) {
|
413 | return keyToString(key, 'R1', 'PUB_R1_');
|
414 | }
|
415 | else if (key.type === KeyType.wa) {
|
416 | return keyToString(key, 'WA', 'PUB_WA_');
|
417 | }
|
418 | else {
|
419 | throw new Error('unrecognized public key format');
|
420 | }
|
421 | };
|
422 | exports.publicKeyToString = publicKeyToString;
|
423 |
|
424 |
|
425 |
|
426 | var convertLegacyPublicKey = function (s) {
|
427 | if (s.substr(0, 3) === 'EOS') {
|
428 | return exports.publicKeyToString(exports.stringToPublicKey(s));
|
429 | }
|
430 | return s;
|
431 | };
|
432 | exports.convertLegacyPublicKey = convertLegacyPublicKey;
|
433 |
|
434 |
|
435 |
|
436 | var convertLegacyPublicKeys = function (keys) {
|
437 | return keys.map(exports.convertLegacyPublicKey);
|
438 | };
|
439 | exports.convertLegacyPublicKeys = convertLegacyPublicKeys;
|
440 |
|
441 | var stringToPrivateKey = function (s) {
|
442 | if (typeof s !== 'string') {
|
443 | throw new Error('expected string containing private key');
|
444 | }
|
445 | if (s.substr(0, 7) === 'PVT_R1_') {
|
446 | return stringToKey(s.substr(7), KeyType.r1, exports.privateKeyDataSize, 'R1');
|
447 | }
|
448 | else if (s.substr(0, 7) === 'PVT_K1_') {
|
449 | return stringToKey(s.substr(7), KeyType.k1, exports.privateKeyDataSize, 'K1');
|
450 | }
|
451 | else {
|
452 |
|
453 |
|
454 |
|
455 | var whole = exports.base58ToBinary(exports.privateKeyDataSize + 5, s);
|
456 | var key = { type: KeyType.k1, data: new Uint8Array(exports.privateKeyDataSize) };
|
457 | if (whole[0] !== 0x80) {
|
458 | throw new Error('unrecognized private key type');
|
459 | }
|
460 | for (var i = 0; i < exports.privateKeyDataSize; ++i) {
|
461 | key.data[i] = whole[i + 1];
|
462 | }
|
463 | return key;
|
464 | }
|
465 | };
|
466 | exports.stringToPrivateKey = stringToPrivateKey;
|
467 |
|
468 | var privateKeyToLegacyString = function (key) {
|
469 | if (key.type === KeyType.k1 && key.data.length === exports.privateKeyDataSize) {
|
470 | var whole_1 = [];
|
471 | whole_1.push(128);
|
472 | key.data.forEach(function (byte) { return whole_1.push(byte); });
|
473 | var digest = new Uint8Array(hash_js_1.sha256().update(hash_js_1.sha256().update(whole_1).digest()).digest());
|
474 | var result = new Uint8Array(exports.privateKeyDataSize + 5);
|
475 | for (var i = 0; i < whole_1.length; i++) {
|
476 | result[i] = whole_1[i];
|
477 | }
|
478 | for (var i = 0; i < 4; i++) {
|
479 | result[i + whole_1.length] = digest[i];
|
480 | }
|
481 | return exports.binaryToBase58(result);
|
482 | }
|
483 | else if (key.type === KeyType.r1 || key.type === KeyType.wa) {
|
484 | throw new Error('Key format not supported in legacy conversion');
|
485 | }
|
486 | else {
|
487 | throw new Error('unrecognized public key format');
|
488 | }
|
489 | };
|
490 | exports.privateKeyToLegacyString = privateKeyToLegacyString;
|
491 |
|
492 | var privateKeyToString = function (key) {
|
493 | if (key.type === KeyType.r1) {
|
494 | return keyToString(key, 'R1', 'PVT_R1_');
|
495 | }
|
496 | else if (key.type === KeyType.k1) {
|
497 | return keyToString(key, 'K1', 'PVT_K1_');
|
498 | }
|
499 | else {
|
500 | throw new Error('unrecognized private key format');
|
501 | }
|
502 | };
|
503 | exports.privateKeyToString = privateKeyToString;
|
504 |
|
505 | var stringToSignature = function (s) {
|
506 | if (typeof s !== 'string') {
|
507 | throw new Error('expected string containing signature');
|
508 | }
|
509 | if (s.substr(0, 7) === 'SIG_K1_') {
|
510 | return stringToKey(s.substr(7), KeyType.k1, exports.signatureDataSize, 'K1');
|
511 | }
|
512 | else if (s.substr(0, 7) === 'SIG_R1_') {
|
513 | return stringToKey(s.substr(7), KeyType.r1, exports.signatureDataSize, 'R1');
|
514 | }
|
515 | else if (s.substr(0, 7) === 'SIG_WA_') {
|
516 | return stringToKey(s.substr(7), KeyType.wa, 0, 'WA');
|
517 | }
|
518 | else {
|
519 | throw new Error('unrecognized signature format');
|
520 | }
|
521 | };
|
522 | exports.stringToSignature = stringToSignature;
|
523 |
|
524 | var signatureToString = function (signature) {
|
525 | if (signature.type === KeyType.k1) {
|
526 | return keyToString(signature, 'K1', 'SIG_K1_');
|
527 | }
|
528 | else if (signature.type === KeyType.r1) {
|
529 | return keyToString(signature, 'R1', 'SIG_R1_');
|
530 | }
|
531 | else if (signature.type === KeyType.wa) {
|
532 | return keyToString(signature, 'WA', 'SIG_WA_');
|
533 | }
|
534 | else {
|
535 | throw new Error('unrecognized signature format');
|
536 | }
|
537 | };
|
538 | exports.signatureToString = signatureToString;
|
539 |
|
\ | No newline at end of file |