@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

package/dist/lib/taquito-rpc/src/types.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartRollupRefuteGameEndedReason = exports.SmartRollupRefuteGameEndedPlayerOutcomes = exports.SmartRollupRefuteGameStatusOptions = exports.SmartRollupRefuteRevealProofKind = exports.SmartRollupInputProofKind = exports.SmartRollupRefutationOptions = exports.PvmKind = exports.METADATA_BALANCE_UPDATES_CATEGORY = exports.OPERATION_METADATA = void 0;
+var OPERATION_METADATA;
+(function (OPERATION_METADATA) {
+    OPERATION_METADATA["TOO_LARGE"] = "too large";
+})(OPERATION_METADATA || (exports.OPERATION_METADATA = OPERATION_METADATA = {}));
+var METADATA_BALANCE_UPDATES_CATEGORY;
+(function (METADATA_BALANCE_UPDATES_CATEGORY) {
+    METADATA_BALANCE_UPDATES_CATEGORY["ACTIVATION"] = "activation";
+    METADATA_BALANCE_UPDATES_CATEGORY["ATTESTATION"] = "attestation";
+    METADATA_BALANCE_UPDATES_CATEGORY["ATTESTATIONS_AGGREGATE"] = "attestations_aggregate";
+    METADATA_BALANCE_UPDATES_CATEGORY["ATTESTATION_WITH_DAL"] = "attestation_with_dal";
+    METADATA_BALANCE_UPDATES_CATEGORY["ATTESTING_REWARDS"] = "attesting rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["BAKING_BONUSES"] = "baking bonuses";
+    METADATA_BALANCE_UPDATES_CATEGORY["BAKING_REWARDS"] = "baking rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["BALLOT"] = "ballot";
+    METADATA_BALANCE_UPDATES_CATEGORY["BLOCK_FEES"] = "block fees";
+    METADATA_BALANCE_UPDATES_CATEGORY["BONDS"] = "bonds";
+    METADATA_BALANCE_UPDATES_CATEGORY["BOOTSTRAP"] = "bootstrap";
+    METADATA_BALANCE_UPDATES_CATEGORY["BURNED"] = "burned";
+    METADATA_BALANCE_UPDATES_CATEGORY["COMMITMENT"] = "commitment";
+    METADATA_BALANCE_UPDATES_CATEGORY["DAL_ATTESTING_REWARDS"] = "dal attesting rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["DAL_ENTRAPMENT_EVIDENCE"] = "dal_entrapment_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DAL_PUBLISH_COMMITMENT"] = "dal_publish_commitment";
+    METADATA_BALANCE_UPDATES_CATEGORY["DELEGATE_DENOMINATOR"] = "delegate_denominator";
+    METADATA_BALANCE_UPDATES_CATEGORY["DELEGATION"] = "delegation";
+    METADATA_BALANCE_UPDATES_CATEGORY["DELEGATOR_NUMERATOR"] = "delegator_numerator";
+    METADATA_BALANCE_UPDATES_CATEGORY["DEPOSITS"] = "deposits";
+    METADATA_BALANCE_UPDATES_CATEGORY["DOUBLE_ATTESTATION_EVIDENCE"] = "double_attestation_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DOUBLE_BAKING_EVIDENCE"] = "double_baking_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DOUBLE_ENDORSEMENT_EVIDENCE"] = "double_endorsement_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DOUBLE_PREATTESTATION_EVIDENCE"] = "double_preattestation_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DOUBLE_PREENDORSEMENT_EVIDENCE"] = "double_preendorsement_evidence";
+    METADATA_BALANCE_UPDATES_CATEGORY["DRAIN_DELEGATE"] = "drain_delegate";
+    METADATA_BALANCE_UPDATES_CATEGORY["ENDORSEMENT"] = "endorsement";
+    METADATA_BALANCE_UPDATES_CATEGORY["ENDORSEMENT_WITH_DAL"] = "endorsement_with_dal";
+    METADATA_BALANCE_UPDATES_CATEGORY["EVENT"] = "event";
+    METADATA_BALANCE_UPDATES_CATEGORY["FAILING_NOOP"] = "failing_noop";
+    METADATA_BALANCE_UPDATES_CATEGORY["INCREASE_PAID_STORAGE"] = "increase_paid_storage";
+    METADATA_BALANCE_UPDATES_CATEGORY["INVOICE"] = "invoice";
+    METADATA_BALANCE_UPDATES_CATEGORY["LOST_ATTESTING_REWARDS"] = "lost attesting rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["LOST_DAL_ATTESTING_REWARDS"] = "lost dal attesting rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["MINTED"] = "minted";
+    METADATA_BALANCE_UPDATES_CATEGORY["NONCE_REVELATION_REWARDS"] = "nonce revelation rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["ORIGINATION"] = "origination";
+    METADATA_BALANCE_UPDATES_CATEGORY["PREATTESTATION"] = "preattestation";
+    METADATA_BALANCE_UPDATES_CATEGORY["PREATTESTATIONS_AGGREGATE"] = "preattestations_aggregate";
+    METADATA_BALANCE_UPDATES_CATEGORY["PREENDORSEMENT"] = "preendorsement";
+    METADATA_BALANCE_UPDATES_CATEGORY["PROPOSALS"] = "proposals";
+    METADATA_BALANCE_UPDATES_CATEGORY["PUNISHMENTS"] = "punishments";
+    METADATA_BALANCE_UPDATES_CATEGORY["REGISTER_GLOBAL_CONSTANT"] = "register_global_constant";
+    METADATA_BALANCE_UPDATES_CATEGORY["REVEAL"] = "reveal";
+    METADATA_BALANCE_UPDATES_CATEGORY["SEED_NONCE_REVELATION"] = "seed_nonce_revelation";
+    METADATA_BALANCE_UPDATES_CATEGORY["SET_DEPOSITS_LIMIT"] = "set_deposits_limit";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_ADD_MESSAGES"] = "smart_rollup_add_messages";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_CEMENT"] = "smart_rollup_cement";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE"] = "smart_rollup_execute_outbox_message";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_ORIGINATE"] = "smart_rollup_originate";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_PUBLISH"] = "smart_rollup_publish";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_RECOVER_BOND"] = "smart_rollup_recover_bond";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_REFUTATION_PUNISHMENTS"] = "smart_rollup_refutation_punishments";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_REFUTATION_REWARDS"] = "smart_rollup_refutation_rewards";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_REFUTE"] = "smart_rollup_refute";
+    METADATA_BALANCE_UPDATES_CATEGORY["SMART_ROLLUP_TIMEOUT"] = "smart_rollup_timeout";
+    METADATA_BALANCE_UPDATES_CATEGORY["STORAGE_FEES"] = "storage fees";
+    METADATA_BALANCE_UPDATES_CATEGORY["SUBSIDY"] = "subsidy";
+    METADATA_BALANCE_UPDATES_CATEGORY["TICKET_UPDATES"] = "ticket_updates";
+    METADATA_BALANCE_UPDATES_CATEGORY["TRANSACTION"] = "transaction";
+    METADATA_BALANCE_UPDATES_CATEGORY["TRANSFER_TICKET"] = "transfer_ticket";
+    METADATA_BALANCE_UPDATES_CATEGORY["UNSTAKED_DEPOSITS"] = "unstaked_deposits";
+    METADATA_BALANCE_UPDATES_CATEGORY["UPDATE_COMPANION_KEY"] = "update_companion_key";
+    METADATA_BALANCE_UPDATES_CATEGORY["UPDATE_CONSENSUS_KEY"] = "update_consensus_key";
+    METADATA_BALANCE_UPDATES_CATEGORY["VDF_REVELATION"] = "vdf_revelation";
+})(METADATA_BALANCE_UPDATES_CATEGORY || (exports.METADATA_BALANCE_UPDATES_CATEGORY = METADATA_BALANCE_UPDATES_CATEGORY = {}));
+var PvmKind;
+(function (PvmKind) {
+    PvmKind["WASM2"] = "wasm_2_0_0";
+    PvmKind["ARITH"] = "arith";
+    PvmKind["RISCV"] = "riscv";
+})(PvmKind || (exports.PvmKind = PvmKind = {}));
+var SmartRollupRefutationOptions;
+(function (SmartRollupRefutationOptions) {
+    SmartRollupRefutationOptions["START"] = "start";
+    SmartRollupRefutationOptions["MOVE"] = "move";
+})(SmartRollupRefutationOptions || (exports.SmartRollupRefutationOptions = SmartRollupRefutationOptions = {}));
+var SmartRollupInputProofKind;
+(function (SmartRollupInputProofKind) {
+    SmartRollupInputProofKind["INBOX_PROOF"] = "inbox_proof";
+    SmartRollupInputProofKind["REVEAL_PROOF"] = "reveal_proof";
+    SmartRollupInputProofKind["FIRST_INPUT"] = "first_input";
+})(SmartRollupInputProofKind || (exports.SmartRollupInputProofKind = SmartRollupInputProofKind = {}));
+var SmartRollupRefuteRevealProofKind;
+(function (SmartRollupRefuteRevealProofKind) {
+    SmartRollupRefuteRevealProofKind["RAW_DATA_PROOF"] = "raw_data_proof";
+    SmartRollupRefuteRevealProofKind["METADATA_PROOF"] = "metadata_proof";
+    SmartRollupRefuteRevealProofKind["DAL_PAGE_PROOF"] = "dal_page_proof";
+    SmartRollupRefuteRevealProofKind["DAL_PARAMETERS_PROOF"] = "dal_parameters_proof";
+})(SmartRollupRefuteRevealProofKind || (exports.SmartRollupRefuteRevealProofKind = SmartRollupRefuteRevealProofKind = {}));
+var SmartRollupRefuteGameStatusOptions;
+(function (SmartRollupRefuteGameStatusOptions) {
+    SmartRollupRefuteGameStatusOptions["ONGOING"] = "ongoing";
+    SmartRollupRefuteGameStatusOptions["ENDED"] = "ended";
+})(SmartRollupRefuteGameStatusOptions || (exports.SmartRollupRefuteGameStatusOptions = SmartRollupRefuteGameStatusOptions = {}));
+var SmartRollupRefuteGameEndedPlayerOutcomes;
+(function (SmartRollupRefuteGameEndedPlayerOutcomes) {
+    SmartRollupRefuteGameEndedPlayerOutcomes["LOSER"] = "loser";
+    SmartRollupRefuteGameEndedPlayerOutcomes["DRAW"] = "draw";
+})(SmartRollupRefuteGameEndedPlayerOutcomes || (exports.SmartRollupRefuteGameEndedPlayerOutcomes = SmartRollupRefuteGameEndedPlayerOutcomes = {}));
+var SmartRollupRefuteGameEndedReason;
+(function (SmartRollupRefuteGameEndedReason) {
+    SmartRollupRefuteGameEndedReason["CONFLICT_RESOLVED"] = "conflict_resolved";
+    SmartRollupRefuteGameEndedReason["TIMEOUT"] = "timeout";
+})(SmartRollupRefuteGameEndedReason || (exports.SmartRollupRefuteGameEndedReason = SmartRollupRefuteGameEndedReason = {}));

