@airgap/crypto 0.13.11-beta.1

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2019 Papers GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/derive.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { CryptoConfiguration, CryptoDerivative } from '@airgap/module-kit';
+export declare function derive(crypto: CryptoConfiguration, seed: Buffer, derivationPath?: string): Promise<CryptoDerivative>;

package/derive.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.derive = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var derive_1 = require("./ed25519/derive");
+var derive_2 = require("./sapling/derive");
+var derive_3 = require("./secp256k1/derive");
+var derive_4 = require("./sr25519/derive");
+var factory_1 = require("./utils/factory");
+function derive(crypto, seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var node;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, deriveNode(crypto, seed, derivationPath)];
+                case 1:
+                    node = _a.sent();
+                    return [2 /*return*/, (0, factory_1.newCryptoDerivativeFromNode)(node)];
+            }
+        });
+    });
+}
+exports.derive = derive;
+function deriveNode(crypto, seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (crypto.algorithm) {
+                case 'ed25519':
+                    return [2 /*return*/, (0, derive_1.deriveEd25519)(seed, derivationPath, crypto.key)];
+                case 'sr25519':
+                    return [2 /*return*/, (0, derive_4.deriveSr25519)(crypto.compatibility, seed, derivationPath)];
+                case 'secp256k1':
+                    return [2 /*return*/, (0, derive_3.deriveSecp256K1)(seed, derivationPath, crypto.key)];
+                case 'sapling':
+                    return [2 /*return*/, (0, derive_2.deriveSapling)(seed, derivationPath)];
+                default:
+                    (0, coinlib_core_1.assertNever)(crypto);
+                    throw new Error('Crypto algorithm not supported');
+            }
+            return [2 /*return*/];
+        });
+    });
+}
+//# sourceMappingURL=derive.js.map

package/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../src/derive.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAAkD;AAGlD,2CAAgD;AAChD,2CAAgD;AAChD,6CAAoD;AACpD,2CAAgD;AAEhD,2CAA6D;AAE7D,SAAsB,MAAM,CAAC,MAA2B,EAAE,IAAY,EAAE,cAAuB;;;;;wBAChE,qBAAM,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,cAAc,CAAC,EAAA;;oBAArE,IAAI,GAAmB,SAA8C;oBAE3E,sBAAO,IAAA,qCAA2B,EAAC,IAAI,CAAC,EAAA;;;;CACzC;AAJD,wBAIC;AAED,SAAe,UAAU,CAAC,MAA2B,EAAE,IAAY,EAAE,cAAuB;;;YAC1F,QAAQ,MAAM,CAAC,SAAS,EAAE;gBACxB,KAAK,SAAS;oBACZ,sBAAO,IAAA,sBAAa,EAAC,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,GAAG,CAAC,EAAA;gBACxD,KAAK,SAAS;oBACZ,sBAAO,IAAA,sBAAa,EAAC,MAAM,CAAC,aAAa,EAAE,IAAI,EAAE,cAAc,CAAC,EAAA;gBAClE,KAAK,WAAW;oBACd,sBAAO,IAAA,wBAAe,EAAC,IAAI,EAAE,cAAc,EAAE,MAAM,CAAC,GAAG,CAAC,EAAA;gBAC1D,KAAK,SAAS;oBACZ,sBAAO,IAAA,sBAAa,EAAC,IAAI,EAAE,cAAc,CAAC,EAAA;gBAC5C;oBACE,IAAA,0BAAW,EAAC,MAAM,CAAC,CAAA;oBACnB,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAA;aACpD;;;;CACF"}

package/ed25519/derive.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { DerivationNode } from '../types/derivation';
+export declare function deriveEd25519(seed: Buffer, derivationPath?: string, key?: string): DerivationNode;

package/ed25519/derive.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveEd25519 = void 0;
+var ed25519_1 = require("@airgap/coinlib-core/dependencies/src/@stablelib/ed25519-1.0.3/packages/ed25519/ed25519");
+var sha512_1 = require("@airgap/coinlib-core/dependencies/src/@stablelib/sha512-1.0.1/packages/sha512/sha512");
+var hmac_1 = require("@stablelib/hmac");
+var derivation_1 = require("../utils/derivation");
+var hash_1 = require("../utils/hash");
+var ED25519_KEY = 'ed25519 seed';
+function deriveEd25519(seed, derivationPath, key) {
+    if (key === void 0) { key = ED25519_KEY; }
+    var masterNode = masterNodeFromSeed(seed, key);
+    return derivationPath !== undefined ? derive(masterNode, derivationPath) : masterNode;
+}
+exports.deriveEd25519 = deriveEd25519;
+function masterNodeFromSeed(seed, key) {
+    var _a = getKey(seed, Buffer.from(key, 'utf-8')), secretKey = _a.key, chainCode = _a.chainCode;
+    return {
+        depth: 0,
+        parentFingerprint: 0x00000000,
+        index: 0,
+        chainCode: chainCode,
+        secretKey: secretKey,
+        publicKey: getPublicKey(secretKey)
+    };
+}
+function derive(masterNode, derivationPath) {
+    var derivationIndices = (0, derivation_1.splitDerivationPath)(derivationPath);
+    return derivationIndices.reduce(function (derivedNode, next) {
+        var parentFingerprint = (0, hash_1.hash160)(derivedNode.publicKey).readUInt32BE();
+        var index = next.masked;
+        var indexBuffer = Buffer.alloc(4);
+        indexBuffer.writeUInt32BE(index);
+        var data = Buffer.concat([Buffer.alloc(1, 0), derivedNode.secretKey, indexBuffer]);
+        var _a = getKey(data, derivedNode.chainCode), secretKey = _a.key, chainCode = _a.chainCode;
+        return {
+            depth: derivedNode.depth + 1,
+            parentFingerprint: parentFingerprint,
+            index: index,
+            chainCode: chainCode,
+            secretKey: secretKey,
+            publicKey: getPublicKey(secretKey)
+        };
+    }, masterNode);
+}
+function getKey(data, key) {
+    var I = Buffer.from((0, hmac_1.hmac)(sha512_1.SHA512, key, data));
+    var IL = I.slice(0, 32);
+    var IR = I.slice(32);
+    return { key: IL, chainCode: IR };
+}
+function getPublicKey(privateKey) {
+    var publicKey = (0, ed25519_1.generateKeyPairFromSeed)(privateKey).publicKey;
+    return Buffer.from(publicKey);
+}
+//# sourceMappingURL=derive.js.map

