@bitgo/account-lib 2.20.1-rc.2 → 2.21.0-hotfix.0

package/dist/src/coin/baseCoin/blsKeyPair.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { BaseKeyPair } from './baseKeyPair';
+import { AddressFormat } from './enum';
+import { BlsKeys, KeyPairOptions } from './iface';
+/**
+ * Base class for BLS keypairs.
+ */
+export declare abstract class BlsKeyPair implements BaseKeyPair {
+    protected keyPair: BlsKeys;
+    /**
+     * Public constructor. By default, creates a key pair with a random polynomial.
+     *
+     * @param {KeyPairOptions} source Either a dkg options, a public and secret shares, or a private key
+     */
+    protected constructor(source?: KeyPairOptions);
+    createShares(threshold: number, participants: number): void;
+    /**
+     * Note - this is not possible using BLS. BLS does not support prvkey derived key gen
+     *
+     * @param {string[]} prv a hexadecimal private key
+     */
+    recordKeysFromPrivateKey(prv: string): void;
+    /**
+     * Note - this is not possible using BLS. BLS does not support pubkey derived key gen
+     *
+     * @param {string} pub - An extended, compressed, or uncompressed public key
+     */
+    recordKeysFromPublicKey(pub: string): void;
+    getAddress(format?: AddressFormat): string;
+    getKeys(): any;
+    /**
+     * Signs bytes using the key pair
+     *
+     * @param msg The message bytes to sign
+     * @return signature of the bytes using this keypair
+     */
+    sign(msg: Buffer): Promise<string>;
+    /**
+     * Aggregates the secret shares of different key pairs into one private key
+     *
+     * @param prvKeys an array of secret shares
+     * @returns a private key
+     */
+    static aggregatePrvkeys(prvKeys: string[]): string;
+    /**
+     * Aggregates the public shares of different key pairs into a common public key
+     *
+     * @param pubKeys an array of public shares
+     * @returns a common public key
+     */
+    static aggregatePubkeys(pubKeys: string[]): string;
+    /**
+     * Aggregates the message signed by different key pairs into one sign
+     *
+     * @param signatures the message signed by different key pairs. The signer id is relevant to ensure a valid signature.
+     * @example <caption> E.g., the message is signed by user and wallet, then signatures would be:</caption>
+     * {
+     *   1: BigInt(messageSignedWithUserPrv),
+     *   3: BigInt(messageSignedWithWalletPrv),
+     * }
+     * @returns a signature combining all the provided signed messages
+     */
+    static aggregateSignatures(signatures: {
+        [n: number]: bigint;
+    }): string;
+    /**
+     * Verifies the signature for this key pair
+     * @param pub The public key with which to verify the signature
+     * @param msg The message to verify the signature with
+     * @param signature the signature to verify
+     * @return true if the signature is valid, else false
+     */
+    static verifySignature(pub: string, msg: Buffer, signature: string): Promise<boolean>;
+}
+//# sourceMappingURL=blsKeyPair.d.ts.map

package/dist/src/coin/baseCoin/blsKeyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blsKeyPair.d.ts","sourceRoot":"","sources":["../../../../src/coin/baseCoin/blsKeyPair.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,OAAO,EAAE,cAAc,EAAiC,MAAM,SAAS,CAAC;AAMjF;;GAEG;AACH,8BAAsB,UAAW,YAAW,WAAW;IACrD,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC;IAE3B;;;;OAIG;IACH,SAAS,aAAa,MAAM,CAAC,EAAE,cAAc;IAoB7C,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAa3D;;;;OAIG;IACH,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;OAIG;IACH,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI1C,UAAU,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM;IAI1C,OAAO,IAAI,GAAG;IAId;;;;;OAKG;IACG,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAQxC;;;;;OAKG;WACW,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM;IAWzD;;;;;OAKG;WACW,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM;IAUzD;;;;;;;;;;OAUG;WACW,mBAAmB,CAAC,UAAU,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,MAAM;IAS9E;;;;;;OAMG;WACiB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAInG"}

package/dist/src/coin/baseCoin/blsKeyPair.js