package/dist/lib/taquito-rpc/src/utils/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castToBigNumber = castToBigNumber;
+exports.castToString = castToString;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+/**
+ * Casts object/array items to BigNumber
+ * @param data input object or array
+ * @param keys keys for processing or all items if not defined
+ *
+ */
+function castToBigNumber(data, keys) {
+    const returnArray = Array.isArray(data);
+    if (typeof keys === 'undefined') {
+        keys = Object.keys(data);
+    }
+    const response = returnArray ? [] : {};
+    keys.forEach((key) => {
+        const item = data[key];
+        let res;
+        if (typeof item === 'undefined') {
+            return;
+        }
+        if (Array.isArray(item)) {
+            res = castToBigNumber(item);
+            response[key] = res;
+            return;
+        }
+        res = new bignumber_js_1.default(item);
+        response[key] = res;
+    });
+    return response;
+}
+/**
+ * Casts object/array BigNumber items to strings for readability
+ * @param data input object or array
+ * @param keys keys for processing or all items if not defined
+ *
+ */
+function castToString(data, keys) {
+    const returnArray = Array.isArray(data);
+    if (typeof keys === 'undefined') {
+        keys = Object.keys(data);
+    }
+    const response = returnArray ? [] : {};
+    keys.forEach((key) => {
+        const item = data[key];
+        if (typeof item === 'undefined') {
+            return;
+        }
+        if (Array.isArray(item)) {
+            response[key] = castToString(item);
+            return;
+        }
+        if (!bignumber_js_1.default.isBigNumber(item)) {
+            response[key] = item;
+            return;
+        }
+        response[key] = item.toString();
+    });
+    return response;
+}

