waves_lib 0.1.0

data/js/node_modules/@waves/ts-lib-crypto/conversions/string-bytes.js

@@ -0,0 +1,65 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var param_1 = require("./param");
+var Utf8_1 = require("../libs/Utf8");
+exports.stringToBytes = function (str, encoding) {
+    if (encoding === void 0) { encoding = 'utf8'; }
+    if (encoding === 'utf8') {
+        return Utf8_1.strToUtf8Array(str);
+    }
+    else if (encoding === 'raw') {
+        return Uint8Array.from(__spread(str).map(function (c) { return c.charCodeAt(0); }));
+    }
+    else {
+        throw new Error("Unsupported encoding " + encoding);
+    }
+};
+exports.bytesToString = function (bytes, encoding) {
+    if (encoding === void 0) { encoding = 'utf8'; }
+    if (encoding === 'utf8') {
+        return Utf8_1.utf8ArrayToStr(Array.from(param_1._fromIn(bytes)));
+    }
+    else if (encoding === 'raw') {
+        return Array.from(param_1._fromIn(bytes))
+            .map(function (byte) { return String.fromCharCode(byte); })
+            .join('');
+    }
+    else {
+        throw new Error("Unsupported encoding " + encoding);
+    }
+};
+/**
+ * Converts each character to byte
+ */
+exports.binaryStringToBytes = function (str) {
+    return Uint8Array.from(__spread(str).map(function (c) { return c.charCodeAt(0); }));
+};
+/**
+ * Reads each byte as individual character
+ */
+exports.bytesToBinaryString = function (bytes) {
+    return Array.from(param_1._fromIn(bytes))
+        .map(function (byte) { return String.fromCharCode(byte); })
+        .join('');
+};
+//# sourceMappingURL=string-bytes.js.map

data/js/node_modules/@waves/ts-lib-crypto/conversions/string-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-bytes.js","sourceRoot":"","sources":["../../src/conversions/string-bytes.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AACA,iCAAiC;AACjC,qCAA6D;AAEhD,QAAA,aAAa,GAAG,UAAC,GAAW,EAAE,QAAiC;IAAjC,yBAAA,EAAA,iBAAiC;IAC1E,IAAI,QAAQ,KAAK,MAAM,EAAC;QACtB,OAAO,qBAAc,CAAC,GAAG,CAAC,CAAA;KAC3B;SAAM,IAAI,QAAQ,KAAK,KAAK,EAAC;QAC5B,OAAO,UAAU,CAAC,IAAI,CAAC,SAAI,GAAG,EAAE,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC,CAAC,CAAA;KAC3D;SAAK;QACJ,MAAM,IAAI,KAAK,CAAC,0BAAwB,QAAU,CAAC,CAAA;KACpD;AACH,CAAC,CAAA;AAEY,QAAA,aAAa,GAAG,UAAC,KAAgB,EAAE,QAAiC;IAAjC,yBAAA,EAAA,iBAAiC;IAC/E,IAAI,QAAQ,KAAK,MAAM,EAAC;QACtB,OAAO,qBAAc,CAAC,KAAK,CAAC,IAAI,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;KAClD;SAAM,IAAI,QAAQ,KAAK,KAAK,EAAC;QAC5B,OAAO,KAAK,CAAC,IAAI,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC;aAC9B,GAAG,CAAC,UAAC,IAAI,IAAK,OAAA,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAzB,CAAyB,CAAC;aACxC,IAAI,CAAC,EAAE,CAAC,CAAA;KACZ;SAAK;QACJ,MAAM,IAAI,KAAK,CAAC,0BAAwB,QAAU,CAAC,CAAA;KACpD;AACH,CAAC,CAAA;AAED;;GAEG;AACU,QAAA,mBAAmB,GAAG,UAAC,GAAW;IAC7C,OAAA,UAAU,CAAC,IAAI,CAAC,SAAI,GAAG,EAAE,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAf,CAAe,CAAC,CAAC;AAAnD,CAAmD,CAAA;AAErD;;GAEG;AACU,QAAA,mBAAmB,GAAG,UAAC,KAAgB;IAClD,OAAA,KAAK,CAAC,IAAI,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC;SACrB,GAAG,CAAC,UAAC,IAAI,IAAK,OAAA,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,EAAzB,CAAyB,CAAC;SACxC,IAAI,CAAC,EAAE,CAAC;AAFb,CAEa,CAAA"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/address-keys-seed.d.ts