@@ -0,0 +1,232 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlsKeyPair = void 0;
+var assert_1 = __importDefault(require("assert"));
+var BLS = __importStar(require("@bitgo/bls-dkg"));
+var errors_1 = require("./errors");
+var iface_1 = require("./iface");
+var crypto_1 = require("../../utils/crypto");
+var DEFAULT_SIGNATURE_THRESHOLD = 2;
+var DEFAULT_SIGNATURE_PARTICIPANTS = 3;
+/**
+ * Base class for BLS keypairs.
+ */
+var BlsKeyPair = /** @class */ (function () {
+    /**
+     * Public constructor. By default, creates a key pair with a random polynomial.
+     *
+     * @param {KeyPairOptions} source Either a dkg options, a public and secret shares, or a private key
+     */
+    function BlsKeyPair(source) {
+        if (!source) {
+            this.createShares(DEFAULT_SIGNATURE_THRESHOLD, DEFAULT_SIGNATURE_PARTICIPANTS);
+        }
+        else if (iface_1.isDkg(source)) {
+            this.createShares(source.threshold, source.participants);
+        }
+        else if (iface_1.isBlsKey(source)) {
+            assert_1.default(source.secretShares.every(crypto_1.isValidBLSPrivateKey), 'Invalid private keys');
+            assert_1.default(crypto_1.isValidBLSPublicKey(source.publicShare), 'Invalid public key');
+            this.keyPair = source;
+        }
+        else if (iface_1.isPrivateKey(source)) {
+            this.keyPair = {
+                prv: source.prv,
+                publicShare: '',
+                secretShares: [],
+            };
+        }
+        else {
+            throw new Error('Invalid key pair options');
+        }
+    }
+    BlsKeyPair.prototype.createShares = function (threshold, participants) {
+        if (participants < threshold) {
+            throw new Error('Participants should be greater than threshold');
+        }
+        var polynomial = BLS.generatePolynomial(threshold);
+        var keySecretShares = BLS.secretShares(polynomial, participants);
+        var keyPublicShare = BLS.publicShare(polynomial);
+        this.keyPair = {
+            secretShares: keySecretShares.map(function (secretShare) { return crypto_1.bigIntToHex(secretShare); }),
+            publicShare: crypto_1.bigIntToHex(keyPublicShare),
+        };
+    };
+    /**
+     * Note - this is not possible using BLS. BLS does not support prvkey derived key gen
+     *
+     * @param {string[]} prv a hexadecimal private key
+     */
+    BlsKeyPair.prototype.recordKeysFromPrivateKey = function (prv) {
+        throw new errors_1.NotImplementedError('Private key derivation is not supported in bls');
+    };
+    /**
+     * Note - this is not possible using BLS. BLS does not support pubkey derived key gen
+     *
+     * @param {string} pub - An extended, compressed, or uncompressed public key
+     */
+    BlsKeyPair.prototype.recordKeysFromPublicKey = function (pub) {
+        throw new errors_1.NotImplementedError('Public key derivation is not supported in bls');
+    };
+    BlsKeyPair.prototype.getAddress = function (format) {
+        throw new errors_1.NotImplementedError('getAddress not implemented');
+    };
+    BlsKeyPair.prototype.getKeys = function () {
+        throw new errors_1.NotImplementedError('getKeys not implemented');
+    };
+    /**
+     * Signs bytes using the key pair
+     *
+     * @param msg The message bytes to sign
+     * @return signature of the bytes using this keypair
+     */
+    BlsKeyPair.prototype.sign = function (msg) {
+        return __awaiter(this, void 0, void 0, function () {
+            var signedMessage;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.keyPair.prv) return [3 /*break*/, 2];
+                        return [4 /*yield*/, BLS.sign(msg, BigInt(this.keyPair.prv))];
+                    case 1:
+                        signedMessage = _a.sent();
+                        return [2 /*return*/, crypto_1.bigIntToHex(signedMessage)];
+                    case 2: throw new Error('Missing private key');
+                }
+            });
+        });
+    };
+    /**
+     * Aggregates the secret shares of different key pairs into one private key
+     *
+     * @param prvKeys an array of secret shares
+     * @returns a private key
+     */
+    BlsKeyPair.aggregatePrvkeys = function (prvKeys) {
+        assert_1.default(prvKeys.every(crypto_1.isValidBLSPrivateKey), 'Invalid private keys');
+        try {
+            var secretShares = prvKeys.map(function (secretShare) { return BigInt(secretShare); });
+            var prv = BLS.mergeSecretShares(secretShares);
+            return crypto_1.bigIntToHex(prv);
+        }
+        catch (e) {
+            throw new Error('Error aggregating prvkeys: ' + e);
+        }
+    };
+    /**
+     * Aggregates the public shares of different key pairs into a common public key
+     *
+     * @param pubKeys an array of public shares
+     * @returns a common public key
+     */
+    BlsKeyPair.aggregatePubkeys = function (pubKeys) {
+        try {
+            var secretShares = pubKeys.map(function (secretShare) { return BigInt(secretShare); });
+            var commonPubKey = BLS.mergePublicShares(secretShares);
+            return crypto_1.bigIntToHex(commonPubKey);
+        }
+        catch (e) {
+            throw new Error('Error aggregating pubkeys: ' + e);
+        }
+    };
+    /**
+     * Aggregates the message signed by different key pairs into one sign
+     *
+     * @param signatures the message signed by different key pairs. The signer id is relevant to ensure a valid signature.
+     * @example <caption> E.g., the message is signed by user and wallet, then signatures would be:</caption>
+     * {
+     *   1: BigInt(messageSignedWithUserPrv),
+     *   3: BigInt(messageSignedWithWalletPrv),
+     * }
+     * @returns a signature combining all the provided signed messages
+     */
+    BlsKeyPair.aggregateSignatures = function (signatures) {
+        try {
+            var signature = BLS.mergeSignatures(signatures);
+            return crypto_1.bigIntToHex(signature);
+        }
+        catch (e) {
+            throw new Error('Error aggregating signatures: ' + e);
+        }
+    };
+    /**
+     * Verifies the signature for this key pair
+     * @param pub The public key with which to verify the signature
+     * @param msg The message to verify the signature with
+     * @param signature the signature to verify
+     * @return true if the signature is valid, else false
+     */
+    BlsKeyPair.verifySignature = function (pub, msg, signature) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        assert_1.default(crypto_1.isValidBLSPublicKey(pub), "Invalid public key: " + pub);
+                        return [4 /*yield*/, BLS.verify(BigInt(signature), msg, BigInt(pub))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return BlsKeyPair;
+}());
+exports.BlsKeyPair = BlsKeyPair;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blsKeyPair.js","sourceRoot":"","sources":["../../../../src/coin/baseCoin/blsKeyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport * as BLS from '@bitgo/bls-dkg';\nimport { BaseKeyPair } from './baseKeyPair';\nimport { AddressFormat } from './enum';\nimport { NotImplementedError } from './errors';\nimport { BlsKeys, KeyPairOptions, isDkg, isBlsKey, isPrivateKey } from './iface';\nimport { isValidBLSPublicKey, isValidBLSPrivateKey, bigIntToHex } from '../../utils/crypto';\n\nconst DEFAULT_SIGNATURE_THRESHOLD = 2;\nconst DEFAULT_SIGNATURE_PARTICIPANTS = 3;\n\n/**\n * Base class for BLS keypairs.\n */\nexport abstract class BlsKeyPair implements BaseKeyPair {\n  protected keyPair: BlsKeys;\n\n  /**\n   * Public constructor. By default, creates a key pair with a random polynomial.\n   *\n   * @param {KeyPairOptions} source Either a dkg options, a public and secret shares, or a private key\n   */\n  protected constructor(source?: KeyPairOptions) {\n    if (!source) {\n      this.createShares(DEFAULT_SIGNATURE_THRESHOLD, DEFAULT_SIGNATURE_PARTICIPANTS);\n    } else if (isDkg(source)) {\n      this.createShares(source.threshold, source.participants);\n    } else if (isBlsKey(source)) {\n      assert(source.secretShares.every(isValidBLSPrivateKey), 'Invalid private keys');\n      assert(isValidBLSPublicKey(source.publicShare), 'Invalid public key');\n      this.keyPair = source;\n    } else if (isPrivateKey(source)) {\n      this.keyPair = {\n        prv: source.prv,\n        publicShare: '',\n        secretShares: [],\n      };\n    } else {\n      throw new Error('Invalid key pair options');\n    }\n  }\n\n  createShares(threshold: number, participants: number): void {\n    if (participants < threshold) {\n      throw new Error('Participants should be greater than threshold');\n    }\n    const polynomial = BLS.generatePolynomial(threshold);\n    const keySecretShares = BLS.secretShares(polynomial, participants);\n    const keyPublicShare = BLS.publicShare(polynomial);\n    this.keyPair = {\n      secretShares: keySecretShares.map((secretShare) => bigIntToHex(secretShare)),\n      publicShare: bigIntToHex(keyPublicShare),\n    };\n  }\n\n  /**\n   * Note - this is not possible using BLS. BLS does not support prvkey derived key gen\n   *\n   * @param {string[]} prv a hexadecimal private key\n   */\n  recordKeysFromPrivateKey(prv: string): void {\n    throw new NotImplementedError('Private key derivation is not supported in bls');\n  }\n\n  /**\n   * Note - this is not possible using BLS. BLS does not support pubkey derived key gen\n   *\n   * @param {string} pub - An extended, compressed, or uncompressed public key\n   */\n  recordKeysFromPublicKey(pub: string): void {\n    throw new NotImplementedError('Public key derivation is not supported in bls');\n  }\n\n  getAddress(format?: AddressFormat): string {\n    throw new NotImplementedError('getAddress not implemented');\n  }\n\n  getKeys(): any {\n    throw new NotImplementedError('getKeys not implemented');\n  }\n\n  /**\n   * Signs bytes using the key pair\n   *\n   * @param msg The message bytes to sign\n   * @return signature of the bytes using this keypair\n   */\n  async sign(msg: Buffer): Promise<string> {\n    if (this.keyPair.prv) {\n      const signedMessage = await BLS.sign(msg, BigInt(this.keyPair.prv));\n      return bigIntToHex(signedMessage);\n    }\n    throw new Error('Missing private key');\n  }\n\n  /**\n   * Aggregates the secret shares of different key pairs into one private key\n   *\n   * @param prvKeys an array of secret shares\n   * @returns a private key\n   */\n  public static aggregatePrvkeys(prvKeys: string[]): string {\n    assert(prvKeys.every(isValidBLSPrivateKey), 'Invalid private keys');\n    try {\n      const secretShares = prvKeys.map((secretShare) => BigInt(secretShare));\n      const prv = BLS.mergeSecretShares(secretShares);\n      return bigIntToHex(prv);\n    } catch (e) {\n      throw new Error('Error aggregating prvkeys: ' + e);\n    }\n  }\n\n  /**\n   * Aggregates the public shares of different key pairs into a common public key\n   *\n   * @param pubKeys an array of public shares\n   * @returns a common public key\n   */\n  public static aggregatePubkeys(pubKeys: string[]): string {\n    try {\n      const secretShares = pubKeys.map((secretShare) => BigInt(secretShare));\n      const commonPubKey = BLS.mergePublicShares(secretShares);\n      return bigIntToHex(commonPubKey);\n    } catch (e) {\n      throw new Error('Error aggregating pubkeys: ' + e);\n    }\n  }\n\n  /**\n   * Aggregates the message signed by different key pairs into one sign\n   *\n   * @param signatures the message signed by different key pairs. The signer id is relevant to ensure a valid signature.\n   * @example <caption> E.g., the message is signed by user and wallet, then signatures would be:</caption>\n   * {\n   *   1: BigInt(messageSignedWithUserPrv),\n   *   3: BigInt(messageSignedWithWalletPrv),\n   * }\n   * @returns a signature combining all the provided signed messages\n   */\n  public static aggregateSignatures(signatures: { [n: number]: bigint }): string {\n    try {\n      const signature = BLS.mergeSignatures(signatures);\n      return bigIntToHex(signature);\n    } catch (e) {\n      throw new Error('Error aggregating signatures: ' + e);\n    }\n  }\n\n  /**\n   * Verifies the signature for this key pair\n   * @param pub The public key with which to verify the signature\n   * @param msg The message to verify the signature with\n   * @param signature the signature to verify\n   * @return true if the signature is valid, else false\n   */\n  public static async verifySignature(pub: string, msg: Buffer, signature: string): Promise<boolean> {\n    assert(isValidBLSPublicKey(pub), `Invalid public key: ${pub}`);\n    return await BLS.verify(BigInt(signature), msg, BigInt(pub));\n  }\n}\n"]}