package/ed25519/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../src/ed25519/derive.ts"],"names":[],"mappings":";;;AAAA,mHAAiI;AACjI,+GAA6G;AAC7G,wCAAsC;AAGtC,kDAAyD;AACzD,sCAAuC;AAEvC,IAAM,WAAW,GAAW,cAAc,CAAA;AAE1C,SAAgB,aAAa,CAAC,IAAY,EAAE,cAAuB,EAAE,GAAyB;IAAzB,oBAAA,EAAA,iBAAyB;IAC5F,IAAM,UAAU,GAAmB,kBAAkB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;IAEhE,OAAO,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,UAAU,CAAA;AACvF,CAAC;AAJD,sCAIC;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAE,GAAW;IAC7C,IAAA,KAAgC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,EAAhE,SAAS,SAAA,EAAE,SAAS,eAA4C,CAAA;IAE7E,OAAO;QACL,KAAK,EAAE,CAAC;QACR,iBAAiB,EAAE,UAAU;QAC7B,KAAK,EAAE,CAAC;QACR,SAAS,WAAA;QACT,SAAS,WAAA;QACT,SAAS,EAAE,YAAY,CAAC,SAAS,CAAC;KACnC,CAAA;AACH,CAAC;AAED,SAAS,MAAM,CAAC,UAA0B,EAAE,cAAsB;IAChE,IAAM,iBAAiB,GAAsB,IAAA,gCAAmB,EAAC,cAAc,CAAC,CAAA;IAEhF,OAAO,iBAAiB,CAAC,MAAM,CAAC,UAAC,WAA2B,EAAE,IAAqB;QACjF,IAAM,iBAAiB,GAAW,IAAA,cAAO,EAAC,WAAW,CAAC,SAAS,CAAC,CAAC,YAAY,EAAE,CAAA;QAE/E,IAAM,KAAK,GAAW,IAAI,CAAC,MAAM,CAAA;QACjC,IAAM,WAAW,GAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAC3C,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;QAEhC,IAAM,IAAI,GAAW,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAA;QAEtF,IAAA,KAAgC,MAAM,CAAC,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC,EAA5D,SAAS,SAAA,EAAE,SAAS,eAAwC,CAAA;QAEzE,OAAO;YACL,KAAK,EAAE,WAAW,CAAC,KAAK,GAAG,CAAC;YAC5B,iBAAiB,mBAAA;YACjB,KAAK,OAAA;YACL,SAAS,WAAA;YACT,SAAS,WAAA;YACT,SAAS,EAAE,YAAY,CAAC,SAAS,CAAC;SACnC,CAAA;IACH,CAAC,EAAE,UAAU,CAAC,CAAA;AAChB,CAAC;AAED,SAAS,MAAM,CAAC,IAAY,EAAE,GAAW;IACvC,IAAM,CAAC,GAAW,MAAM,CAAC,IAAI,CAAC,IAAA,WAAI,EAAC,eAAM,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;IACtD,IAAM,EAAE,GAAW,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IACjC,IAAM,EAAE,GAAW,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAE9B,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,CAAA;AACnC,CAAC;AAED,SAAS,YAAY,CAAC,UAAkB;IAC9B,IAAA,SAAS,GAAK,IAAA,iCAAuB,EAAC,UAAU,CAAC,UAAxC,CAAwC;IAEzD,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAC/B,CAAC"}

package/encoding.d.ts

@@ -0,0 +1,12 @@
+import { CryptoDerivative } from '@airgap/module-kit';
+import { Bip32Node, Version } from './utils/bip32';
+import { BytesNode } from './utils/bytes';
+import { HexNode } from './utils/hex';
+import { Zip32Node } from './utils/zip32';
+declare type EncodedNode = BytesNode | HexNode | Bip32Node | Zip32Node;
+export declare function encodeDerivative(type: BytesNode['type'], derivative: CryptoDerivative): BytesNode;
+export declare function encodeDerivative(type: HexNode['type'], derivative: CryptoDerivative): HexNode;
+export declare function encodeDerivative(type: Bip32Node['type'], derivative: CryptoDerivative, version?: Version): Bip32Node;
+export declare function encodeDerivative(type: Zip32Node['type'], derivative: CryptoDerivative): Zip32Node;
+export declare function decodeDerivative(node: EncodedNode): CryptoDerivative;
+export {};

package/encoding.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeDerivative = exports.encodeDerivative = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var bip32_1 = require("./utils/bip32");
+var bytes_1 = require("./utils/bytes");
+var factory_1 = require("./utils/factory");
+var hex_1 = require("./utils/hex");
+var zip32_1 = require("./utils/zip32");
+function encodeDerivative(type, derivative, bip39VersionOrUndefined) {
+    var node = (0, factory_1.newDerivationNodeFromDerivative)(derivative);
+    return encodeNode(type, node, bip39VersionOrUndefined);
+}
+exports.encodeDerivative = encodeDerivative;
+function encodeNode(type, node, bip39VersionOrUndefined) {
+    switch (type) {
+        case 'bytes':
+            return (0, bytes_1.bytesEncodeNode)(node);
+        case 'hex':
+            return (0, hex_1.hexEncodeNode)(node);
+        case 'bip32':
+            return (0, bip32_1.bip32EncodeNode)(node, bip39VersionOrUndefined);
+        case 'zip32':
+            return (0, zip32_1.zip32EncodeNode)(node);
+        default:
+            (0, coinlib_core_1.assertNever)(type);
+            throw new Error('Unsupported encoding type');
+    }
+}
+function decodeDerivative(node) {
+    var decodedNode = decodeNode(node);
+    return (0, factory_1.newCryptoDerivativeFromNode)(decodedNode);
+}
+exports.decodeDerivative = decodeDerivative;
+function decodeNode(node) {
+    switch (node.type) {
+        case 'bytes':
+            return (0, bytes_1.bytesDecodeNode)(node);
+        case 'hex':
+            return (0, hex_1.hexDecodeNode)(node);
+        case 'bip32':
+            return (0, bip32_1.bip32DecodeNode)(node);
+        case 'zip32':
+            return (0, zip32_1.zip32DecodeNode)(node);
+        default:
+            (0, coinlib_core_1.assertNever)(node);
+            throw new Error('Unsupported encoded node type');
+    }
+}
+//# sourceMappingURL=encoding.js.map

package/encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoding.js","sourceRoot":"","sources":["../src/encoding.ts"],"names":[],"mappings":";;;AAAA,qDAAkD;AAIlD,uCAAoF;AACpF,uCAA2E;AAC3E,2CAA8F;AAC9F,mCAAmE;AACnE,uCAA2E;AAS3E,SAAgB,gBAAgB,CAAC,IAAkB,EAAE,UAA4B,EAAE,uBAAiC;IAClH,IAAM,IAAI,GAAmB,IAAA,yCAA+B,EAAC,UAAU,CAAC,CAAA;IAExE,OAAO,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,uBAAuB,CAAC,CAAA;AACxD,CAAC;AAJD,4CAIC;AAED,SAAS,UAAU,CAAC,IAAkB,EAAE,IAAoB,EAAE,uBAAiC;IAC7F,QAAQ,IAAI,EAAE;QACZ,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;QAC9B,KAAK,KAAK;YACR,OAAO,IAAA,mBAAa,EAAC,IAAI,CAAC,CAAA;QAC5B,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;QACvD,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;QAC9B;YACE,IAAA,0BAAW,EAAC,IAAI,CAAC,CAAA;YACjB,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAA;KAC/C;AACH,CAAC;AAED,SAAgB,gBAAgB,CAAC,IAAiB;IAChD,IAAM,WAAW,GAAmB,UAAU,CAAC,IAAI,CAAC,CAAA;IAEpD,OAAO,IAAA,qCAA2B,EAAC,WAAW,CAAC,CAAA;AACjD,CAAC;AAJD,4CAIC;AAED,SAAS,UAAU,CAAC,IAAiB;IACnC,QAAQ,IAAI,CAAC,IAAI,EAAE;QACjB,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;QAC9B,KAAK,KAAK;YACR,OAAO,IAAA,mBAAa,EAAC,IAAI,CAAC,CAAA;QAC5B,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;QAC9B,KAAK,OAAO;YACV,OAAO,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;QAC9B;YACE,IAAA,0BAAW,EAAC,IAAI,CAAC,CAAA;YACjB,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAA;KACnD;AACH,CAAC"}