@@ -0,0 +1,7 @@
+import { TSeed, INonceSeed, TPublicKey, TBinaryIn, TKeyPair, TPrivateKey } from './interface';
+export declare const seedWithNonce: (seed: TSeed, nonce: number) => INonceSeed;
+export declare const buildAddress: (publicKeyBytes: Uint8Array, chainId?: string | number) => Uint8Array;
+export declare const keyPair: (seed: TSeed) => TKeyPair<Uint8Array>;
+export declare const address: (seedOrPublicKey: string | Uint8Array | number[] | import("./interface").TRawStringInDiscriminator | INonceSeed | TPublicKey<TBinaryIn>, chainId?: string | number) => Uint8Array;
+export declare const publicKey: (seedOrPrivateKey: string | Uint8Array | number[] | import("./interface").TRawStringInDiscriminator | INonceSeed | TPrivateKey<TBinaryIn>) => Uint8Array;
+export declare const privateKey: (seed: TSeed) => Uint8Array;

data/js/node_modules/@waves/ts-lib-crypto/crypto/address-keys-seed.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var interface_1 = require("./interface");
+var seed_1 = require("../extensions/seed");
+var hashing_1 = require("./hashing");
+var param_1 = require("../conversions/param");
+var concat_split_1 = require("./concat-split");
+var util_1 = require("./util");
+var axlsign_1 = __importDefault(require("../libs/axlsign"));
+exports.seedWithNonce = function (seed, nonce) { return ({ seed: seed_1.Seed.toBinary(seed).seed, nonce: nonce }); };
+exports.buildAddress = function (publicKeyBytes, chainId) {
+    if (chainId === void 0) { chainId = interface_1.MAIN_NET_CHAIN_ID; }
+    var prefix = [1, typeof chainId === 'string' ? chainId.charCodeAt(0) : chainId];
+    var publicKeyHashPart = hashing_1._hashChain(publicKeyBytes).slice(0, 20);
+    var rawAddress = concat_split_1.concat(prefix, publicKeyHashPart);
+    var addressHash = hashing_1._hashChain(rawAddress).slice(0, 4);
+    return concat_split_1.concat(rawAddress, addressHash);
+};
+var buildSeedHash = function (seedBytes, nonce) {
+    var nonceArray = [0, 0, 0, 0];
+    if (nonce && nonce > 0) {
+        var remainder = nonce;
+        for (var i = 3; i >= 0; i--) {
+            nonceArray[3 - i] = Math.floor(remainder / Math.pow(2, (i * 8)));
+            remainder = remainder % Math.pow(2, (i * 8));
+        }
+    }
+    var seedBytesWithNonce = concat_split_1.concat(nonceArray, seedBytes);
+    var seedHash = hashing_1._hashChain(seedBytesWithNonce);
+    return hashing_1.sha256(seedHash);
+};
+exports.keyPair = function (seed) {
+    var _a = seed_1.Seed.toBinary(seed), seedBytes = _a.seed, nonce = _a.nonce;
+    var seedHash = buildSeedHash(seedBytes, nonce);
+    var keys = axlsign_1.default.generateKeyPair(seedHash);
+    return {
+        privateKey: keys.private,
+        publicKey: keys.public,
+    };
+};
+exports.address = function (seedOrPublicKey, chainId) {
+    if (chainId === void 0) { chainId = interface_1.MAIN_NET_CHAIN_ID; }
+    return util_1.isPublicKey(seedOrPublicKey) ?
+        exports.buildAddress(param_1._fromIn(seedOrPublicKey.publicKey), chainId) :
+        exports.address(exports.keyPair(seedOrPublicKey), chainId);
+};
+exports.publicKey = function (seedOrPrivateKey) {
+    return util_1.isPrivateKey(seedOrPrivateKey) ?
+        axlsign_1.default.generateKeyPair(param_1._fromIn(seedOrPrivateKey.privateKey)).public :
+        exports.keyPair(seedOrPrivateKey).publicKey;
+};
+exports.privateKey = function (seed) {
+    return exports.keyPair(seed).privateKey;
+};
+//# sourceMappingURL=address-keys-seed.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/address-keys-seed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address-keys-seed.js","sourceRoot":"","sources":["../../src/crypto/address-keys-seed.ts"],"names":[],"mappings":"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"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/concat-split.d.ts