package/dist/src/coin/baseCoin/ed25519KeyPair.d.ts

@@ -0,0 +1,50 @@
+import { BaseKeyPair } from './baseKeyPair';
+import { AddressFormat } from './enum';
+import { DefaultKeys, KeyPairOptions } from './iface';
+export declare abstract class Ed25519KeyPair implements BaseKeyPair {
+    protected keyPair: DefaultKeys;
+    protected source?: KeyPairOptions;
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param {KeyPairOptions} source Either a master seed, a private key, or a public key
+     */
+    protected constructor(source?: KeyPairOptions);
+    private getKeyPair;
+    private setKeyPair;
+    /** @inheritdoc */
+    recordKeysFromPrivateKey(prv: string): void;
+    /** @inheritdoc */
+    recordKeysFromPublicKey(pub: string): void;
+    abstract recordKeysFromPrivateKeyInProtocolFormat(prv: string): DefaultKeys;
+    abstract recordKeysFromPublicKeyInProtocolFormat(pub: string): DefaultKeys;
+    /** @inheritdoc */
+    abstract getAddress(format?: AddressFormat): string;
+    /** @inheritdoc */
+    abstract getKeys(): any;
+    /**
+     * Generates a signature for an arbitrary string with the current private key using the ed25519 public-key signature
+     * system.
+     *
+     * @param {string} message to produce a signature for
+     * @returns {Uint8Array} The signature produced for the message
+     * @throws if there is no private key
+     */
+    signMessage(message: string): Uint8Array;
+    /**
+     * Verifies a message signature using the current public key.
+     *
+     * @param {string} message signed
+     * @param {Uint8Array} signature to verify
+     * @returns {boolean} True if the message was signed with the current key pair
+     */
+    verifySignature(message: Uint8Array | string, signature: Uint8Array): boolean;
+    /**
+     * Derives a hardened child key pair using this key pair's secret key
+     * as the seed.
+     *
+     * @param path derivation path
+     */
+    deriveHardened(path: string): DefaultKeys;
+}
+//# sourceMappingURL=ed25519KeyPair.d.ts.map