package/dist/lib/taquito-rpc/src/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "fb73f1546d3dff2fbba7741ca6006680212bef16",
+    "version": "24.3.0-beta.2"
+};

package/dist/lib/taquito-signer/src/bls-key.js

@@ -0,0 +1,104 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLSPublicKey = exports.BLSKey = void 0;
+const utils_1 = require("@taquito/utils");
+const bls12_381_1 = require("@noble/curves/bls12-381");
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const bls = bls12_381_1.bls12_381.longSignatures; // AKA MinPK
+class BLSKey {
+    constructor(key, decrypt) {
+        _BLSKey_key.set(this, void 0);
+        _BLSKey_publicKey.set(this, void 0);
+        const tmp = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
+            utils_1.PrefixV2.BLS12_381EncryptedSecretKey,
+            utils_1.PrefixV2.BLS12_381SecretKey,
+        ]);
+        let [keyData] = tmp;
+        const [, prefix] = tmp;
+        if (prefix === utils_1.PrefixV2.BLS12_381EncryptedSecretKey) {
+            if (decrypt !== undefined) {
+                keyData = decrypt(keyData);
+            }
+            else {
+                throw new Error('decryption function is not provided');
+            }
+        }
+        __classPrivateFieldSet(this, _BLSKey_key, keyData, "f");
+        __classPrivateFieldSet(this, _BLSKey_publicKey, bls.getPublicKey(this.sk()).toBytes(), "f");
+    }
+    sk() {
+        return new Uint8Array(__classPrivateFieldGet(this, _BLSKey_key, "f")).reverse();
+    }
+    signDst(message, dst) {
+        const point = bls.hash(message, dst);
+        const sig = bls.sign(point, this.sk()).toBytes();
+        return {
+            rawSignature: sig,
+            sig: (0, utils_1.b58Encode)(sig, utils_1.PrefixV2.GenericSignature),
+            prefixSig: (0, utils_1.b58Encode)(sig, utils_1.PrefixV2.BLS12_381Signature),
+        };
+    }
+    sign(message) {
+        return this.signDst(message, utils_1.BLS12_381_DST);
+    }
+    provePossession() {
+        return this.signDst(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), utils_1.POP_DST);
+    }
+    publicKey() {
+        return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
+    }
+    secretKey() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils_1.PrefixV2.BLS12_381SecretKey);
+    }
+}
+exports.BLSKey = BLSKey;
+_BLSKey_key = new WeakMap(), _BLSKey_publicKey = new WeakMap();
+class BLSPublicKey {
+    constructor(src) {
+        _BLSPublicKey_key.set(this, void 0);
+        if (typeof src === 'string') {
+            const [key, _] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [utils_1.PrefixV2.BLS12_381PublicKey]);
+            __classPrivateFieldSet(this, _BLSPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _BLSPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof BLSPublicKey) {
+            return (0, utils_1.compareArrays)(this.bytes(), other.bytes());
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('BLS key expected');
+        }
+    }
+    hash() {
+        return (0, utils_1.b58Encode)((0, blake2_js_1.blake2b)(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), { dkLen: 20 }), utils_1.PrefixV2.BLS12_381PublicKeyHash);
+    }
+    bytes() {
+        return __classPrivateFieldGet(this, _BLSPublicKey_key, "f");
+    }
+    toProtocol() {
+        const res = new Uint8Array(__classPrivateFieldGet(this, _BLSPublicKey_key, "f").length + 1);
+        res[0] = 3;
+        res.set(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 1);
+        return res;
+    }
+    toString() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), utils_1.PrefixV2.BLS12_381PublicKey);
+    }
+}
+exports.BLSPublicKey = BLSPublicKey;
+_BLSPublicKey_key = new WeakMap();