@@ -0,0 +1,3 @@
+import { TBinaryIn } from './interface';
+export declare const concat: (...arrays: TBinaryIn[]) => Uint8Array;
+export declare const split: (binary: TBinaryIn, ...sizes: number[]) => Uint8Array[];

data/js/node_modules/@waves/ts-lib-crypto/crypto/concat-split.js

@@ -0,0 +1,39 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var param_1 = require("../conversions/param");
+exports.concat = function () {
+    var arrays = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        arrays[_i] = arguments[_i];
+    }
+    return arrays.reduce(function (a, b) { return Uint8Array.from(__spread(a, param_1._fromIn(b))); }, new Uint8Array(0));
+};
+exports.split = function (binary) {
+    var sizes = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        sizes[_i - 1] = arguments[_i];
+    }
+    var _a = sizes.reduce(function (a, s) { return ({ arr: a.arr.slice(s), r: __spread(a.r, [a.arr.slice(0, s)]) }); }, { arr: param_1._fromIn(binary), r: [] }), r = _a.r, arr = _a.arr;
+    return __spread(r, [arr]);
+};
+//# sourceMappingURL=concat-split.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/concat-split.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat-split.js","sourceRoot":"","sources":["../../src/crypto/concat-split.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AACA,8CAA8C;AAEjC,QAAA,MAAM,GAAG;IAAC,gBAAsB;SAAtB,UAAsB,EAAtB,qBAAsB,EAAtB,IAAsB;QAAtB,2BAAsB;;IAC3C,OAAA,MAAM,CAAC,MAAM,CAAa,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,UAAU,CAAC,IAAI,UAAK,CAAC,EAAK,eAAO,CAAC,CAAC,CAAC,EAAE,EAAtC,CAAsC,EAAE,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;AAA9F,CAA8F,CAAA;AAEnF,QAAA,KAAK,GAAG,UAAC,MAAiB;IAAE,eAAkB;SAAlB,UAAkB,EAAlB,qBAAkB,EAAlB,IAAkB;QAAlB,8BAAkB;;IACnD,IAAA,wJAA6J,EAA3J,QAAC,EAAE,YAAwJ,CAAA;IACnK,gBAAW,CAAC,GAAE,GAAG,GAAC;AACpB,CAAC,CAAA"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/crypto.d.ts

@@ -0,0 +1,13 @@
+import { IWavesCrypto, TBinaryOut, TSeed, ISeedRelated, ISeedEmbeded } from './interface';
+declare type TOutputTypesMap = {
+    Bytes: Uint8Array;
+    Base58: string;
+};
+declare type TDefaultOut = 'Base58';
+declare type TOptions<T extends TBinaryOut = TDefaultOut, S extends TSeed | undefined = undefined> = {
+    output?: T;
+    seed?: S;
+};
+declare type TWavesCrypto<T extends TBinaryOut = TDefaultOut, S extends TSeed | undefined = undefined> = IWavesCrypto<T> & (S extends undefined ? ISeedRelated<T> : ISeedEmbeded<T>);
+export declare const crypto: <TOut extends "Bytes" | "Base58" = "Base58", S extends string | Uint8Array | number[] | import("./interface").TRawStringInDiscriminator | import("./interface").INonceSeed | undefined = undefined>(options?: TOptions<TOut, S> | undefined) => TWavesCrypto<TOutputTypesMap[TOut], S>;
+export {};

data/js/node_modules/@waves/ts-lib-crypto/crypto/crypto.js