package/index.d.ts

@@ -0,0 +1,8 @@
+import { derive } from './derive';
+import { deriveEd25519 } from './ed25519/derive';
+import { decodeDerivative, encodeDerivative } from './encoding';
+import { mnemonicToSeed } from './secret';
+import { deriveSr25519 } from './sr25519/derive';
+export { derive, deriveEd25519, deriveSr25519 };
+export { mnemonicToSeed };
+export { encodeDerivative, decodeDerivative };

package/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeDerivative = exports.encodeDerivative = exports.mnemonicToSeed = exports.deriveSr25519 = exports.deriveEd25519 = exports.derive = void 0;
+var derive_1 = require("./derive");
+Object.defineProperty(exports, "derive", { enumerable: true, get: function () { return derive_1.derive; } });
+var derive_2 = require("./ed25519/derive");
+Object.defineProperty(exports, "deriveEd25519", { enumerable: true, get: function () { return derive_2.deriveEd25519; } });
+var encoding_1 = require("./encoding");
+Object.defineProperty(exports, "decodeDerivative", { enumerable: true, get: function () { return encoding_1.decodeDerivative; } });
+Object.defineProperty(exports, "encodeDerivative", { enumerable: true, get: function () { return encoding_1.encodeDerivative; } });
+var secret_1 = require("./secret");
+Object.defineProperty(exports, "mnemonicToSeed", { enumerable: true, get: function () { return secret_1.mnemonicToSeed; } });
+var derive_3 = require("./sr25519/derive");
+Object.defineProperty(exports, "deriveSr25519", { enumerable: true, get: function () { return derive_3.deriveSr25519; } });
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,mCAAiC;AAQxB,uFARA,eAAM,OAQA;AAPf,2CAAgD;AAO/B,8FAPR,sBAAa,OAOQ;AAN9B,uCAA+D;AAcpC,iGAdlB,2BAAgB,OAckB;AAAlC,iGAdkB,2BAAgB,OAclB;AAbzB,mCAAyC;AAShC,+FATA,uBAAc,OASA;AARvB,2CAAgD;AAIhB,8FAJvB,sBAAa,OAIuB"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@airgap/crypto",
+  "version": "0.13.11-beta.1",
+  "description": "TODO",
+  "keywords": [
+    "airgap",
+    "blockchain",
+    "crypto"
+  ],
+  "license": "MIT",
+  "homepage": "https://www.airgap.it",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/airgap-it/airgap-coin-lib"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsc && node scripts/copy-files-after-build.js",
+    "build-scripts": "tsc scripts/*.ts",
+    "lint": "tslint -c ./tslint.json --project ./tsconfig.json --format stylish --fix",
+    "lint:prettier": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "lint-ci": "tslint -t json -o ../../lint-reports/crypto.json --project . || true",
+    "lint-ci:prettier": "prettier \"src/**/*.ts\" \"test/**/*.ts\" --list-different",
+    "test": "",
+    "test-ci": "",
+    "test-legacy": "",
+    "browserify": "browserify ./dist/index.js -s airgapCrypto > ./dist/airgap-crypto.min.js"
+  },
+  "author": "Papers GmbH <contact@papers.ch> (https://papers.ch)",
+  "dependencies": {
+    "@airgap/coinlib-core": "*",
+    "@airgap/module-kit": "*",
+    "@airgap/sapling-wasm": "^0.0.9",
+    "@polkadot/wasm-crypto": "0.20.1",
+    "@stablelib/hmac": "^1.0.1"
+  },
+  "nyc": {
+    "include": [
+      "src/**/*.ts"
+    ],
+    "exclude": [
+      "test/**/*.spec.ts"
+    ],
+    "extension": [
+      ".ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ],
+    "reporter": [
+      "text",
+      "text-summary"
+    ],
+    "report-dir": "../../coverage/crypto",
+    "sourceMap": true,
+    "instrument": true
+  }
+}

package/sapling/derive.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { DerivationNode } from '../types/derivation';
+export declare function deriveSapling(seed: Buffer, derivationPath?: string): Promise<DerivationNode>;

package/sapling/derive.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSapling = void 0;
+var sapling_wasm_1 = require("@airgap/sapling-wasm");
+var zip32_1 = require("../utils/zip32");
+function deriveSapling(seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var xsk, xfvk;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, sapling_wasm_1.getExtendedSpendingKey)(seed, derivationPath !== null && derivationPath !== void 0 ? derivationPath : 'm/')];
+                case 1:
+                    xsk = _a.sent();
+                    return [4 /*yield*/, (0, sapling_wasm_1.getExtendedFullViewingKeyFromSpendingKey)(xsk)];
+                case 2:
+                    xfvk = _a.sent();
+                    return [2 /*return*/, (0, zip32_1.zip32DecodeNode)({
+                            type: 'zip32bytes',
+                            secretKey: xsk,
+                            publicKey: xfvk
+                        })];
+            }
+        });
+    });
+}
+exports.deriveSapling = deriveSapling;
+//# sourceMappingURL=derive.js.map

package/sapling/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../src/sapling/derive.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAAuG;AAGvG,wCAAgD;AAEhD,SAAsB,aAAa,CAAC,IAAY,EAAE,cAAuB;;;;;wBACnD,qBAAM,IAAA,qCAAsB,EAAC,IAAI,EAAE,cAAc,aAAd,cAAc,cAAd,cAAc,GAAI,IAAI,CAAC,EAAA;;oBAAxE,GAAG,GAAW,SAA0D;oBACzD,qBAAM,IAAA,uDAAwC,EAAC,GAAG,CAAC,EAAA;;oBAAlE,IAAI,GAAW,SAAmD;oBAExE,sBAAO,IAAA,uBAAe,EAAC;4BACrB,IAAI,EAAE,YAAY;4BAClB,SAAS,EAAE,GAAG;4BACd,SAAS,EAAE,IAAI;yBAChB,CAAC,EAAA;;;;CACH;AATD,sCASC"}