package/dist/lib/taquito-signer/src/derivation-tools/ecdsa.js

@@ -0,0 +1,156 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKey = void 0;
+/* eslint-disable @typescript-eslint/no-this-alias */
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const nist_1 = require("@noble/curves/nist");
+const types_1 = require("./types");
+const hmac_js_1 = require("@noble/hashes/hmac.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const utils_1 = require("./utils");
+const errors_1 = require("../errors");
+const core_1 = require("@taquito/core");
+const seedKey = {
+    p256: 'Nist256p1 seed',
+    secp256k1: 'Bitcoin seed',
+};
+// MinSeedSize is the minimal allowed seed byte length
+const minSeedSize = 16;
+// MaxSeedSize is the maximal allowed seed byte length
+const maxSeedSize = 64;
+class PrivateKey {
+    /**
+     *
+     * @param priv { secretKey: BN, curve: 'p256' | 'secp256k1' }
+     * @param chainCode slice 32->n HMAC hash key and seedkey (first instance curve default seedKey. after hmac value slice 32->n)
+     */
+    constructor(priv, chainCode) {
+        this.priv = priv;
+        this.chainCode = chainCode;
+        const privateKeyBytes = priv.secretKey.toArray('be', 32);
+        const privateKeyUint8 = new Uint8Array(privateKeyBytes);
+        const publicKey = priv.curve === 'secp256k1'
+            ? secp256k1_1.secp256k1.getPublicKey(privateKeyUint8, true) // compressed public key
+            : nist_1.p256.getPublicKey(privateKeyUint8, true); // compressed public key
+        this.keyPair = {
+            curve: priv.curve,
+            secretKey: priv.secretKey,
+            publicKey: publicKey,
+        };
+    }
+    /**
+     * @param seedSrc result of Bip39.mnemonicToSeed
+     * @param curve known supported curve p256 or secp256k1
+     * @returns instance of PrivateKey non-HD keys derived
+     * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
+     */
+    static fromSeed(seedSrc, curve) {
+        let seed = typeof seedSrc === 'string' ? (0, utils_1.parseHex)(seedSrc) : seedSrc;
+        if (seed.length < minSeedSize || seed.length > maxSeedSize) {
+            throw new errors_1.InvalidSeedLengthError(seed.length);
+        }
+        if (!Object.prototype.hasOwnProperty.call(seedKey, curve)) {
+            throw new errors_1.InvalidCurveError(`Unsupported curve "${curve}" expecting either "p256" or "secp256k1"`);
+        }
+        // Get curve order for validation
+        let curveOrder;
+        if (curve === 'secp256k1') {
+            curveOrder = new bn_js_1.default(secp256k1_1.secp256k1.Point.CURVE().n.toString());
+        }
+        else {
+            curveOrder = new bn_js_1.default(nist_1.p256.Point.CURVE().n.toString());
+        }
+        if (curveOrder.bitLength() !== 256) {
+            throw new errors_1.InvalidBitSize(`Invalid curve "${curve}" with bit size "${curveOrder.bitLength()}" expecting bit size "256"`);
+        }
+        const key = new TextEncoder().encode(seedKey[curve]);
+        let d = null;
+        let chain = new Uint8Array();
+        let i = 0;
+        while (i === 0) {
+            const sum = (0, hmac_js_1.hmac)(sha2_js_1.sha512, key, seed);
+            d = new bn_js_1.default(sum.subarray(0, 32));
+            chain = sum.subarray(32);
+            if (d.isZero() || d.cmp(curveOrder) >= 0) {
+                seed = sum;
+            }
+            else {
+                i++;
+            }
+        }
+        return new PrivateKey({ curve, secretKey: d }, chain);
+    }
+    /**
+     *
+     * @param index derivation path item pre-hardened if applicable ie: 44' -> 2^31 + 44
+     * @returns child PrivateKey of the current PrivateKey
+     */
+    derive(index) {
+        const data = new Uint8Array(37);
+        if ((index & types_1.Hard) !== 0) {
+            // hardened derivation
+            data.set(this.keyPair.secretKey.toArray(), 1);
+        }
+        else {
+            data.set(this.keyPair.publicKey, 0);
+        }
+        new DataView(data.buffer).setUint32(33, index);
+        let d = new bn_js_1.default(0);
+        let chain = new Uint8Array();
+        let i = 0;
+        while (i === 0) {
+            const sum = (0, hmac_js_1.hmac)(sha2_js_1.sha512, this.chainCode, data);
+            d = new bn_js_1.default(sum.subarray(0, 32));
+            chain = sum.subarray(32);
+            // Get curve order for comparison
+            let curveOrder;
+            if (this.keyPair.curve === 'secp256k1') {
+                curveOrder = new bn_js_1.default(secp256k1_1.secp256k1.Point.CURVE().n.toString());
+            }
+            else {
+                curveOrder = new bn_js_1.default(nist_1.p256.Point.CURVE().n.toString());
+            }
+            if (d.cmp(curveOrder) < 0) {
+                d = d.add(this.keyPair.secretKey).mod(curveOrder);
+                if (!d.isZero()) {
+                    i++;
+                }
+            }
+            data.set(chain, 1);
+            data[0] = 1;
+        }
+        return new PrivateKey({ curve: this.keyPair.curve, secretKey: d }, chain);
+    }
+    /**
+     *
+     * @param path pre-hardened (if applicable) derivation path items ie 44'/1729'/0/0 -> 2^31 + 44/2^31 + 1729/0/0
+     * @returns final child of the full HD keys derivation
+     */
+    derivePath(path) {
+        let key = this;
+        for (const x of path) {
+            key = key.derive(x);
+        }
+        return key;
+    }
+    /**
+     *
+     * @returns Uint8Array (if contains a private key)
+     * @throws InvalidKeyError
+     */
+    bytes() {
+        if (!this.keyPair.secretKey) {
+            throw new core_1.InvalidKeyError('missing private key');
+        }
+        // pad to 32 bytes as toArray() length argument seems to be ignored (BN bug)
+        const src = this.keyPair.secretKey.toArray();
+        const out = new Uint8Array(32);
+        out.set(src, out.length - src.length);
+        return out;
+    }
+}
+exports.PrivateKey = PrivateKey;

package/dist/lib/taquito-signer/src/derivation-tools/ed25519.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKey = void 0;
+/* eslint-disable @typescript-eslint/no-this-alias */
+const hmac_js_1 = require("@noble/hashes/hmac.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const ed25519_1 = require("@noble/curves/ed25519");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+const errors_1 = require("../errors");
+const core_1 = require("@taquito/core");
+function generateKeyPairFromSeed(seed) {
+    const publicKey = ed25519_1.ed25519.getPublicKey(seed);
+    const secretKey = new Uint8Array(64);
+    secretKey.set(seed);
+    secretKey.set(publicKey, 32);
+    return { secretKey, publicKey };
+}
+// MinSeedSize is the minimal allowed seed byte length
+const minSeedSize = 16;
+// MaxSeedSize is the maximal allowed seed byte length
+const maxSeedSize = 64;
+const ed25519Key = 'ed25519 seed';
+class PrivateKey {
+    /**
+     *
+     * @param priv generated keypair 0->32 private key 32->n public key
+     * @param chainCode new HMAC hash with new key
+     */
+    constructor(priv, chainCode) {
+        this.priv = priv;
+        this.chainCode = chainCode;
+    }
+    /**
+     *
+     * @param seedSrc result of Bip39.mnemonicToSeed
+     * @returns instance of PrivateKey
+     * @throws InvalidSeedLengthError
+     */
+    static fromSeed(seedSrc) {
+        const seed = typeof seedSrc === 'string' ? (0, utils_1.parseHex)(seedSrc) : seedSrc;
+        if (seed.length < minSeedSize || seed.length > maxSeedSize) {
+            throw new errors_1.InvalidSeedLengthError(seed.length);
+        }
+        const key = new TextEncoder().encode(ed25519Key);
+        const sum = (0, hmac_js_1.hmac)(sha2_js_1.sha512, key, seed);
+        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
+    }
+    /**
+     *
+     * @returns slice(0, 32) of current priv for new seed for next derived priv
+     */
+    seed() {
+        return this.priv.subarray(0, 32);
+    }
+    /**
+     \* @remarks index: current derivation path item ie: 1729'
+     * @returns derivation path child of original private key pair
+     */
+    derive(index) {
+        if ((index & types_1.Hard) === 0) {
+            throw new core_1.InvalidDerivationPathError(index.toString(), ': Non-hardened derivation path.');
+        }
+        const data = new Uint8Array(37);
+        data.set(this.seed(), 1);
+        new DataView(data.buffer).setUint32(33, index);
+        const sum = (0, hmac_js_1.hmac)(sha2_js_1.sha512, this.chainCode, data);
+        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
+    }
+    /**
+     * @param path array of numbers pre adjusted for hardened paths ie: 44' -> 2^31 + 44
+     * @returns final child of full derivation path private key pair
+     */
+    derivePath(path) {
+        let key = this;
+        for (const index of path) {
+            key = key.derive(index);
+        }
+        return key;
+    }
+}
+exports.PrivateKey = PrivateKey;

package/dist/lib/taquito-signer/src/derivation-tools/index.js

@@ -0,0 +1,79 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Path = exports.Ed25519 = exports.ECDSA = void 0;
+const core_1 = require("@taquito/core");
+const types_1 = require("./types");
+exports.ECDSA = __importStar(require("./ecdsa"));
+exports.Ed25519 = __importStar(require("./ed25519"));
+__exportStar(require("./types"), exports);
+class Path extends Array {
+    static from(iterable) {
+        return super.from(iterable).map((x) => x >>> 0);
+    }
+    /**
+     *
+     * @param s derivation path eg: 44'/1729'/0'/0'
+     * @returns applied hardened values
+     */
+    static fromString(s) {
+        if (s.length === 0) {
+            return new Path();
+        }
+        let parts = s.split('/');
+        const out = [];
+        if (parts[0] === 'm') {
+            parts = parts.slice(1);
+        }
+        for (let p of parts) {
+            if (p.length === 0) {
+                throw new core_1.InvalidDerivationPathError(s, `: Invalid BIP32 path`);
+            }
+            let h = 0;
+            const last = p[p.length - 1];
+            if (last === "'" || last === 'h' || last === 'H') {
+                h = types_1.Hard;
+                p = p.slice(0, p.length - 1);
+            }
+            const index = (parseInt(p, 10) | h) >>> 0;
+            out.push(index);
+        }
+        return Path.from(out);
+    }
+}
+exports.Path = Path;

package/dist/lib/taquito-signer/src/derivation-tools/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hard = void 0;
+exports.Hard = 0x80000000;

package/dist/lib/taquito-signer/src/derivation-tools/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHex = parseHex;
+const core_1 = require("@taquito/core");
+function parseHex(s) {
+    const res = [];
+    for (let i = 0; i < s.length; i += 2) {
+        const ss = s.slice(i, i + 2);
+        const x = parseInt(ss, 16);
+        if (Number.isNaN(x)) {
+            throw new core_1.InvalidHexStringError(ss);
+        }
+        res.push(x);
+    }
+    return new Uint8Array(res);
+}