@@ -0,0 +1,117 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var random_1 = require("./random");
+var encryption_1 = require("./encryption");
+var base_xx_1 = require("../conversions/base-xx");
+var string_bytes_1 = require("../conversions/string-bytes");
+var concat_split_1 = require("./concat-split");
+var hashing_1 = require("./hashing");
+var address_keys_seed_1 = require("./address-keys-seed");
+var sign_1 = require("./sign");
+var verification_1 = require("./verification");
+var rsa_1 = require("./rsa");
+var seed_ecryption_1 = require("./seed-ecryption");
+var merkle_verify_1 = require("./merkle-verify");
+exports.crypto = function (options) {
+    if (options && options.seed == '')
+        throw new Error('Empty seed is not allowed.');
+    var c = function (f, first) {
+        return function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return f.apply(void 0, __spread([first], args));
+        };
+    };
+    var toOut = function (f) { return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var r = f.apply(void 0, __spread(args));
+        return (!options || options && options.output === 'Base58') ? base_xx_1.base58Encode(r) : r;
+    }; };
+    var toOutKey = function (f) { return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var r = f.apply(void 0, __spread(args));
+        return ((!options || options && options.output === 'Base58') ?
+            ({ privateKey: base_xx_1.base58Encode(r.privateKey), publicKey: base_xx_1.base58Encode(r.publicKey) }) :
+            r);
+    }; };
+    var s = (options && options.seed) ? options.seed : undefined;
+    var seedPart = {
+        seedWithNonce: s ? c(address_keys_seed_1.seedWithNonce, s) : address_keys_seed_1.seedWithNonce,
+        signBytes: toOut(s ? c(sign_1.signBytes, s) : sign_1.signBytes),
+        keyPair: toOutKey(s ? c(address_keys_seed_1.keyPair, s) : address_keys_seed_1.keyPair),
+        publicKey: toOut(s ? c(address_keys_seed_1.publicKey, s) : address_keys_seed_1.publicKey),
+        privateKey: toOut(s ? c(address_keys_seed_1.privateKey, s) : address_keys_seed_1.privateKey),
+        address: toOut(s ? c(address_keys_seed_1.address, s) : address_keys_seed_1.address),
+    };
+    return __assign({}, seedPart, { sharedKey: toOut(encryption_1.sharedKey), buildAddress: address_keys_seed_1.buildAddress,
+        blake2b: hashing_1.blake2b,
+        keccak: hashing_1.keccak,
+        sha256: hashing_1.sha256,
+        base64Encode: base_xx_1.base64Encode,
+        base64Decode: base_xx_1.base64Decode,
+        base58Encode: base_xx_1.base58Encode,
+        base58Decode: base_xx_1.base58Decode,
+        base16Encode: base_xx_1.base16Encode,
+        base16Decode: base_xx_1.base16Decode,
+        stringToBytes: string_bytes_1.stringToBytes,
+        bytesToString: string_bytes_1.bytesToString,
+        random: random_1.random,
+        randomSeed: random_1.randomSeed,
+        randomBytes: random_1.randomBytes,
+        verifySignature: verification_1.verifySignature,
+        verifyPublicKey: verification_1.verifyPublicKey,
+        verifyAddress: verification_1.verifyAddress,
+        messageDecrypt: encryption_1.messageDecrypt,
+        messageEncrypt: encryption_1.messageEncrypt,
+        aesDecrypt: encryption_1.aesDecrypt,
+        aesEncrypt: encryption_1.aesEncrypt,
+        encryptSeed: seed_ecryption_1.encryptSeed,
+        decryptSeed: seed_ecryption_1.decryptSeed,
+        rsaKeyPair: rsa_1.rsaKeyPair,
+        rsaKeyPairSync: rsa_1.rsaKeyPairSync,
+        rsaSign: rsa_1.rsaSign,
+        rsaVerify: rsa_1.rsaVerify,
+        merkleVerify: merkle_verify_1.merkleVerify,
+        split: concat_split_1.split,
+        concat: concat_split_1.concat });
+};
+//# sourceMappingURL=crypto.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/crypto/crypto.ts"],"names":[],"mappings":"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"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/encryption.d.ts

@@ -0,0 +1,6 @@
+import { TBinaryIn, TRawStringIn, AESMode } from './interface';
+export declare const aesEncrypt: (data: TBinaryIn, key: TBinaryIn, mode?: AESMode, iv?: string | Uint8Array | number[] | undefined) => Uint8Array;
+export declare const aesDecrypt: (encryptedData: TBinaryIn, key: TBinaryIn, mode?: AESMode, iv?: string | Uint8Array | number[] | undefined) => Uint8Array;
+export declare const messageEncrypt: (sharedKey: TBinaryIn, message: string) => Uint8Array;
+export declare const messageDecrypt: (sharedKey: TBinaryIn, encryptedMessage: TBinaryIn) => string;
+export declare const sharedKey: (privateKeyFrom: TBinaryIn, publicKeyTo: TBinaryIn, prefix: TRawStringIn) => Uint8Array;