package/secp256k1/derive.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { DerivationNode } from '../types/derivation';
+export declare function deriveSecp256K1(seed: Buffer, derivationPath?: string, key?: string): DerivationNode;

package/secp256k1/derive.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSecp256K1 = void 0;
+var sha512_1 = require("@airgap/coinlib-core/dependencies/src/@stablelib/sha512-1.0.1/packages/sha512/sha512");
+// @ts-ignore
+var elliptic_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/secp256k1-4.0.2/elliptic"));
+var hmac_1 = require("@stablelib/hmac");
+var derivation_1 = require("../utils/derivation");
+var hash_1 = require("../utils/hash");
+var BITCOIN_KEY = 'Bitcoin seed';
+function deriveSecp256K1(seed, derivationPath, key) {
+    if (key === void 0) { key = BITCOIN_KEY; }
+    var masterNode = masterNodeFromSeed(seed, key);
+    return derivationPath !== undefined ? derive(masterNode, derivationPath) : masterNode;
+}
+exports.deriveSecp256K1 = deriveSecp256K1;
+function masterNodeFromSeed(seed, key) {
+    var _a = getKey(seed, Buffer.from(key, 'utf-8')), secretKey = _a.key, chainCode = _a.chainCode;
+    return {
+        depth: 0,
+        parentFingerprint: 0x00000000,
+        index: 0,
+        chainCode: chainCode,
+        secretKey: secretKey,
+        publicKey: getPublicKey(secretKey)
+    };
+}
+function derive(masterNode, derivationPath) {
+    var derivationIndices = (0, derivation_1.splitDerivationPath)(derivationPath);
+    return derivationIndices.reduce(deriveChild, masterNode);
+}
+function deriveChild(node, derivationIndex) {
+    var parentFingerprint = (0, hash_1.hash160)(node.publicKey).readUInt32BE();
+    var index = derivationIndex.masked;
+    var indexBuffer = Buffer.alloc(4);
+    indexBuffer.writeUInt32BE(index);
+    var data = derivationIndex.isHardened
+        ? Buffer.concat([Buffer.alloc(1, 0), node.secretKey, indexBuffer])
+        : Buffer.concat([node.publicKey, indexBuffer]);
+    var _a = getKey(data, node.chainCode), key = _a.key, chainCode = _a.chainCode;
+    try {
+        var ki = Buffer.from(elliptic_1.default.privateKeyTweakAdd(Buffer.from(node.secretKey), key));
+        return {
+            depth: node.depth + 1,
+            parentFingerprint: parentFingerprint,
+            index: index,
+            chainCode: chainCode,
+            secretKey: ki,
+            publicKey: getPublicKey(ki)
+        };
+    }
+    catch (_b) {
+        return deriveChild(node, (0, derivation_1.incIndex)(derivationIndex));
+    }
+}
+function getKey(data, key) {
+    var I = Buffer.from((0, hmac_1.hmac)(sha512_1.SHA512, key, data));
+    var IL = I.slice(0, 32);
+    var IR = I.slice(32);
+    return { key: IL, chainCode: IR };
+}
+function getPublicKey(privateKey) {
+    var publicKey = elliptic_1.default.publicKeyCreate(privateKey, true);
+    return Buffer.from(publicKey);
+}
+//# sourceMappingURL=derive.js.map

package/secp256k1/derive.js.map

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

package/secret.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { CryptoConfiguration } from '@airgap/module-kit';
+export declare function mnemonicToSeed(crypto: CryptoConfiguration, mnemonic: string, password?: string): Promise<Buffer>;

package/secret.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToSeed = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+// @ts-ignore
+var bip39_2_5_0_1 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0");
+var wasm_crypto_1 = require("@polkadot/wasm-crypto");
+function mnemonicToSeed(crypto, mnemonic, password) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var seed, _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (!(crypto.algorithm !== 'sr25519')) return [3 /*break*/, 1];
+                    _b = mnemonicToBip39Seed((_a = crypto.secretType) !== null && _a !== void 0 ? _a : 'secret', mnemonic, password);
+                    return [3 /*break*/, 5];
+                case 1:
+                    if (!(crypto.compatibility === 'substrate')) return [3 /*break*/, 3];
+                    return [4 /*yield*/, mnemonicToSubstrateSeed(mnemonic, password)];
+                case 2:
+                    _c = _d.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    _c = undefined;
+                    _d.label = 4;
+                case 4:
+                    _b = _c;
+                    _d.label = 5;
+                case 5:
+                    seed = _b;
+                    if (seed === undefined) {
+                        throw new Error('Invalid crypto configuration');
+                    }
+                    return [2 /*return*/, seed];
+            }
+        });
+    });
+}
+exports.mnemonicToSeed = mnemonicToSeed;
+function mnemonicToSubstrateSeed(mnemonic, password) {
+    return __awaiter(this, void 0, void 0, function () {
+        var secret;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, wasm_crypto_1.waitReady)()];
+                case 1:
+                    _a.sent();
+                    secret = (0, wasm_crypto_1.bip39ToMiniSecret)(mnemonic, password || '');
+                    return [2 /*return*/, Buffer.from(secret)];
+            }
+        });
+    });
+}
+function mnemonicToBip39Seed(secretType, mnemonic, password) {
+    var seed = (0, bip39_2_5_0_1.mnemonicToSeed)(mnemonic, password);
+    switch (secretType) {
+        case 'secret':
+            return seed;
+        case 'miniSecretXor':
+            var first32 = seed.slice(0, 32);
+            var second32_1 = seed.slice(32);
+            // tslint:disable-next-line: no-bitwise
+            return Buffer.from(first32.map(function (byte, index) { return byte ^ second32_1[index]; }));
+        default:
+            (0, coinlib_core_1.assertNever)(secretType);
+            throw new Error("Secret type ".concat(secretType, " is not supported"));
+    }
+}
+//# sourceMappingURL=secret.js.map

