@bitgo/sdk-core 1.0.1 → 1.1.0-rc.1

package/dist/src/account-lib/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/account-lib/baseCoin/blsKeyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blsKeyPair.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/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/account-lib/baseCoin/blsKeyPair.js

@@ -0,0 +1,179 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlsKeyPair = void 0;
+const assert_1 = __importDefault(require("assert"));
+const BLS = __importStar(require("@bitgo/bls-dkg"));
+const errors_1 = require("./errors");
+const iface_1 = require("./iface");
+const crypto_1 = require("../util/crypto");
+const DEFAULT_SIGNATURE_THRESHOLD = 2;
+const DEFAULT_SIGNATURE_PARTICIPANTS = 3;
+/**
+ * Base class for BLS keypairs.
+ */
+class BlsKeyPair {
+    /**
+     * 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
+     */
+    constructor(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');
+        }
+    }
+    createShares(threshold, participants) {
+        if (participants < threshold) {
+            throw new Error('Participants should be greater than threshold');
+        }
+        const polynomial = BLS.generatePolynomial(threshold);
+        const keySecretShares = BLS.secretShares(polynomial, participants);
+        const keyPublicShare = BLS.publicShare(polynomial);
+        this.keyPair = {
+            secretShares: keySecretShares.map((secretShare) => 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
+     */
+    recordKeysFromPrivateKey(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
+     */
+    recordKeysFromPublicKey(pub) {
+        throw new errors_1.NotImplementedError('Public key derivation is not supported in bls');
+    }
+    getAddress(format) {
+        throw new errors_1.NotImplementedError('getAddress not implemented');
+    }
+    getKeys() {
+        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
+     */
+    async sign(msg) {
+        var _a;
+        if ((_a = this.keyPair) === null || _a === void 0 ? void 0 : _a.prv) {
+            const signedMessage = await BLS.sign(msg, BigInt(this.keyPair.prv));
+            return crypto_1.bigIntToHex(signedMessage);
+        }
+        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
+     */
+    static aggregatePrvkeys(prvKeys) {
+        assert_1.default(prvKeys.every(crypto_1.isValidBLSPrivateKey), 'Invalid private keys');
+        try {
+            const secretShares = prvKeys.map((secretShare) => BigInt(secretShare));
+            const 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
+     */
+    static aggregatePubkeys(pubKeys) {
+        try {
+            const secretShares = pubKeys.map((secretShare) => BigInt(secretShare));
+            const 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
+     */
+    static aggregateSignatures(signatures) {
+        try {
+            const 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
+     */
+    static async verifySignature(pub, msg, signature) {
+        assert_1.default(crypto_1.isValidBLSPublicKey(pub), `Invalid public key: ${pub}`);
+        return await BLS.verify(BigInt(signature), msg, BigInt(pub));
+    }
+}
+exports.BlsKeyPair = BlsKeyPair;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"blsKeyPair.js","sourceRoot":"","sources":["../../../../src/account-lib/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 '../util/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/account-lib/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/account-lib/baseCoin/ed25519KeyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519KeyPair.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/baseCoin/ed25519KeyPair.ts"],"names":[],"mappings":"AASA,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;IAc7E;;;;;OAKG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW;CAU1C"}

package/dist/src/account-lib/baseCoin/ed25519KeyPair.js

@@ -0,0 +1,145 @@
+"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;
+const nacl = __importStar(require("tweetnacl"));
+const crypto_1 = require("../util/crypto");
+const ed25519KeyDeriver_1 = require("../util/ed25519KeyDeriver");
+const iface_1 = require("./iface");
+const DEFAULT_SEED_SIZE_BYTES = 32;
+class Ed25519KeyPair {
+    /**
+     * 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
+     */
+    constructor(source) {
+        let naclKeyPair;
+        if (!source) {
+            const 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');
+        }
+    }
+    getKeyPair(naclKeyPair) {
+        return {
+            prv: crypto_1.toHex(naclKeyPair.secretKey.slice(0, 32)),
+            pub: crypto_1.toHex(naclKeyPair.publicKey),
+        };
+    }
+    setKeyPair(naclKeyPair) {
+        this.keyPair = this.getKeyPair(naclKeyPair);
+    }
+    /** @inheritdoc */
+    recordKeysFromPrivateKey(prv) {
+        if (crypto_1.isValidEd25519Seed(prv)) {
+            const decodedPrv = crypto_1.toUint8Array(prv);
+            const naclKeyPair = nacl.sign.keyPair.fromSeed(decodedPrv);
+            this.setKeyPair(naclKeyPair);
+        }
+        else if (crypto_1.isValidEd25519SecretKey(prv)) {
+            const decodedPrv = crypto_1.toUint8Array(prv);
+            const naclKeyPair = nacl.sign.keyPair.fromSecretKey(decodedPrv);
+            this.setKeyPair(naclKeyPair);
+        }
+        else {
+            this.keyPair = this.recordKeysFromPrivateKeyInProtocolFormat(prv);
+        }
+    }
+    /** @inheritdoc */
+    recordKeysFromPublicKey(pub) {
+        if (crypto_1.isValidEd25519PublicKey(pub)) {
+            this.keyPair = { 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
+     */
+    signMessage(message) {
+        var _a;
+        const messageToSign = crypto_1.toUint8Array(Buffer.from(message).toString('hex'));
+        const prv = (_a = this.keyPair) === null || _a === void 0 ? void 0 : _a.prv;
+        if (!prv) {
+            throw new Error('Missing private key');
+        }
+        return nacl.sign.detached(messageToSign, nacl.sign.keyPair.fromSeed(crypto_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
+     */
+    verifySignature(message, signature) {
+        var _a;
+        let messageToVerify;
+        if (typeof message === 'string') {
+            messageToVerify = crypto_1.toUint8Array(Buffer.from(message).toString('hex'));
+        }
+        else {
+            messageToVerify = message;
+        }
+        if (!((_a = this.keyPair) === null || _a === void 0 ? void 0 : _a.pub)) {
+            return false;
+        }
+        const publicKey = crypto_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
+     */
+    deriveHardened(path) {
+        var _a;
+        if (!((_a = this.keyPair) === null || _a === void 0 ? void 0 : _a.prv)) {
+            throw new Error('need private key to derive hardened keypair');
+        }
+        const seed = ed25519KeyDeriver_1.Ed25519KeyDeriver.derivePath(path, this.keyPair.prv).key;
+        const derivedKeyPair = nacl.sign.keyPair.fromSeed(seed);
+        return this.getKeyPair(derivedKeyPair);
+    }
+}
+exports.Ed25519KeyPair = Ed25519KeyPair;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ed25519KeyPair.js","sourceRoot":"","sources":["../../../../src/account-lib/baseCoin/ed25519KeyPair.ts"],"names":[],"mappings":"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","sourcesContent":["import * as nacl from 'tweetnacl';\nimport {\n  isValidEd25519PublicKey,\n  isValidEd25519SecretKey,\n  isValidEd25519Seed,\n  toHex,\n  toUint8Array,\n} from '../util/crypto';\nimport { Ed25519KeyDeriver } from '../util/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?.prv;\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    if (!this.keyPair?.pub) {\n      return false;\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/account-lib/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/account-lib/baseCoin/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../../src/account-lib/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"}

package/dist/src/account-lib/baseCoin/enum.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingOperationTypes = exports.AddressFormat = exports.TransactionType = void 0;
+/**
+ * Internal metadata. Defines the type of transaction.
+ */
+var TransactionType;
+(function (TransactionType) {
+    TransactionType[TransactionType["Send"] = 0] = "Send";
+    // Send ERC721 compliant tokens
+    TransactionType[TransactionType["SendERC721"] = 1] = "SendERC721";
+    // Send ERC1155 compliant tokens
+    TransactionType[TransactionType["SendERC1155"] = 2] = "SendERC1155";
+    // Initialize a wallet on-chain (e.g. Multi-sig contract deployment)
+    TransactionType[TransactionType["WalletInitialization"] = 3] = "WalletInitialization";
+    // Initialize an address on-chain(e.g. Forwarder contract deployment)
+    TransactionType[TransactionType["AddressInitialization"] = 4] = "AddressInitialization";
+    // Initialized an associated token account
+    TransactionType[TransactionType["AssociatedTokenAccountInitialization"] = 5] = "AssociatedTokenAccountInitialization";
+    // Flush tokens from a forwarder address to its base address
+    TransactionType[TransactionType["FlushTokens"] = 6] = "FlushTokens";
+    // Flush native coins (eg. ETH) from a forwarder address to base address
+    TransactionType[TransactionType["FlushCoins"] = 7] = "FlushCoins";
+    // Send a raw single-sig transaction
+    TransactionType[TransactionType["SingleSigSend"] = 8] = "SingleSigSend";
+    // Update an account on-chain (e.g. Public key revelation operation for Tezos)
+    TransactionType[TransactionType["AccountUpdate"] = 9] = "AccountUpdate";
+    // Lock
+    TransactionType[TransactionType["StakingLock"] = 10] = "StakingLock";
+    // Vote
+    TransactionType[TransactionType["StakingVote"] = 11] = "StakingVote";
+    // Unvote
+    TransactionType[TransactionType["StakingUnvote"] = 12] = "StakingUnvote";
+    // Activate
+    TransactionType[TransactionType["StakingActivate"] = 13] = "StakingActivate";
+    // Unlock
+    TransactionType[TransactionType["StakingUnlock"] = 14] = "StakingUnlock";
+    // Withdraw
+    TransactionType[TransactionType["StakingWithdraw"] = 15] = "StakingWithdraw";
+    // Handle smart contract calls
+    TransactionType[TransactionType["ContractCall"] = 16] = "ContractCall";
+    // Deactivate
+    TransactionType[TransactionType["StakingDeactivate"] = 17] = "StakingDeactivate";
+    // Batch of multiple transactions broadcast as a single transaction
+    TransactionType[TransactionType["Batch"] = 18] = "Batch";
+    // Claim the staking rewards
+    TransactionType[TransactionType["StakingClaim"] = 19] = "StakingClaim";
+})(TransactionType = exports.TransactionType || (exports.TransactionType = {}));
+/**
+ * Generic list of encoding formats. Can be used as arguments for methods inputs.
+ */
+var AddressFormat;
+(function (AddressFormat) {
+    AddressFormat["hex"] = "hex";
+    AddressFormat["base58"] = "base58";
+    // format for westend addresses
+    AddressFormat["substrate"] = "substrate";
+    // format for polkadot mainnet addresses
+    AddressFormat["polkadot"] = "polkadot";
+})(AddressFormat = exports.AddressFormat || (exports.AddressFormat = {}));
+var StakingOperationTypes;
+(function (StakingOperationTypes) {
+    StakingOperationTypes[StakingOperationTypes["LOCK"] = 0] = "LOCK";
+    StakingOperationTypes[StakingOperationTypes["VOTE"] = 1] = "VOTE";
+    StakingOperationTypes[StakingOperationTypes["UNVOTE"] = 2] = "UNVOTE";
+    StakingOperationTypes[StakingOperationTypes["ACTIVATE"] = 3] = "ACTIVATE";
+    StakingOperationTypes[StakingOperationTypes["UNLOCK"] = 4] = "UNLOCK";
+    StakingOperationTypes[StakingOperationTypes["WITHDRAW"] = 5] = "WITHDRAW";
+})(StakingOperationTypes = exports.StakingOperationTypes || (exports.StakingOperationTypes = {}));
+//# sourceMappingURL=data:application/json;base64,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