package/dist/src/coin/baseCoin/ed25519KeyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519KeyPair.d.ts","sourceRoot":"","sources":["../../../../src/coin/baseCoin/ed25519KeyPair.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AACvC,OAAO,EAAqC,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAIzF,8BAAsB,cAAe,YAAW,WAAW;IACzD,SAAS,CAAC,OAAO,EAAE,WAAW,CAAC;IAC/B,SAAS,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IAElC;;;;OAIG;IACH,SAAS,aAAa,MAAM,CAAC,EAAE,cAAc;IAkB7C,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,UAAU;IAIlB,kBAAkB;IAClB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAc3C,kBAAkB;IAClB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQ1C,QAAQ,CAAC,wCAAwC,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAE3E,QAAQ,CAAC,uCAAuC,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW;IAE1E,kBAAkB;IAClB,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM;IAEnD,kBAAkB;IAClB,QAAQ,CAAC,OAAO,IAAI,GAAG;IAEvB;;;;;;;OAOG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU;IASxC;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,GAAG,OAAO;IAW7E;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;CAU1C"}

package/dist/src/coin/baseCoin/ed25519KeyPair.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.Ed25519KeyPair = void 0;
+var nacl = __importStar(require("tweetnacl"));
+var utils_1 = require("../hbar/utils");
+var crypto_1 = require("../../utils/crypto");
+var ed25519KeyDeriver_1 = require("../../utils/ed25519KeyDeriver");
+var iface_1 = require("./iface");
+var DEFAULT_SEED_SIZE_BYTES = 32;
+var Ed25519KeyPair = /** @class */ (function () {
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param {KeyPairOptions} source Either a master seed, a private key, or a public key
+     */
+    function Ed25519KeyPair(source) {
+        var naclKeyPair;
+        if (!source) {
+            var seed = nacl.randomBytes(DEFAULT_SEED_SIZE_BYTES);
+            naclKeyPair = nacl.sign.keyPair.fromSeed(seed);
+            this.setKeyPair(naclKeyPair);
+        }
+        else if (iface_1.isSeed(source)) {
+            naclKeyPair = nacl.sign.keyPair.fromSeed(source.seed);
+            this.setKeyPair(naclKeyPair);
+        }
+        else if (iface_1.isPrivateKey(source)) {
+            this.recordKeysFromPrivateKey(source.prv);
+        }
+        else if (iface_1.isPublicKey(source)) {
+            this.recordKeysFromPublicKey(source.pub);
+        }
+        else {
+            throw new Error('Invalid key pair options');
+        }
+    }
+    Ed25519KeyPair.prototype.getKeyPair = function (naclKeyPair) {
+        return {
+            prv: utils_1.toHex(naclKeyPair.secretKey.slice(0, 32)),
+            pub: utils_1.toHex(naclKeyPair.publicKey),
+        };
+    };
+    Ed25519KeyPair.prototype.setKeyPair = function (naclKeyPair) {
+        this.keyPair = this.getKeyPair(naclKeyPair);
+    };
+    /** @inheritdoc */
+    Ed25519KeyPair.prototype.recordKeysFromPrivateKey = function (prv) {
+        if (crypto_1.isValidEd25519Seed(prv)) {
+            var decodedPrv = utils_1.toUint8Array(prv);
+            var naclKeyPair = nacl.sign.keyPair.fromSeed(decodedPrv);
+            this.setKeyPair(naclKeyPair);
+        }
+        else if (crypto_1.isValidEd25519SecretKey(prv)) {
+            var decodedPrv = utils_1.toUint8Array(prv);
+            var naclKeyPair = nacl.sign.keyPair.fromSecretKey(decodedPrv);
+            this.setKeyPair(naclKeyPair);
+        }
+        else {
+            this.keyPair = this.recordKeysFromPrivateKeyInProtocolFormat(prv);
+        }
+    };
+    /** @inheritdoc */
+    Ed25519KeyPair.prototype.recordKeysFromPublicKey = function (pub) {
+        if (crypto_1.isValidEd25519PublicKey(pub)) {
+            this.keyPair = { pub: pub };
+        }
+        else {
+            this.keyPair = this.recordKeysFromPublicKeyInProtocolFormat(pub);
+        }
+    };
+    /**
+     * Generates a signature for an arbitrary string with the current private key using the ed25519 public-key signature
+     * system.
+     *
+     * @param {string} message to produce a signature for
+     * @returns {Uint8Array} The signature produced for the message
+     * @throws if there is no private key
+     */
+    Ed25519KeyPair.prototype.signMessage = function (message) {
+        var messageToSign = utils_1.toUint8Array(Buffer.from(message).toString('hex'));
+        var prv = this.keyPair.prv;
+        if (!prv) {
+            throw new Error('Missing private key');
+        }
+        return nacl.sign.detached(messageToSign, nacl.sign.keyPair.fromSeed(utils_1.toUint8Array(prv)).secretKey);
+    };
+    /**
+     * Verifies a message signature using the current public key.
+     *
+     * @param {string} message signed
+     * @param {Uint8Array} signature to verify
+     * @returns {boolean} True if the message was signed with the current key pair
+     */
+    Ed25519KeyPair.prototype.verifySignature = function (message, signature) {
+        var messageToVerify;
+        if (typeof message === 'string') {
+            messageToVerify = utils_1.toUint8Array(Buffer.from(message).toString('hex'));
+        }
+        else {
+            messageToVerify = message;
+        }
+        var publicKey = utils_1.toUint8Array(this.keyPair.pub);
+        return nacl.sign.detached.verify(messageToVerify, signature, publicKey);
+    };
+    /**
+     * Derives a hardened child key pair using this key pair's secret key
+     * as the seed.
+     *
+     * @param path derivation path
+     */
+    Ed25519KeyPair.prototype.deriveHardened = function (path) {
+        if (!this.keyPair.prv) {
+            throw new Error('need private key to derive hardened keypair');
+        }
+        var seed = ed25519KeyDeriver_1.Ed25519KeyDeriver.derivePath(path, this.keyPair.prv).key;
+        var derivedKeyPair = nacl.sign.keyPair.fromSeed(seed);
+        return this.getKeyPair(derivedKeyPair);
+    };
+    return Ed25519KeyPair;
+}());
+exports.Ed25519KeyPair = Ed25519KeyPair;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ed25519KeyPair.js","sourceRoot":"","sources":["../../../../src/coin/baseCoin/ed25519KeyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import * as nacl from 'tweetnacl';\nimport { toHex, toUint8Array } from '../hbar/utils';\nimport { isValidEd25519PublicKey, isValidEd25519SecretKey, isValidEd25519Seed } from '../../utils/crypto';\nimport { Ed25519KeyDeriver } from '../../utils/ed25519KeyDeriver';\nimport { BaseKeyPair } from './baseKeyPair';\nimport { AddressFormat } from './enum';\nimport { isPrivateKey, isPublicKey, isSeed, DefaultKeys, KeyPairOptions } from './iface';\n\nconst DEFAULT_SEED_SIZE_BYTES = 32;\n\nexport abstract class Ed25519KeyPair implements BaseKeyPair {\n  protected keyPair: DefaultKeys;\n  protected source?: KeyPairOptions;\n\n  /**\n   * Public constructor. By default, creates a key pair with a random master seed.\n   *\n   * @param {KeyPairOptions} source Either a master seed, a private key, or a public key\n   */\n  protected constructor(source?: KeyPairOptions) {\n    let naclKeyPair;\n    if (!source) {\n      const seed = nacl.randomBytes(DEFAULT_SEED_SIZE_BYTES);\n      naclKeyPair = nacl.sign.keyPair.fromSeed(seed);\n      this.setKeyPair(naclKeyPair);\n    } else if (isSeed(source)) {\n      naclKeyPair = nacl.sign.keyPair.fromSeed(source.seed);\n      this.setKeyPair(naclKeyPair);\n    } else if (isPrivateKey(source)) {\n      this.recordKeysFromPrivateKey(source.prv);\n    } else if (isPublicKey(source)) {\n      this.recordKeysFromPublicKey(source.pub);\n    } else {\n      throw new Error('Invalid key pair options');\n    }\n  }\n\n  private getKeyPair(naclKeyPair: nacl.SignKeyPair): DefaultKeys {\n    return {\n      prv: toHex(naclKeyPair.secretKey.slice(0, 32)),\n      pub: toHex(naclKeyPair.publicKey),\n    };\n  }\n\n  private setKeyPair(naclKeyPair: nacl.SignKeyPair): void {\n    this.keyPair = this.getKeyPair(naclKeyPair);\n  }\n\n  /** @inheritdoc */\n  recordKeysFromPrivateKey(prv: string): void {\n    if (isValidEd25519Seed(prv)) {\n      const decodedPrv = toUint8Array(prv);\n      const naclKeyPair = nacl.sign.keyPair.fromSeed(decodedPrv);\n      this.setKeyPair(naclKeyPair);\n    } else if (isValidEd25519SecretKey(prv)) {\n      const decodedPrv = toUint8Array(prv);\n      const naclKeyPair = nacl.sign.keyPair.fromSecretKey(decodedPrv);\n      this.setKeyPair(naclKeyPair);\n    } else {\n      this.keyPair = this.recordKeysFromPrivateKeyInProtocolFormat(prv);\n    }\n  }\n\n  /** @inheritdoc */\n  recordKeysFromPublicKey(pub: string): void {\n    if (isValidEd25519PublicKey(pub)) {\n      this.keyPair = { pub };\n    } else {\n      this.keyPair = this.recordKeysFromPublicKeyInProtocolFormat(pub);\n    }\n  }\n\n  abstract recordKeysFromPrivateKeyInProtocolFormat(prv: string): DefaultKeys;\n\n  abstract recordKeysFromPublicKeyInProtocolFormat(pub: string): DefaultKeys;\n\n  /** @inheritdoc */\n  abstract getAddress(format?: AddressFormat): string;\n\n  /** @inheritdoc */\n  abstract getKeys(): any;\n\n  /**\n   * Generates a signature for an arbitrary string with the current private key using the ed25519 public-key signature\n   * system.\n   *\n   * @param {string} message to produce a signature for\n   * @returns {Uint8Array} The signature produced for the message\n   * @throws if there is no private key\n   */\n  signMessage(message: string): Uint8Array {\n    const messageToSign = toUint8Array(Buffer.from(message).toString('hex'));\n    const { prv } = this.keyPair;\n    if (!prv) {\n      throw new Error('Missing private key');\n    }\n    return nacl.sign.detached(messageToSign, nacl.sign.keyPair.fromSeed(toUint8Array(prv)).secretKey);\n  }\n\n  /**\n   * Verifies a message signature using the current public key.\n   *\n   * @param {string} message signed\n   * @param {Uint8Array} signature to verify\n   * @returns {boolean} True if the message was signed with the current key pair\n   */\n  verifySignature(message: Uint8Array | string, signature: Uint8Array): boolean {\n    let messageToVerify;\n    if (typeof message === 'string') {\n      messageToVerify = toUint8Array(Buffer.from(message).toString('hex'));\n    } else {\n      messageToVerify = message;\n    }\n    const publicKey = toUint8Array(this.keyPair.pub);\n    return nacl.sign.detached.verify(messageToVerify, signature, publicKey);\n  }\n\n  /**\n   * Derives a hardened child key pair using this key pair's secret key\n   * as the seed.\n   *\n   * @param path derivation path\n   */\n  deriveHardened(path: string): DefaultKeys {\n    if (!this.keyPair.prv) {\n      throw new Error('need private key to derive hardened keypair');\n    }\n\n    const seed = Ed25519KeyDeriver.derivePath(path, this.keyPair.prv).key;\n    const derivedKeyPair = nacl.sign.keyPair.fromSeed(seed);\n\n    return this.getKeyPair(derivedKeyPair);\n  }\n}\n"]}