package/secret.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret.js","sourceRoot":"","sources":["../src/secret.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAAkD;AAClD,aAAa;AACb,iFAAyG;AAEzG,qDAAoE;AAEpE,SAAsB,cAAc,CAAC,MAA2B,EAAE,QAAgB,EAAE,QAAiB;;;;;;;yBAEjG,CAAA,MAAM,CAAC,SAAS,KAAK,SAAS,CAAA,EAA9B,wBAA8B;oBAC1B,KAAA,mBAAmB,CAAC,MAAA,MAAM,CAAC,UAAU,mCAAI,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;;;yBACtE,CAAA,MAAM,CAAC,aAAa,KAAK,WAAW,CAAA,EAApC,wBAAoC;oBACpC,qBAAM,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAA;;oBAAjD,KAAA,SAAiD,CAAA;;;oBACjD,KAAA,SAAS,CAAA;;;oBAFT,QAES;;;oBALT,IAAI,KAKK;oBAEf,IAAI,IAAI,KAAK,SAAS,EAAE;wBACtB,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAA;qBAChD;oBAED,sBAAO,IAAI,EAAA;;;;CACZ;AAbD,wCAaC;AAED,SAAe,uBAAuB,CAAC,QAAgB,EAAE,QAAiB;;;;;wBACxE,qBAAM,IAAA,uBAAS,GAAE,EAAA;;oBAAjB,SAAiB,CAAA;oBACX,MAAM,GAAe,IAAA,+BAAiB,EAAC,QAAQ,EAAE,QAAQ,IAAI,EAAE,CAAC,CAAA;oBAEtE,sBAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAA;;;;CAC3B;AAED,SAAS,mBAAmB,CAAC,UAA4B,EAAE,QAAgB,EAAE,QAAiB;IAC5F,IAAM,IAAI,GAAW,IAAA,4BAAmB,EAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAE5D,QAAQ,UAAU,EAAE;QAClB,KAAK,QAAQ;YACX,OAAO,IAAI,CAAA;QACb,KAAK,eAAe;YAClB,IAAM,OAAO,GAAW,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;YACzC,IAAM,UAAQ,GAAW,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;YAEvC,uCAAuC;YACvC,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAC,IAAY,EAAE,KAAa,IAAK,OAAA,IAAI,GAAG,UAAQ,CAAC,KAAK,CAAC,EAAtB,CAAsB,CAAC,CAAC,CAAA;QAC1F;YACE,IAAA,0BAAW,EAAC,UAAU,CAAC,CAAA;YACvB,MAAM,IAAI,KAAK,CAAC,sBAAe,UAAU,sBAAmB,CAAC,CAAA;KAChE;AACH,CAAC"}

package/sr25519/derive.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Sr25519CryptoConfiguration } from '@airgap/module-kit';
+import { DerivationNode } from '../types/derivation';
+export declare function deriveSr25519(compatibility: Sr25519CryptoConfiguration['compatibility'], seed: Buffer, derivationPath?: string): Promise<DerivationNode>;

package/sr25519/derive.js

@@ -0,0 +1,129 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSr25519 = void 0;
+var wasm_crypto_1 = require("@polkadot/wasm-crypto");
+var derivation_1 = require("../utils/derivation");
+var hash_1 = require("../utils/hash");
+function deriveSr25519(compatibility, seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, compatibility === 'substrate' ? deriveSr25519Substrate(seed, derivationPath) : deriveSr25519Standard(seed, derivationPath)];
+        });
+    });
+}
+exports.deriveSr25519 = deriveSr25519;
+function deriveSr25519Standard(seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            throw new Error('Not implemented');
+        });
+    });
+}
+function deriveSr25519Substrate(seed, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var masterNode;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, substrateMasterKeyFromSeed(seed)];
+                case 1:
+                    masterNode = _a.sent();
+                    return [2 /*return*/, derivationPath !== undefined ? deriveSubstrate(masterNode, derivationPath) : masterNode];
+            }
+        });
+    });
+}
+function substrateMasterKeyFromSeed(seed) {
+    return __awaiter(this, void 0, void 0, function () {
+        var keyPair, _a, secretKey, publicKey;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, (0, wasm_crypto_1.waitReady)()];
+                case 1:
+                    _b.sent();
+                    keyPair = (0, wasm_crypto_1.sr25519KeypairFromSeed)(seed.slice(0, 32));
+                    _a = splitKeyPair(keyPair), secretKey = _a.secretKey, publicKey = _a.publicKey;
+                    return [2 /*return*/, {
+                            depth: 0,
+                            parentFingerprint: 0x00000000,
+                            index: 0,
+                            chainCode: Buffer.alloc(32, 0),
+                            secretKey: secretKey,
+                            publicKey: publicKey
+                        }];
+            }
+        });
+    });
+}
+function deriveSubstrate(masterNode, derivationPath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var derivationIndices;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, wasm_crypto_1.waitReady)()];
+                case 1:
+                    _a.sent();
+                    derivationIndices = (0, derivation_1.splitDerivationPath)(derivationPath);
+                    return [2 /*return*/, derivationIndices.reduce(function (derivedKey, next) {
+                            var parentFingerprint = (0, hash_1.hash160)(derivedKey.publicKey).readUInt32BE();
+                            var deriveKeyPair = next.isHardened ? wasm_crypto_1.sr25519DeriveKeypairHard : wasm_crypto_1.sr25519DeriveKeypairSoft;
+                            var keyPair = Buffer.concat([derivedKey.secretKey, derivedKey.publicKey]);
+                            var index = Buffer.alloc(32, 0);
+                            index.writeUInt32LE(next.value);
+                            var derivedKeyPair = deriveKeyPair(keyPair, index);
+                            var _a = splitKeyPair(derivedKeyPair), secretKey = _a.secretKey, publicKey = _a.publicKey;
+                            return {
+                                depth: derivedKey.depth + 1,
+                                parentFingerprint: parentFingerprint,
+                                index: next.masked,
+                                chainCode: index,
+                                secretKey: secretKey,
+                                publicKey: publicKey
+                            };
+                        }, masterNode)];
+            }
+        });
+    });
+}
+function splitKeyPair(keyPair) {
+    var keyPairBuffer = Buffer.from(keyPair);
+    var secretKey = keyPairBuffer.slice(0, 64);
+    var publicKey = keyPairBuffer.slice(64);
+    return { secretKey: secretKey, publicKey: publicKey };
+}
+//# sourceMappingURL=derive.js.map

package/sr25519/derive.js.map

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

package/types/derivation.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+export interface DerivationIndex {
+    value: number;
+    masked: number;
+    isHardened: boolean;
+}
+export interface DerivationKey {
+    depth: number;
+    parentFingerprint: number;
+    index: number;
+    chainCode: Buffer;
+    key: Buffer;
+}
+export interface DerivationNode {
+    depth: number;
+    parentFingerprint: number;
+    index: number;
+    chainCode: Buffer;
+    secretKey: Buffer;
+    publicKey: Buffer;
+}
+export declare type DerivationKeyType = Extract<keyof DerivationNode, 'secretKey' | 'publicKey'>;

package/types/derivation.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=derivation.js.map

package/types/derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.js","sourceRoot":"","sources":["../../src/types/derivation.ts"],"names":[],"mappings":""}

package/types/key.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+export interface KeyPair {
+    secretKey: Buffer;
+    publicKey: Buffer;
+}

package/types/key.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=key.js.map

package/types/key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.js","sourceRoot":"","sources":["../../src/types/key.ts"],"names":[],"mappings":""}

package/utils/bip32.d.ts

@@ -0,0 +1,12 @@
+import { DerivationNode } from '../types/derivation';
+export interface Version {
+    secretKey?: string;
+    publicKey?: string;
+}
+export interface Bip32Node {
+    type: 'bip32';
+    secretKey: string;
+    publicKey: string;
+}
+export declare function bip32EncodeNode(node: DerivationNode, version?: Version): Bip32Node;
+export declare function bip32DecodeNode(node: Bip32Node, version?: Version): DerivationNode;