data/js/node_modules/@waves/ts-lib-crypto/crypto/encryption.js

@@ -0,0 +1,89 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+var forgeCipher = __importStar(require("node-forge/lib/cipher"));
+// @ts-ignore
+var util = __importStar(require("node-forge/lib/util"));
+var random_1 = require("./random");
+var param_1 = require("../conversions/param");
+var hashing_1 = require("./hashing");
+var concat_split_1 = require("./concat-split");
+var axlsign_1 = __importDefault(require("../libs/axlsign"));
+var string_bytes_1 = require("../conversions/string-bytes");
+exports.aesEncrypt = function (data, key, mode, iv) {
+    if (mode === void 0) { mode = 'CBC'; }
+    var cipher = forgeCipher.createCipher("AES-" + mode, string_bytes_1.bytesToString(param_1._fromIn(key), 'raw'));
+    cipher.start({ iv: iv && util.createBuffer(string_bytes_1.bytesToString(param_1._fromIn(iv), 'raw')) });
+    cipher.update(util.createBuffer(string_bytes_1.bytesToString(data, 'raw')));
+    cipher.finish();
+    return string_bytes_1.stringToBytes(cipher.output.getBytes(), 'raw');
+};
+exports.aesDecrypt = function (encryptedData, key, mode, iv) {
+    if (mode === void 0) { mode = 'CBC'; }
+    var decipher = forgeCipher.createDecipher("AES-" + mode, string_bytes_1.bytesToString(param_1._fromIn(key), 'raw'));
+    decipher.start({ iv: iv && util.createBuffer(string_bytes_1.bytesToString(param_1._fromIn(iv), 'raw')) });
+    var encbuf = util.createBuffer(string_bytes_1.bytesToString(param_1._fromIn(encryptedData), 'raw'));
+    decipher.update(encbuf);
+    if (!decipher.finish()) {
+        throw new Error('Failed to decrypt data with provided key');
+    }
+    return string_bytes_1.stringToBytes(decipher.output.getBytes(), 'raw');
+};
+exports.messageEncrypt = function (sharedKey, message) {
+    var version = Uint8Array.from([1]);
+    var CEK = random_1.randomBytes(32);
+    var IV = random_1.randomBytes(16);
+    var m = string_bytes_1.stringToBytes(message);
+    var Cc = exports.aesEncrypt(m, CEK, 'CTR', IV);
+    var Ccek = exports.aesEncrypt(CEK, sharedKey, 'ECB');
+    var Mhmac = hashing_1.hmacSHA256(m, CEK);
+    var CEKhmac = hashing_1.hmacSHA256(concat_split_1.concat(CEK, IV), sharedKey);
+    var packageBytes = concat_split_1.concat(version, Ccek, CEKhmac, Mhmac, IV, Cc);
+    return packageBytes;
+};
+exports.messageDecrypt = function (sharedKey, encryptedMessage) {
+    var _a = __read(concat_split_1.split(encryptedMessage, 1, 48, 32, 32, 16), 6), version = _a[0], Ccek = _a[1], _CEKhmac = _a[2], _Mhmac = _a[3], iv = _a[4], Cc = _a[5];
+    var CEK = exports.aesDecrypt(Ccek, sharedKey, 'ECB');
+    var CEKhmac = param_1._fromIn(hashing_1.hmacSHA256(concat_split_1.concat(CEK, iv), param_1._fromIn(sharedKey)));
+    var isValidKey = CEKhmac.every(function (v, i) { return v === _CEKhmac[i]; });
+    if (!isValidKey)
+        throw new Error('Invalid key');
+    var M = exports.aesDecrypt(Cc, CEK, 'CTR', iv);
+    var Mhmac = param_1._fromIn(hashing_1.hmacSHA256(M, CEK));
+    var isValidMessage = Mhmac.every(function (v, i) { return v === _Mhmac[i]; });
+    if (!isValidMessage)
+        throw new Error('Invalid message');
+    return string_bytes_1.bytesToString(M);
+};
+exports.sharedKey = function (privateKeyFrom, publicKeyTo, prefix) {
+    var sharedKey = axlsign_1.default.sharedKey(param_1._fromIn(privateKeyFrom), param_1._fromIn(publicKeyTo));
+    var prefixHash = hashing_1.sha256(param_1._fromRawIn(prefix));
+    return hashing_1.hmacSHA256(sharedKey, prefixHash);
+};
+//# sourceMappingURL=encryption.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/encryption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../../src/crypto/encryption.ts"],"names":[],"mappings":"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"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/hashing.d.ts

