@airgap/icp 0.13.11-beta.1 → 0.13.11-beta.2

package/v1/utils/secp256k1.js

@@ -0,0 +1,278 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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;
+};
+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 };
+    }
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Secp256k1KeyIdentity = exports.Secp256k1PublicKey = void 0;
+/* eslint-disable no-underscore-dangle */
+// tslint:disable: max-classes-per-file
+var nacl = __importStar(require("@airgap/coinlib-core/dependencies/src/tweetnacl-1.0.1/nacl"));
+var bip39_1 = require("bip39");
+var js_sha256_1 = require("js-sha256");
+var secp256k1_1 = __importDefault(require("secp256k1"));
+var auth_1 = require("./auth");
+var buffer_1 = require("./buffer");
+var der_1 = require("./der");
+var hdkey_1 = __importDefault(require("./hdkey"));
+var Secp256k1PublicKey = /** @class */ (function () {
+    // `fromRaw` and `fromDer` should be used for instantiation, not this constructor.
+    function Secp256k1PublicKey(key) {
+        key.byteLength;
+        this.rawKey = key;
+        this.derKey = Secp256k1PublicKey.derEncode(key);
+    }
+    /**
+     * Construct Secp256k1PublicKey from an existing PublicKey
+     * @param {PublicKey} key
+     * @returns {Secp256k1PublicKey} Instance of Secp256k1PublicKey
+     */
+    Secp256k1PublicKey.from = function (key) {
+        return this.fromDer(key.toDer());
+    };
+    Secp256k1PublicKey.fromRaw = function (rawKey) {
+        return new Secp256k1PublicKey(rawKey);
+    };
+    Secp256k1PublicKey.fromDer = function (derKey) {
+        return new Secp256k1PublicKey(this.derDecode(derKey));
+    };
+    Secp256k1PublicKey.derEncode = function (publicKey) {
+        return (0, der_1.wrapDER)(publicKey, der_1.SECP256K1_OID).buffer;
+    };
+    Secp256k1PublicKey.derDecode = function (key) {
+        return (0, der_1.unwrapDER)(key, der_1.SECP256K1_OID);
+    };
+    Secp256k1PublicKey.prototype.toDer = function () {
+        return this.derKey;
+    };
+    Secp256k1PublicKey.prototype.toRaw = function () {
+        return this.rawKey;
+    };
+    return Secp256k1PublicKey;
+}());
+exports.Secp256k1PublicKey = Secp256k1PublicKey;
+var Secp256k1KeyIdentity = /** @class */ (function (_super) {
+    __extends(Secp256k1KeyIdentity, _super);
+    function Secp256k1KeyIdentity(publicKey, _privateKey) {
+        var _this = _super.call(this) || this;
+        _this._privateKey = _privateKey;
+        _this._publicKey = publicKey;
+        return _this;
+    }
+    /**
+     * Generates an identity. If a seed is provided, the keys are generated from the
+     * seed according to BIP 0032. Otherwise, the key pair is randomly generated.
+     * This method throws an error in case the seed is not 32 bytes long or invalid
+     * for use as a private key.
+     * @param {Uint8Array} seed the optional seed
+     * @returns {Secp256k1KeyIdentity}
+     */
+    Secp256k1KeyIdentity.generate = function (seed) {
+        if (seed && seed.byteLength !== 32) {
+            throw new Error('Secp256k1 Seed needs to be 32 bytes long.');
+        }
+        var privateKey;
+        if (seed) {
+            // private key from seed according to https://en.bitcoin.it/wiki/BIP_0032
+            // master key generation:
+            privateKey = seed;
+            if (!secp256k1_1.default.privateKeyVerify(privateKey)) {
+                throw new Error('The seed is invalid.');
+            }
+        }
+        else {
+            privateKey = new Uint8Array(nacl.randomBytes(32));
+            while (!secp256k1_1.default.privateKeyVerify(privateKey)) {
+                privateKey = new Uint8Array(nacl.randomBytes(32));
+            }
+        }
+        var publicKeyRaw = secp256k1_1.default.publicKeyCreate(privateKey, false);
+        var publicKey = Secp256k1PublicKey.fromRaw(publicKeyRaw);
+        return new this(publicKey, privateKey);
+    };
+    Secp256k1KeyIdentity.fromParsedJson = function (obj) {
+        var _a = __read(obj, 2), publicKeyRaw = _a[0], privateKeyRaw = _a[1];
+        return new Secp256k1KeyIdentity(Secp256k1PublicKey.fromRaw((0, buffer_1.fromHexString)(publicKeyRaw)), (0, buffer_1.fromHexString)(privateKeyRaw));
+    };
+    Secp256k1KeyIdentity.fromJSON = function (json) {
+        var parsed = JSON.parse(json);
+        if (Array.isArray(parsed)) {
+            if (typeof parsed[0] === 'string' && typeof parsed[1] === 'string') {
+                return this.fromParsedJson([parsed[0], parsed[1]]);
+            }
+            throw new Error('Deserialization error: JSON must have at least 2 items.');
+        }
+        throw new Error("Deserialization error: Invalid JSON type for string: ".concat(JSON.stringify(json)));
+    };
+    /**
+     * generates an identity from a public and private key. Please ensure that you are generating these keys securely and protect the user's private key
+     * @param {ArrayBuffer} publicKey
+     * @param {ArrayBuffer} privateKey
+     * @returns {Secp256k1KeyIdentity}
+     */
+    Secp256k1KeyIdentity.fromKeyPair = function (publicKey, privateKey) {
+        return new Secp256k1KeyIdentity(Secp256k1PublicKey.fromRaw(publicKey), privateKey);
+    };
+    /**
+     * generates an identity from an existing secret key, and is the correct method to generate an identity from a seed phrase. Please ensure you protect the user's private key.
+     * @param {ArrayBuffer} secretKey
+     * @returns {Secp256k1KeyIdentity}
+     */
+    Secp256k1KeyIdentity.fromSecretKey = function (secretKey) {
+        var publicKey = secp256k1_1.default.publicKeyCreate(new Uint8Array(secretKey), false);
+        var identity = Secp256k1KeyIdentity.fromKeyPair(publicKey, new Uint8Array(secretKey));
+        return identity;
+    };
+    /**
+     * Generates an identity from a seed phrase. Use carefully - seed phrases should only be used in secure contexts, and you should avoid having users copying and pasting seed phrases as much as possible.
+     * @param {string | string[]} seedPhrase - either an array of words or a string of words separated by spaces.
+     * @param password - optional password to be used by bip39
+     * @returns Secp256k1KeyIdentity
+     */
+    Secp256k1KeyIdentity.fromSeedPhrase = function (seedPhrase, password, derivationPath) {
+        if (derivationPath === void 0) { derivationPath = "m/44'/223'/0'/0/0"; }
+        // Convert to string for convenience
+        var phrase = Array.isArray(seedPhrase) ? seedPhrase.join(' ') : seedPhrase;
+        // Warn if provided phrase is not conventional
+        if (phrase.split(' ').length < 12 || phrase.split(' ').length > 24) {
+            console.warn('Warning - an unusually formatted seed phrase has been provided. Decoding may not work as expected');
+        }
+        var seed = (0, bip39_1.mnemonicToSeedSync)(phrase, password);
+        var root = hdkey_1.default.fromMasterSeed(seed);
+        var addrnode = root.derive(derivationPath);
+        return Secp256k1KeyIdentity.fromSecretKey(addrnode.privateKey);
+    };
+    /**
+     * Serialize this key to JSON-serializable object.
+     * @returns {JsonableSecp256k1Identity}
+     */
+    Secp256k1KeyIdentity.prototype.toJSON = function () {
+        return [(0, buffer_1.toHexString)(this._publicKey.toRaw()), (0, buffer_1.toHexString)(this._privateKey)];
+    };
+    /**
+     * Return a copy of the key pair.
+     * @returns {KeyPair}
+     */
+    Secp256k1KeyIdentity.prototype.getKeyPair = function () {
+        return {
+            secretKey: this._privateKey,
+            publicKey: this._publicKey
+        };
+    };
+    /**
+     * Return the public key.
+     * @returns {Secp256k1PublicKey}
+     */
+    Secp256k1KeyIdentity.prototype.getPublicKey = function () {
+        return this._publicKey;
+    };
+    /**
+     * Signs a blob of data, with this identity's private key.
+     * @param {ArrayBuffer} challenge - challenge to sign with this identity's secretKey, producing a signature
+     * @returns {Promise<Signature>} signature
+     */
+    Secp256k1KeyIdentity.prototype.sign = function (challenge) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hash, signature;
+            return __generator(this, function (_a) {
+                hash = js_sha256_1.sha256.create();
+                hash.update(challenge);
+                signature = secp256k1_1.default.ecdsaSign(new Uint8Array(hash.digest()), new Uint8Array(this._privateKey)).signature.buffer;
+                return [2 /*return*/, signature];
+            });
+        });
+    };
+    return Secp256k1KeyIdentity;
+}(auth_1.SignIdentity));
+exports.Secp256k1KeyIdentity = Secp256k1KeyIdentity;
+exports.default = Secp256k1KeyIdentity;
+//# sourceMappingURL=secp256k1.js.map