package/utils/bip32.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bip32DecodeNode = exports.bip32EncodeNode = void 0;
+// @ts-ignore
+var bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2/index"));
+var factory_1 = require("./factory");
+var XPRV_VERSION = '0488ade4';
+var XPUB_VERSION = '0488b21e';
+function bip32EncodeNode(node, version) {
+    var _a, _b;
+    if (version === void 0) { version = {}; }
+    return {
+        type: 'bip32',
+        secretKey: encodeKey(node, (_a = version.secretKey) !== null && _a !== void 0 ? _a : XPRV_VERSION, 'secretKey'),
+        publicKey: encodeKey(node, (_b = version.publicKey) !== null && _b !== void 0 ? _b : XPUB_VERSION, 'publicKey')
+    };
+}
+exports.bip32EncodeNode = bip32EncodeNode;
+function encodeKey(node, version, keyType) {
+    var versionBuffer = Buffer.from(version, 'hex');
+    var depth = Buffer.alloc(1);
+    depth.writeUInt8(node.depth);
+    var parentFingerprint = Buffer.alloc(4);
+    parentFingerprint.writeUInt32BE(node.parentFingerprint);
+    var index = Buffer.alloc(4);
+    index.writeUInt32BE(node.index);
+    var chainCode = node.chainCode;
+    var key = keyType === 'secretKey' ? Buffer.concat([Buffer.alloc(1, 0), node[keyType]]) : node[keyType];
+    return bs58check.encode(Buffer.concat([versionBuffer, depth, parentFingerprint, index, chainCode, key]));
+}
+function bip32DecodeNode(node, version) {
+    var _a, _b;
+    if (version === void 0) { version = {}; }
+    var xprvDecoded = decodeKey(node.secretKey, (_a = version.secretKey) !== null && _a !== void 0 ? _a : XPRV_VERSION, 'secretKey');
+    var xpubDecoded = decodeKey(node.publicKey, (_b = version.publicKey) !== null && _b !== void 0 ? _b : XPUB_VERSION, 'publicKey');
+    return (0, factory_1.newDerivationNodeFromKeys)(xprvDecoded, xpubDecoded);
+}
+exports.bip32DecodeNode = bip32DecodeNode;
+function decodeKey(key, version, keyType) {
+    var buffer = bs58check.decode(key);
+    var versionBuffer = buffer.slice(0, 4);
+    if (versionBuffer.toString('hex') !== version) {
+        throw new Error('Invalid Bip32 version');
+    }
+    var depth = buffer.readUInt8(4);
+    var parentFingerprint = buffer.readUInt32BE(5);
+    var index = buffer.readUInt32BE(9);
+    var chainCode = buffer.slice(13, 45);
+    return {
+        depth: depth,
+        parentFingerprint: parentFingerprint,
+        index: index,
+        chainCode: chainCode,
+        key: keyType === 'secretKey' ? buffer.slice(46) : buffer.slice(45)
+    };
+}
+//# sourceMappingURL=bip32.js.map

package/utils/bip32.js.map

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

package/utils/bytes.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { DerivationNode } from '../types/derivation';
+export interface BytesNode {
+    type: 'bytes';
+    secretKey: Buffer;
+    publicKey: Buffer;
+}
+export declare function bytesEncodeNode(node: DerivationNode): BytesNode;
+export declare function bytesDecodeNode(node: BytesNode): DerivationNode;

package/utils/bytes.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesDecodeNode = exports.bytesEncodeNode = void 0;
+var factory_1 = require("./factory");
+function bytesEncodeNode(node) {
+    return {
+        type: 'bytes',
+        secretKey: encodeKey(node, 'secretKey'),
+        publicKey: encodeKey(node, 'publicKey')
+    };
+}
+exports.bytesEncodeNode = bytesEncodeNode;
+function encodeKey(node, keyType) {
+    var depth = Buffer.alloc(1);
+    depth.writeUInt8(node.depth);
+    var parentFingerprint = Buffer.alloc(4);
+    parentFingerprint.writeUInt32BE(node.parentFingerprint);
+    var index = Buffer.alloc(4);
+    index.writeUInt32BE(node.index);
+    var chainCode = node.chainCode;
+    var key = node[keyType];
+    return Buffer.concat([depth, parentFingerprint, index, chainCode, key]);
+}
+function bytesDecodeNode(node) {
+    var xprvDecoded = decodeKey(node.secretKey);
+    var xpubDecoded = decodeKey(node.publicKey);
+    return (0, factory_1.newDerivationNodeFromKeys)(xprvDecoded, xpubDecoded);
+}
+exports.bytesDecodeNode = bytesDecodeNode;
+function decodeKey(buffer) {
+    var depth = buffer.readUInt8(0);
+    var parentFingerprint = buffer.readUInt32BE(1);
+    var index = buffer.readUInt32BE(5);
+    var chainCode = buffer.slice(9, 41);
+    var key = buffer.slice(41);
+    return {
+        depth: depth,
+        parentFingerprint: parentFingerprint,
+        index: index,
+        chainCode: chainCode,
+        key: key
+    };
+}
+//# sourceMappingURL=bytes.js.map

package/utils/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../src/utils/bytes.ts"],"names":[],"mappings":";;;AAEA,qCAAqD;AAQrD,SAAgB,eAAe,CAAC,IAAoB;IAClD,OAAO;QACL,IAAI,EAAE,OAAO;QACb,SAAS,EAAE,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC;QACvC,SAAS,EAAE,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC;KACxC,CAAA;AACH,CAAC;AAND,0CAMC;AAED,SAAS,SAAS,CAAC,IAAoB,EAAE,OAA0B;IACjE,IAAM,KAAK,GAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACrC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAE5B,IAAM,iBAAiB,GAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACjD,iBAAiB,CAAC,aAAa,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAA;IAEvD,IAAM,KAAK,GAAW,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACrC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAE/B,IAAM,SAAS,GAAW,IAAI,CAAC,SAAS,CAAA;IACxC,IAAM,GAAG,GAAW,IAAI,CAAC,OAAO,CAAC,CAAA;IAEjC,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC,CAAA;AACzE,CAAC;AAED,SAAgB,eAAe,CAAC,IAAe;IAC7C,IAAM,WAAW,GAAkB,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IAC5D,IAAM,WAAW,GAAkB,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IAE5D,OAAO,IAAA,mCAAyB,EAAC,WAAW,EAAE,WAAW,CAAC,CAAA;AAC5D,CAAC;AALD,0CAKC;AAED,SAAS,SAAS,CAAC,MAAc;IAC/B,IAAM,KAAK,GAAW,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IACzC,IAAM,iBAAiB,GAAW,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;IACxD,IAAM,KAAK,GAAW,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;IAC5C,IAAM,SAAS,GAAW,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAC7C,IAAM,GAAG,GAAW,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAEpC,OAAO;QACL,KAAK,OAAA;QACL,iBAAiB,mBAAA;QACjB,KAAK,OAAA;QACL,SAAS,WAAA;QACT,GAAG,KAAA;KACJ,CAAA;AACH,CAAC"}