@@ -0,0 +1,7 @@
+import { TBinaryIn } from './interface';
+import 'node-forge/lib/sha256';
+export declare const _hashChain: (input: TBinaryIn) => Uint8Array;
+export declare const sha256: (input: TBinaryIn) => Uint8Array;
+export declare const blake2b: (input: TBinaryIn) => Uint8Array;
+export declare const keccak: (input: TBinaryIn) => Uint8Array;
+export declare const hmacSHA256: (message: TBinaryIn, key: TBinaryIn) => Uint8Array;

data/js/node_modules/@waves/ts-lib-crypto/crypto/hashing.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var param_1 = require("../conversions/param");
+var sha3_1 = require("../libs/sha3");
+// @ts-ignore
+var forgeHmac = __importStar(require("node-forge/lib/hmac"));
+// @ts-ignore
+var forgeMd = __importStar(require("node-forge/lib/md"));
+require("node-forge/lib/sha256");
+var blake = __importStar(require("../libs/blake2b"));
+var string_bytes_1 = require("../conversions/string-bytes");
+exports._hashChain = function (input) {
+    return param_1._fromIn(exports.keccak(exports.blake2b(param_1._fromIn(input))));
+};
+exports.sha256 = function (input) {
+    var md = forgeMd.algorithms.sha256.create();
+    md.update(string_bytes_1.bytesToString(input, 'raw'));
+    return string_bytes_1.stringToBytes(md.digest().getBytes(), 'raw');
+};
+exports.blake2b = function (input) {
+    return blake.blake2b(param_1._fromIn(input), null, 32);
+};
+exports.keccak = function (input) {
+    return param_1._fromIn(sha3_1.keccak256.array(param_1._fromIn(input)));
+};
+exports.hmacSHA256 = function (message, key) {
+    var hmac = forgeHmac.create();
+    hmac.start('sha256', string_bytes_1.bytesToString(param_1._fromIn(key), 'raw'));
+    hmac.update(string_bytes_1.bytesToString(param_1._fromIn(message), 'raw'));
+    return string_bytes_1.stringToBytes(hmac.digest().getBytes(), 'raw');
+};
+//# sourceMappingURL=hashing.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/hashing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.js","sourceRoot":"","sources":["../../src/crypto/hashing.ts"],"names":[],"mappings":";;;;;;;;;AACA,8CAA8C;AAC9C,qCAAwC;AACxC,aAAa;AACb,6DAAgD;AAChD,aAAa;AACb,yDAA4C;AAC5C,iCAA8B;AAC9B,qDAAwC;AACxC,4DAA0E;AAE7D,QAAA,UAAU,GAAG,UAAC,KAAgB;IACzC,OAAA,eAAO,CAAC,cAAM,CAAC,eAAO,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAAxC,CAAwC,CAAA;AAE7B,QAAA,MAAM,GAAG,UAAC,KAAgB;IACrC,IAAM,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,CAAA;IAC7C,EAAE,CAAC,MAAM,CAAC,4BAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAA;IACtC,OAAO,4BAAa,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAA;AACrD,CAAC,CAAA;AAEY,QAAA,OAAO,GAAG,UAAC,KAAgB;IACtC,OAAA,KAAK,CAAC,OAAO,CAAC,eAAO,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC;AAAvC,CAAuC,CAAA;AAE5B,QAAA,MAAM,GAAG,UAAC,KAAgB;IACrC,OAAA,eAAO,CAAC,gBAAS,CAAC,KAAK,CAAC,eAAO,CAAC,KAAK,CAAC,CAAC,CAAC;AAAxC,CAAwC,CAAA;AAE7B,QAAA,UAAU,GAAG,UAAC,OAAkB,EAAE,GAAc;IAC3D,IAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,CAAA;IAC/B,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,4BAAa,CAAC,eAAO,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAA;IACxD,IAAI,CAAC,MAAM,CAAC,4BAAa,CAAC,eAAO,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC,CAAA;IACnD,OAAO,4BAAa,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,EAAE,KAAK,CAAC,CAAA;AACvD,CAAC,CAAA"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/interface.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+export declare const PUBLIC_KEY_LENGTH = 32;
+export declare const PRIVATE_KEY_LENGTH = 32;
+export declare const SIGNATURE_LENGTH = 64;
+export declare const ADDRESS_LENGTH = 26;
+export declare const MAIN_NET_CHAIN_ID = 87;
+export declare const TEST_NET_CHAIN_ID = 84;
+export interface INonceSeed {
+    seed: TBytes;
+    nonce?: number;
+}
+export declare type AESMode = 'CBC' | 'CFB' | 'CTR' | 'OFB' | 'ECB' | 'GCM';
+export declare type RSADigestAlgorithm = 'MD5' | 'SHA1' | 'SHA224' | 'SHA256' | 'SHA384' | 'SHA512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
+export declare type TRandomTypesMap = {
+    Array8: number[];
+    Array16: number[];
+    Array32: number[];
+    Buffer: Buffer;
+    Uint8Array: Uint8Array;
+    Uint16Array: Uint16Array;
+    Uint32Array: Uint32Array;
+};
+export declare type TBytes = Uint8Array;
+export declare type TBase64 = string;
+export declare type TBase58 = string;
+export declare type TBase16 = string;
+export declare type TChainId = string | number;
+export declare type TBinaryIn = TBytes | TBase58 | number[];
+export declare type TRawStringInDiscriminator = {
+    TRawStringIn: null;
+};
+export declare type TRawStringIn = TBytes | string | number[] | TRawStringInDiscriminator;
+export declare type TBinaryOut = TBytes | TBase58;
+export declare type TPublicKey<T extends TBinaryIn = TBase58> = {
+    publicKey: T;
+};
+export declare type TPrivateKey<T extends TBinaryIn = TBase58> = {
+    privateKey: T;
+};
+export declare type TKeyPair<T extends TBinaryIn = TBase58> = TPublicKey<T> & TPrivateKey<T>;
+export declare type TSeed = TRawStringIn | INonceSeed;
+export declare type TRSAKeyPair = {
+    rsaPublic: TBytes;
+    rsaPrivate: TBytes;
+};
+export interface ISeedRelated<TDesiredOut extends TBinaryOut = TBase58> {
+    seedWithNonce: (seed: TSeed, nonce: number) => INonceSeed;
+    keyPair: (seed: TSeed) => TKeyPair<TDesiredOut>;
+    publicKey: (seedOrPrivateKey: TSeed | TPrivateKey<TBinaryIn>) => TDesiredOut;
+    privateKey: (seed: TSeed) => TDesiredOut;
+    address: (seedOrPublicKey: TSeed | TPublicKey<TBinaryIn>, chainId?: TChainId) => TDesiredOut;
+    signBytes: (seedOrPrivateKey: TSeed | TPrivateKey<TBinaryIn>, bytes: TBinaryIn, random?: TBinaryIn) => TDesiredOut;
+}
+export interface ISeedEmbeded<TDesiredOut extends TBinaryOut = TBase58> {
+    seedWithNonce: (nonce: number) => INonceSeed;
+    keyPair: () => TKeyPair<TDesiredOut>;
+    publicKey: () => TDesiredOut;
+    privateKey: () => TDesiredOut;
+    address: (chainId?: TChainId) => TDesiredOut;
+    signBytes: (bytes: TBinaryIn, random?: TBinaryIn) => TDesiredOut;
+}
+export interface IWavesCrypto<TDesiredOut extends TBinaryOut = TBase58> {
+    blake2b: (input: TBinaryIn) => TBytes;
+    keccak: (input: TBinaryIn) => TBytes;
+    sha256: (input: TBinaryIn) => TBytes;
+    base64Encode: (input: TBinaryIn) => TBase64;
+    base64Decode: (input: TBase64) => TBytes;
+    base58Encode: (input: TBinaryIn) => TBase58;
+    base58Decode: (input: TBase58) => TBytes;
+    base16Encode: (input: TBinaryIn) => TBase16;
+    base16Decode: (input: TBase16) => TBytes;
+    stringToBytes: (input: string, encoding?: 'utf8' | 'raw') => TBytes;
+    bytesToString: (input: TBinaryIn, encoding?: 'utf8' | 'raw') => string;
+    split: (binary: TBinaryIn, ...sizes: number[]) => TBytes[];
+    concat: (...binaries: TBinaryIn[]) => TBytes;
+    buildAddress: (publicKeyBytes: TBytes, chainId: TChainId) => TBytes;
+    random<T extends keyof TRandomTypesMap>(count: number, type: T): TRandomTypesMap[T];
+    randomBytes: (size: number) => TBytes;
+    randomSeed: (wordsCount?: number) => string;
+    verifySignature: (publicKey: TBinaryIn, bytes: TBinaryIn, signature: TBinaryIn) => boolean;
+    verifyPublicKey: (publicKey: TBinaryIn) => boolean;
+    verifyAddress: (address: TBinaryIn, optional?: {
+        chainId?: TChainId;
+        publicKey?: TBinaryIn;
+    }) => boolean;
+    sharedKey: (privateKeyFrom: TBinaryIn, publicKeyTo: TBinaryIn, prefix: TRawStringIn) => TDesiredOut;
+    messageDecrypt: (sharedKey: TBinaryIn, encryptedMessage: TBinaryIn) => string;
+    messageEncrypt: (sharedKey: TBinaryIn, message: string) => TBytes;
+    aesEncrypt: (data: TBinaryIn, encryptionKey: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes;
+    aesDecrypt: (encryptedData: TBinaryIn, encryptionKey: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes;
+    encryptSeed: (seed: string, password: string, encryptionRounds?: number) => TBase64;
+    decryptSeed: (encryptedSeed: TBase64, password: string, encryptionRounds?: number) => string;
+    rsaKeyPair: (bits?: number, e?: number) => Promise<TRSAKeyPair>;
+    rsaKeyPairSync: (bits?: number, e?: number) => TRSAKeyPair;
+    rsaSign: (rsaPrivateKey: TBytes, message: TBytes, digest?: RSADigestAlgorithm) => TBytes;
+    rsaVerify: (rsaPublicKey: TBytes, message: TBytes, signature: TBytes, digest?: RSADigestAlgorithm) => boolean;
+    merkleVerify: (rootHash: Uint8Array, merkleProof: Uint8Array, leafData: Uint8Array) => boolean;
+}

data/js/node_modules/@waves/ts-lib-crypto/crypto/interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLIC_KEY_LENGTH = 32;
+exports.PRIVATE_KEY_LENGTH = 32;
+exports.SIGNATURE_LENGTH = 64;
+exports.ADDRESS_LENGTH = 26;
+exports.MAIN_NET_CHAIN_ID = 87; // W
+exports.TEST_NET_CHAIN_ID = 84; // T
+//# sourceMappingURL=interface.js.map

data/js/node_modules/@waves/ts-lib-crypto/crypto/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../src/crypto/interface.ts"],"names":[],"mappings":";;AAAa,QAAA,iBAAiB,GAAG,EAAE,CAAA;AACtB,QAAA,kBAAkB,GAAG,EAAE,CAAA;AACvB,QAAA,gBAAgB,GAAG,EAAE,CAAA;AACrB,QAAA,cAAc,GAAG,EAAE,CAAA;AAEnB,QAAA,iBAAiB,GAAG,EAAE,CAAA,CAAC,IAAI;AAC3B,QAAA,iBAAiB,GAAG,EAAE,CAAA,CAAC,IAAI"}

data/js/node_modules/@waves/ts-lib-crypto/crypto/merkle-verify.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param rootHash
+ * @param merkleProof
+ * @param leafData
+ */
+export declare function merkleVerify(rootHash: Uint8Array, merkleProof: Uint8Array, leafData: Uint8Array): boolean;