package/v1/utils/secp256k1.js.map

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

package/v1/utils/transaction.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+export declare function encodeTx(transaction: any): string;
+export declare function decodeTx(transaction: string): Buffer;

package/v1/utils/transaction.js

@@ -0,0 +1,56 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTx = exports.encodeTx = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2/index"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var base64Check_1 = __importDefault(require("@airgap/coinlib-core/utils/base64Check"));
+var TRANSACTION_PREFIX = 'tx_';
+function encodeTx(transaction) {
+    return "".concat(TRANSACTION_PREFIX).concat(base64Check_1.default.encode(transaction));
+}
+exports.encodeTx = encodeTx;
+function decodeTx(transaction) {
+    var encoded = transaction.replace(TRANSACTION_PREFIX, '');
+    try {
+        return base64Check_1.default.decode(encoded);
+    }
+    catch (error) {
+        //
+    }
+    try {
+        return bs58check.decode(encoded);
+    }
+    catch (error) {
+        //
+    }
+    throw new errors_1.InvalidValueError(coinlib_core_1.Domain.AETERNITY, 'invalid TX-encoding');
+}
+exports.decodeTx = decodeTx;
+//# sourceMappingURL=transaction.js.map

package/v1/utils/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/v1/utils/transaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qDAA6C;AAC7C,qGAAwF;AACxF,sDAA+D;AAC/D,uFAA8D;AAE9D,IAAM,kBAAkB,GAAW,KAAK,CAAA;AAExC,SAAgB,QAAQ,CAAC,WAAgB;IACvC,OAAO,UAAG,kBAAkB,SAAG,qBAAS,CAAC,MAAM,CAAC,WAAW,CAAC,CAAE,CAAA;AAChE,CAAC;AAFD,4BAEC;AAED,SAAgB,QAAQ,CAAC,WAAmB;IAC1C,IAAM,OAAO,GAAW,WAAW,CAAC,OAAO,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAA;IAEnE,IAAI;QACF,OAAO,qBAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KACjC;IAAC,OAAO,KAAK,EAAE;QACd,EAAE;KACH;IAED,IAAI;QACF,OAAO,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KACjC;IAAC,OAAO,KAAK,EAAE;QACd,EAAE;KACH;IAED,MAAM,IAAI,0BAAiB,CAAC,qBAAM,CAAC,SAAS,EAAE,qBAAqB,CAAC,CAAA;AACtE,CAAC;AAhBD,4BAgBC"}