package/utils/derivation.d.ts

@@ -0,0 +1,5 @@
+import { DerivationIndex } from '../types/derivation';
+export declare function createDerivationIndexFromNumber(value: number, isHardened: boolean): DerivationIndex;
+export declare function createDerivationIndexFromString(value: string): DerivationIndex;
+export declare function splitDerivationPath(path: string): DerivationIndex[];
+export declare function incIndex(current: DerivationIndex): DerivationIndex;

package/utils/derivation.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incIndex = exports.splitDerivationPath = exports.createDerivationIndexFromString = exports.createDerivationIndexFromNumber = void 0;
+var MASK_HARD_DERIVATION = 0x80000000;
+var MASK_SOFT_DERIVATION = 0x00000000;
+function createDerivationIndexFromNumber(value, isHardened) {
+    var mask = isHardened ? MASK_HARD_DERIVATION : MASK_SOFT_DERIVATION;
+    return {
+        value: value,
+        // tslint:disable-next-line: no-bitwise
+        masked: parseInt((BigInt(mask) | BigInt(value)).toString(), 10),
+        isHardened: isHardened
+    };
+}
+exports.createDerivationIndexFromNumber = createDerivationIndexFromNumber;
+function createDerivationIndexFromString(value) {
+    var isHardened = ['h', "'"].includes(value.slice(-1));
+    var index = parseInt(isHardened ? value.slice(0, -1) : value, 10);
+    return createDerivationIndexFromNumber(index, isHardened);
+}
+exports.createDerivationIndexFromString = createDerivationIndexFromString;
+function splitDerivationPath(path) {
+    if (path.length === 0 || !path.startsWith('m/') || path === 'm/') {
+        return [];
+    }
+    return path.slice(2).split('/').map(createDerivationIndexFromString);
+}
+exports.splitDerivationPath = splitDerivationPath;
+function incIndex(current) {
+    return createDerivationIndexFromNumber(current.value + 1, current.isHardened);
+}
+exports.incIndex = incIndex;
+//# sourceMappingURL=derivation.js.map

package/utils/derivation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.js","sourceRoot":"","sources":["../../src/utils/derivation.ts"],"names":[],"mappings":";;;AAEA,IAAM,oBAAoB,GAAW,UAAU,CAAA;AAC/C,IAAM,oBAAoB,GAAW,UAAU,CAAA;AAE/C,SAAgB,+BAA+B,CAAC,KAAa,EAAE,UAAmB;IAChF,IAAM,IAAI,GAAW,UAAU,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,oBAAoB,CAAA;IAE7E,OAAO;QACL,KAAK,OAAA;QACL,uCAAuC;QACvC,MAAM,EAAE,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAE,EAAE,CAAC;QAC/D,UAAU,YAAA;KACX,CAAA;AACH,CAAC;AATD,0EASC;AAED,SAAgB,+BAA+B,CAAC,KAAa;IAC3D,IAAM,UAAU,GAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAChE,IAAM,KAAK,GAAW,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;IAE3E,OAAO,+BAA+B,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;AAC3D,CAAC;AALD,0EAKC;AAED,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,IAAI,EAAE;QAChE,OAAO,EAAE,CAAA;KACV;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAA;AACtE,CAAC;AAND,kDAMC;AAED,SAAgB,QAAQ,CAAC,OAAwB;IAC/C,OAAO,+BAA+B,CAAC,OAAO,CAAC,KAAK,GAAG,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;AAC/E,CAAC;AAFD,4BAEC"}

package/utils/factory.d.ts

@@ -0,0 +1,6 @@
+import { CryptoDerivative } from '@airgap/module-kit';
+import { DerivationKey, DerivationNode } from '../types/derivation';
+export declare function newDerivationNodeFromDerivative(derivative: CryptoDerivative): DerivationNode;
+export declare function newDerivationNodeFromKeys(secretKey: DerivationKey, publicKey: DerivationKey): DerivationNode;
+export declare function newCryptoDerivativeFromKeys(secretKey: DerivationKey, publicKey: DerivationKey): CryptoDerivative;
+export declare function newCryptoDerivativeFromNode(node: DerivationNode): CryptoDerivative;

package/utils/factory.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newCryptoDerivativeFromNode = exports.newCryptoDerivativeFromKeys = exports.newDerivationNodeFromKeys = exports.newDerivationNodeFromDerivative = void 0;
+function newDerivationNodeFromDerivative(derivative) {
+    return {
+        depth: derivative.depth,
+        parentFingerprint: derivative.parentFingerprint,
+        index: derivative.index,
+        chainCode: Buffer.from(derivative.chainCode, 'hex'),
+        secretKey: Buffer.from(derivative.secretKey, 'hex'),
+        publicKey: Buffer.from(derivative.publicKey, 'hex')
+    };
+}
+exports.newDerivationNodeFromDerivative = newDerivationNodeFromDerivative;
+function newDerivationNodeFromKeys(secretKey, publicKey) {
+    if (secretKey.depth !== publicKey.depth ||
+        secretKey.parentFingerprint !== publicKey.parentFingerprint ||
+        secretKey.index !== publicKey.index ||
+        !secretKey.chainCode.equals(publicKey.chainCode)) {
+        throw new Error('Derivation keys mismatch');
+    }
+    return {
+        depth: secretKey.depth,
+        parentFingerprint: secretKey.parentFingerprint,
+        index: secretKey.index,
+        chainCode: secretKey.chainCode,
+        secretKey: secretKey.key,
+        publicKey: publicKey.key
+    };
+}
+exports.newDerivationNodeFromKeys = newDerivationNodeFromKeys;
+function newCryptoDerivativeFromKeys(secretKey, publicKey) {
+    var node = newDerivationNodeFromKeys(secretKey, publicKey);
+    return newCryptoDerivativeFromNode(node);
+}
+exports.newCryptoDerivativeFromKeys = newCryptoDerivativeFromKeys;
+function newCryptoDerivativeFromNode(node) {
+    return {
+        depth: node.depth,
+        parentFingerprint: node.parentFingerprint,
+        index: node.index,
+        chainCode: node.chainCode.toString('hex'),
+        secretKey: node.secretKey.toString('hex'),
+        publicKey: node.publicKey.toString('hex')
+    };
+}
+exports.newCryptoDerivativeFromNode = newCryptoDerivativeFromNode;
+//# sourceMappingURL=factory.js.map