package/dist/src/coin/baseCoin/enum.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Internal metadata. Defines the type of transaction.
+ */
+export declare enum TransactionType {
+    Send = 0,
+    SendERC721 = 1,
+    SendERC1155 = 2,
+    WalletInitialization = 3,
+    AddressInitialization = 4,
+    AssociatedTokenAccountInitialization = 5,
+    FlushTokens = 6,
+    FlushCoins = 7,
+    SingleSigSend = 8,
+    AccountUpdate = 9,
+    StakingLock = 10,
+    StakingVote = 11,
+    StakingUnvote = 12,
+    StakingActivate = 13,
+    StakingUnlock = 14,
+    StakingWithdraw = 15,
+    ContractCall = 16,
+    StakingDeactivate = 17,
+    Batch = 18,
+    StakingClaim = 19
+}
+/**
+ * Generic list of encoding formats. Can be used as arguments for methods inputs.
+ */
+export declare enum AddressFormat {
+    hex = "hex",
+    base58 = "base58",
+    substrate = "substrate",
+    polkadot = "polkadot"
+}
+export declare enum StakingOperationTypes {
+    LOCK = 0,
+    VOTE = 1,
+    UNVOTE = 2,
+    ACTIVATE = 3,
+    UNLOCK = 4,
+    WITHDRAW = 5
+}
+//# sourceMappingURL=enum.d.ts.map

package/dist/src/coin/baseCoin/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../../src/coin/baseCoin/enum.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,eAAe;IACzB,IAAI,IAAA;IAEJ,UAAU,IAAA;IAEV,WAAW,IAAA;IAEX,oBAAoB,IAAA;IAEpB,qBAAqB,IAAA;IAErB,oCAAoC,IAAA;IAEpC,WAAW,IAAA;IAEX,UAAU,IAAA;IAEV,aAAa,IAAA;IAEb,aAAa,IAAA;IAEb,WAAW,KAAA;IAEX,WAAW,KAAA;IAEX,aAAa,KAAA;IAEb,eAAe,KAAA;IAEf,aAAa,KAAA;IAEb,eAAe,KAAA;IAEf,YAAY,KAAA;IAEZ,iBAAiB,KAAA;IAEjB,KAAK,KAAA;IAEL,YAAY,KAAA;CACb;AAED;;GAEG;AACH,oBAAY,aAAa;IACvB,GAAG,QAAQ;IACX,MAAM,WAAW;IAEjB,SAAS,cAAc;IAEvB,QAAQ,aAAa;CACtB;AAED,oBAAY,qBAAqB;IAC/B,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,QAAQ,IAAA;CACT"}