package/utils/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/utils/factory.ts"],"names":[],"mappings":";;;AAIA,SAAgB,+BAA+B,CAAC,UAA4B;IAC1E,OAAO;QACL,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,iBAAiB,EAAE,UAAU,CAAC,iBAAiB;QAC/C,KAAK,EAAE,UAAU,CAAC,KAAK;QACvB,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC;QACnD,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC;QACnD,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,KAAK,CAAC;KACpD,CAAA;AACH,CAAC;AATD,0EASC;AAED,SAAgB,yBAAyB,CAAC,SAAwB,EAAE,SAAwB;IAC1F,IACE,SAAS,CAAC,KAAK,KAAK,SAAS,CAAC,KAAK;QACnC,SAAS,CAAC,iBAAiB,KAAK,SAAS,CAAC,iBAAiB;QAC3D,SAAS,CAAC,KAAK,KAAK,SAAS,CAAC,KAAK;QACnC,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,EAChD;QACA,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAA;KAC5C;IAED,OAAO;QACL,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,iBAAiB,EAAE,SAAS,CAAC,iBAAiB;QAC9C,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,SAAS,EAAE,SAAS,CAAC,SAAS;QAC9B,SAAS,EAAE,SAAS,CAAC,GAAG;QACxB,SAAS,EAAE,SAAS,CAAC,GAAG;KACzB,CAAA;AACH,CAAC;AAlBD,8DAkBC;AAED,SAAgB,2BAA2B,CAAC,SAAwB,EAAE,SAAwB;IAC5F,IAAM,IAAI,GAAmB,yBAAyB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;IAE5E,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAA;AAC1C,CAAC;AAJD,kEAIC;AAED,SAAgB,2BAA2B,CAAC,IAAoB;IAC9D,OAAO;QACL,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;QACzC,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;QACzC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;QACzC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;KAC1C,CAAA;AACH,CAAC;AATD,kEASC"}

package/utils/hash.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function hash160(data: string | Uint8Array | Buffer): Buffer;

package/utils/hash.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hash160 = void 0;
+// @ts-ignore
+var create_hash_1_2_0_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/create-hash-1.2.0")); // TODO: check if it can be replaced with `crypto.createHash`
+function hash160(data) {
+    var sha256Hash = (0, create_hash_1_2_0_1.default)('sha256').update(data).digest();
+    try {
+        return (0, create_hash_1_2_0_1.default)('rmd160').update(sha256Hash).digest();
+    }
+    catch (_a) {
+        return (0, create_hash_1_2_0_1.default)('ripemd160').update(sha256Hash).digest();
+    }
+}
+exports.hash160 = hash160;
+//# sourceMappingURL=hash.js.map

package/utils/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":";;;;;;AAAA,aAAa;AACb,8GAAgF,CAAC,6DAA6D;AAE9I,SAAgB,OAAO,CAAC,IAAkC;IACxD,IAAM,UAAU,GAAG,IAAA,2BAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAA;IAC7D,IAAI;QACF,OAAO,IAAA,2BAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,CAAA;KACxD;IAAC,WAAM;QACN,OAAO,IAAA,2BAAU,EAAC,WAAW,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,MAAM,EAAE,CAAA;KAC3D;AACH,CAAC;AAPD,0BAOC"}

package/utils/hex.d.ts

@@ -0,0 +1,8 @@
+import { DerivationNode } from '../types/derivation';
+export interface HexNode {
+    type: 'hex';
+    secretKey: string;
+    publicKey: string;
+}
+export declare function hexEncodeNode(node: DerivationNode): HexNode;
+export declare function hexDecodeNode(node: HexNode): DerivationNode;

package/utils/hex.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexDecodeNode = exports.hexEncodeNode = void 0;
+var bytes_1 = require("./bytes");
+function hexEncodeNode(node) {
+    var bytesNode = (0, bytes_1.bytesEncodeNode)(node);
+    return {
+        type: 'hex',
+        secretKey: bytesNode.secretKey.toString('hex'),
+        publicKey: bytesNode.publicKey.toString('hex')
+    };
+}
+exports.hexEncodeNode = hexEncodeNode;
+function hexDecodeNode(node) {
+    return (0, bytes_1.bytesDecodeNode)({
+        type: 'bytes',
+        secretKey: Buffer.from(node.secretKey, 'hex'),
+        publicKey: Buffer.from(node.publicKey, 'hex')
+    });
+}
+exports.hexDecodeNode = hexDecodeNode;
+//# sourceMappingURL=hex.js.map

package/utils/hex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex.js","sourceRoot":"","sources":["../../src/utils/hex.ts"],"names":[],"mappings":";;;AAEA,iCAA0D;AAQ1D,SAAgB,aAAa,CAAC,IAAoB;IAChD,IAAM,SAAS,GAAG,IAAA,uBAAe,EAAC,IAAI,CAAC,CAAA;IAEvC,OAAO;QACL,IAAI,EAAE,KAAK;QACX,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;QAC9C,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC;KAC/C,CAAA;AACH,CAAC;AARD,sCAQC;AAED,SAAgB,aAAa,CAAC,IAAa;IACzC,OAAO,IAAA,uBAAe,EAAC;QACrB,IAAI,EAAE,OAAO;QACb,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC;QAC7C,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC;KAC9C,CAAC,CAAA;AACJ,CAAC;AAND,sCAMC"}

package/utils/zip32.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { DerivationNode } from '../types/derivation';
+export interface Zip32Node {
+    type: 'zip32';
+    secretKey: string;
+    publicKey: string;
+}
+export interface Zip32BytesNode {
+    type: 'zip32bytes';
+    secretKey: Buffer;
+    publicKey: Buffer;
+}
+export declare function zip32EncodeNode(node: DerivationNode): Zip32Node;
+export declare function zip32DecodeNode(node: Zip32Node | Zip32BytesNode): DerivationNode;

package/utils/zip32.js

@@ -0,0 +1,25 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip32DecodeNode = exports.zip32EncodeNode = void 0;
+var bytes_1 = require("./bytes");
+var hex_1 = require("./hex");
+function zip32EncodeNode(node) {
+    return __assign(__assign({}, (0, hex_1.hexEncodeNode)(node)), { type: 'zip32' });
+}
+exports.zip32EncodeNode = zip32EncodeNode;
+function zip32DecodeNode(node) {
+    return node.type === 'zip32' ? (0, hex_1.hexDecodeNode)(__assign(__assign({}, node), { type: 'hex' })) : (0, bytes_1.bytesDecodeNode)(__assign(__assign({}, node), { type: 'bytes' }));
+}
+exports.zip32DecodeNode = zip32DecodeNode;
+//# sourceMappingURL=zip32.js.map

package/utils/zip32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip32.js","sourceRoot":"","sources":["../../src/utils/zip32.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAEA,iCAAyC;AACzC,6BAAoD;AAcpD,SAAgB,eAAe,CAAC,IAAoB;IAClD,6BACK,IAAA,mBAAa,EAAC,IAAI,CAAC,KACtB,IAAI,EAAE,OAAO,IACd;AACH,CAAC;AALD,0CAKC;AAED,SAAgB,eAAe,CAAC,IAAgC;IAC9D,OAAO,IAAI,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,IAAA,mBAAa,wBAAM,IAAI,KAAE,IAAI,EAAE,KAAK,IAAG,CAAC,CAAC,CAAC,IAAA,uBAAe,wBAAM,IAAI,KAAE,IAAI,EAAE,OAAO,IAAG,CAAA;AACtH,CAAC;AAFD,0CAEC"}