@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/libs/modules/key-derivation/networks/sui/sui-key-derivation.js

@@ -0,0 +1,872 @@
+import { t as toHex, b as bech32, S as SIGNATURE_FLAG_TO_SCHEME, a as SIGNATURE_SCHEME_TO_FLAG, c as blake2b, m as messageWithIntent, d as toBase64, e as toSerializedSignature, f as bcs, g as fromHex, E as Ed25519PublicKey, h as createBase58check, i as Secp256k1PublicKey, j as Secp256r1PublicKey } from '../../../../../publickey-DsLd2AKA.js';
+import { p as pbkdf2 } from '../../../../../pbkdf2-CASYB-8e.js';
+import { a as sha512, s as sha256 } from '../../../../../sha2-OXpLEvj4.js';
+import { h as hmac } from '../../../../../hmac-uNq7SSgZ.js';
+import { e as ed25519 } from '../../../../../ed25519-BcS7UiUJ.js';
+import { p as p256 } from '../../../../../nist-Cie-30E0.js';
+import { s as secp256k1 } from '../../../../../secp256k1-FNoOZ2h8.js';
+import { r as ripemd160 } from '../../../../../legacy-CeOtyvCs.js';
+import { c as concatBytes, g as abytes, a as createView } from '../../../../../utils-BDj4oeIm.js';
+import { KeyDerivationError } from '../../libs/exceptions/key-derivation-error.exception.js';
+import { ExceptionMessage } from '../../../../enums/exception-message.enum.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+// Normalization replaces equivalent sequences of characters
+// so that any two texts that are equivalent will be reduced
+// to the same sequence of code points, called the normal form of the original text.
+// https://tonsky.me/blog/unicode/#why-is-a----
+function nfkd(str) {
+    if (typeof str !== 'string')
+        throw new TypeError('invalid mnemonic type: ' + typeof str);
+    return str.normalize('NFKD');
+}
+function normalize(str) {
+    const norm = nfkd(str);
+    const words = norm.split(' ');
+    if (![12, 15, 18, 21, 24].includes(words.length))
+        throw new Error('Invalid mnemonic');
+    return { nfkd: norm, words };
+}
+const psalt = (passphrase) => nfkd('mnemonic' + passphrase);
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+function mnemonicToSeedSync(mnemonic, passphrase = '') {
+    return pbkdf2(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });
+}
+
+//#region src/cryptography/mnemonics.ts
+/**
+* Parse and validate a path that is compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+*
+* @param path path string (e.g. `m/44'/784'/0'/0'/0'`).
+*/
+function isValidHardenedPath(path) {
+	if (!(/* @__PURE__ */ new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$")).test(path)) return false;
+	return true;
+}
+/**
+* Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
+* for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
+*
+* Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
+*
+* @param path path string (e.g. `m/54'/784'/0'/0/0`).
+*/
+function isValidBIP32Path(path) {
+	if (!(/* @__PURE__ */ new RegExp("^m\\/(54|74)'\\/784'\\/[0-9]+'\\/[0-9]+\\/[0-9]+$")).test(path)) return false;
+	return true;
+}
+/**
+* Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
+*
+* @param mnemonics 12 words string split by spaces.
+*/
+function mnemonicToSeed(mnemonics) {
+	return mnemonicToSeedSync(mnemonics, "");
+}
+/**
+* Derive the seed in hex format from a 12-word mnemonic string.
+*
+* @param mnemonics 12 words string split by spaces.
+*/
+function mnemonicToSeedHex(mnemonics) {
+	return toHex(mnemonicToSeed(mnemonics));
+}
+
+//#region src/cryptography/keypair.ts
+const PRIVATE_KEY_SIZE = 32;
+const SUI_PRIVATE_KEY_PREFIX = "suiprivkey";
+/**
+* TODO: Document
+*/
+var Signer = class {
+	/**
+	* Sign messages with a specific intent. By combining the message bytes with the intent before hashing and signing,
+	* it ensures that a signed message is tied to a specific purpose and domain separator is provided
+	*/
+	async signWithIntent(bytes, intent) {
+		const digest = blake2b(messageWithIntent(intent, bytes), { dkLen: 32 });
+		return {
+			signature: toSerializedSignature({
+				signature: await this.sign(digest),
+				signatureScheme: this.getKeyScheme(),
+				publicKey: this.getPublicKey()
+			}),
+			bytes: toBase64(bytes)
+		};
+	}
+	/**
+	* Signs provided transaction by calling `signWithIntent()` with a `TransactionData` provided as intent scope
+	*/
+	async signTransaction(bytes) {
+		return this.signWithIntent(bytes, "TransactionData");
+	}
+	/**
+	* Signs provided personal message by calling `signWithIntent()` with a `PersonalMessage` provided as intent scope
+	*/
+	async signPersonalMessage(bytes) {
+		const { signature } = await this.signWithIntent(bcs.byteVector().serialize(bytes).toBytes(), "PersonalMessage");
+		return {
+			bytes: toBase64(bytes),
+			signature
+		};
+	}
+	async signAndExecuteTransaction({ transaction, client }) {
+		transaction.setSenderIfNotSet(this.toSuiAddress());
+		const bytes = await transaction.build({ client });
+		const { signature } = await this.signTransaction(bytes);
+		return client.core.executeTransaction({
+			transaction: bytes,
+			signatures: [signature],
+			include: {
+				transaction: true,
+				effects: true
+			}
+		});
+	}
+	toSuiAddress() {
+		return this.getPublicKey().toSuiAddress();
+	}
+};
+var Keypair = class extends Signer {};
+/**
+* This returns an ParsedKeypair object based by validating the
+* 33-byte Bech32 encoded string starting with `suiprivkey`, and
+* parse out the signature scheme and the private key in bytes.
+*/
+function decodeSuiPrivateKey(value) {
+	const { prefix, words } = bech32.decode(value);
+	if (prefix !== SUI_PRIVATE_KEY_PREFIX) throw new Error("invalid private key prefix");
+	const extendedSecretKey = new Uint8Array(bech32.fromWords(words));
+	const secretKey = extendedSecretKey.slice(1);
+	return {
+		scheme: SIGNATURE_FLAG_TO_SCHEME[extendedSecretKey[0]],
+		secretKey
+	};
+}
+/**
+* This returns a Bech32 encoded string starting with `suiprivkey`,
+* encoding 33-byte `flag || bytes` for the given the 32-byte private
+* key and its signature scheme.
+*/
+function encodeSuiPrivateKey(bytes, scheme) {
+	if (bytes.length !== PRIVATE_KEY_SIZE) throw new Error("Invalid bytes length");
+	const flag = SIGNATURE_SCHEME_TO_FLAG[scheme];
+	const privKeyBytes = new Uint8Array(bytes.length + 1);
+	privKeyBytes.set([flag]);
+	privKeyBytes.set(bytes, 1);
+	return bech32.encode(SUI_PRIVATE_KEY_PREFIX, bech32.toWords(privKeyBytes));
+}
+
+//#region src/keypairs/ed25519/ed25519-hd-key.ts
+const ED25519_CURVE = "ed25519 seed";
+const HARDENED_OFFSET$1 = 2147483648;
+const pathRegex = /* @__PURE__ */ new RegExp("^m(\\/[0-9]+')+$");
+const replaceDerive = (val) => val.replace("'", "");
+const getMasterKeyFromSeed = (seed) => {
+	const I = hmac.create(sha512, new TextEncoder().encode(ED25519_CURVE)).update(fromHex(seed)).digest();
+	return {
+		key: I.slice(0, 32),
+		chainCode: I.slice(32)
+	};
+};
+const CKDPriv = ({ key, chainCode }, index) => {
+	const indexBuffer = /* @__PURE__ */ new ArrayBuffer(4);
+	new DataView(indexBuffer).setUint32(0, index);
+	const data = new Uint8Array(1 + key.length + indexBuffer.byteLength);
+	data.set(new Uint8Array(1).fill(0));
+	data.set(key, 1);
+	data.set(new Uint8Array(indexBuffer, 0, indexBuffer.byteLength), key.length + 1);
+	const I = hmac.create(sha512, chainCode).update(data).digest();
+	return {
+		key: I.slice(0, 32),
+		chainCode: I.slice(32)
+	};
+};
+const isValidPath = (path) => {
+	if (!pathRegex.test(path)) return false;
+	return !path.split("/").slice(1).map(replaceDerive).some(isNaN);
+};
+const derivePath = (path, seed, offset = HARDENED_OFFSET$1) => {
+	if (!isValidPath(path)) throw new Error("Invalid derivation path");
+	const { key, chainCode } = getMasterKeyFromSeed(seed);
+	return path.split("/").slice(1).map(replaceDerive).map((el) => parseInt(el, 10)).reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
+		key,
+		chainCode
+	});
+};
+
+//#region src/keypairs/ed25519/keypair.ts
+const DEFAULT_ED25519_DERIVATION_PATH = "m/44'/784'/0'/0'/0'";
+/**
+* An Ed25519 Keypair used for signing transactions.
+*/
+var Ed25519Keypair = class Ed25519Keypair extends Keypair {
+	/**
+	* Create a new Ed25519 keypair instance.
+	* Generate random keypair if no {@link Ed25519Keypair} is provided.
+	*
+	* @param keypair Ed25519 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = {
+			publicKey: keypair.publicKey,
+			secretKey: keypair.secretKey.slice(0, 32)
+		};
+		else {
+			const privateKey = ed25519.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: ed25519.getPublicKey(privateKey),
+				secretKey: privateKey
+			};
+		}
+	}
+	/**
+	* Get the key scheme of the keypair ED25519
+	*/
+	getKeyScheme() {
+		return "ED25519";
+	}
+	/**
+	* Generate a new random Ed25519 keypair
+	*/
+	static generate() {
+		const secretKey = ed25519.utils.randomSecretKey();
+		return new Ed25519Keypair({
+			publicKey: ed25519.getPublicKey(secretKey),
+			secretKey
+		});
+	}
+	/**
+	* Create a Ed25519 keypair from a raw secret key byte array, also known as seed.
+	* This is NOT the private scalar which is result of hashing and bit clamping of
+	* the raw secret key.
+	*
+	* @throws error if the provided secret key is invalid and validation is not skipped.
+	*
+	* @param secretKey secret key as a byte array or Bech32 secret key string
+	* @param options: skip secret key validation
+	*/
+	static fromSecretKey(secretKey, options) {
+		if (typeof secretKey === "string") {
+			const decoded = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "ED25519") throw new Error(`Expected a ED25519 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const secretKeyLength = secretKey.length;
+		if (secretKeyLength !== PRIVATE_KEY_SIZE) throw new Error(`Wrong secretKey size. Expected ${PRIVATE_KEY_SIZE} bytes, got ${secretKeyLength}.`);
+		const keypair = {
+			publicKey: ed25519.getPublicKey(secretKey),
+			secretKey
+		};
+		if (!options || !options.skipValidation) {
+			const signData = new TextEncoder().encode("sui validation");
+			const signature = ed25519.sign(signData, secretKey);
+			if (!ed25519.verify(signature, signData, keypair.publicKey)) throw new Error("provided secretKey is invalid");
+		}
+		return new Ed25519Keypair(keypair);
+	}
+	/**
+	* The public key for this Ed25519 keypair
+	*/
+	getPublicKey() {
+		return new Ed25519PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Ed25519 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey.slice(0, PRIVATE_KEY_SIZE), this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data using Ed25519.
+	*/
+	async sign(data) {
+		return ed25519.sign(data, this.keypair.secretKey);
+	}
+	/**
+	* Derive Ed25519 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+	* be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_ED25519_DERIVATION_PATH;
+		if (!isValidHardenedPath(path)) throw new Error("Invalid derivation path");
+		const { key } = derivePath(path, mnemonicToSeedHex(mnemonics));
+		return Ed25519Keypair.fromSecretKey(key);
+	}
+	/**
+	* Derive Ed25519 keypair from mnemonicSeed and path.
+	*
+	* If path is none, it will default to m/44'/784'/0'/0'/0', otherwise the path must
+	* be compliant to SLIP-0010 in form m/44'/784'/{account_index}'/{change_index}'/{address_index}'.
+	*/
+	static deriveKeypairFromSeed(seedHex, path) {
+		if (path == null) path = DEFAULT_ED25519_DERIVATION_PATH;
+		if (!isValidHardenedPath(path)) throw new Error("Invalid derivation path");
+		const { key } = derivePath(path, seedHex);
+		return Ed25519Keypair.fromSecretKey(key);
+	}
+};
+
+/**
+ * BIP32 hierarchical deterministic (HD) wallets over secp256k1.
+ * @module
+ * @example
+ * ```js
+ * import { HDKey } from "@scure/bip32";
+ * const hdkey1 = HDKey.fromMasterSeed(seed);
+ * const hdkey2 = HDKey.fromExtendedKey(base58key);
+ * const hdkey3 = HDKey.fromJSON({ xpriv: string });
+ *
+ * // props
+ * [hdkey1.depth, hdkey1.index, hdkey1.chainCode];
+ * console.log(hdkey2.privateKey, hdkey2.publicKey);
+ * console.log(hdkey3.derive("m/0/2147483647'/1"));
+ * const sig = hdkey3.sign(hash);
+ * hdkey3.verify(hash, sig);
+ * ```
+ */
+/*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+const Point = secp256k1.Point;
+const { Fn } = Point;
+const base58check = createBase58check(sha256);
+const MASTER_SECRET = Uint8Array.from('Bitcoin seed'.split(''), (char) => char.charCodeAt(0));
+const BITCOIN_VERSIONS = { private: 0x0488ade4, public: 0x0488b21e };
+/** Hardened offset from Bitcoin, default */
+const HARDENED_OFFSET = 0x80000000;
+const hash160 = (data) => ripemd160(sha256(data));
+const fromU32 = (data) => createView(data).getUint32(0, false);
+const toU32 = (n) => {
+    if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
+        throw new Error('invalid number, should be from 0 to 2**32-1, got ' + n);
+    }
+    const buf = new Uint8Array(4);
+    createView(buf).setUint32(0, n, false);
+    return buf;
+};
+/**
+ * HDKey from BIP32
+ * @example
+```js
+const hdkey1 = HDKey.fromMasterSeed(seed);
+const hdkey2 = HDKey.fromExtendedKey(base58key);
+const hdkey3 = HDKey.fromJSON({ xpriv: string });
+```
+ */
+class HDKey {
+    get fingerprint() {
+        if (!this.pubHash) {
+            throw new Error('No publicKey set!');
+        }
+        return fromU32(this.pubHash);
+    }
+    get identifier() {
+        return this.pubHash;
+    }
+    get pubKeyHash() {
+        return this.pubHash;
+    }
+    get privateKey() {
+        return this._privateKey || null;
+    }
+    get publicKey() {
+        return this._publicKey || null;
+    }
+    get privateExtendedKey() {
+        const priv = this._privateKey;
+        if (!priv) {
+            throw new Error('No private key');
+        }
+        return base58check.encode(this.serialize(this.versions.private, concatBytes(Uint8Array.of(0), priv)));
+    }
+    get publicExtendedKey() {
+        if (!this._publicKey) {
+            throw new Error('No public key');
+        }
+        return base58check.encode(this.serialize(this.versions.public, this._publicKey));
+    }
+    static fromMasterSeed(seed, versions = BITCOIN_VERSIONS) {
+        abytes(seed);
+        if (8 * seed.length < 128 || 8 * seed.length > 512) {
+            throw new Error('HDKey: seed length must be between 128 and 512 bits; 256 bits is advised, got ' +
+                seed.length);
+        }
+        const I = hmac(sha512, MASTER_SECRET, seed);
+        const privateKey = I.slice(0, 32);
+        const chainCode = I.slice(32);
+        return new HDKey({ versions, chainCode, privateKey });
+    }
+    static fromExtendedKey(base58key, versions = BITCOIN_VERSIONS) {
+        // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        const keyBuffer = base58check.decode(base58key);
+        const keyView = createView(keyBuffer);
+        const version = keyView.getUint32(0, false);
+        const opt = {
+            versions,
+            depth: keyBuffer[4],
+            parentFingerprint: keyView.getUint32(5, false),
+            index: keyView.getUint32(9, false),
+            chainCode: keyBuffer.slice(13, 45),
+        };
+        const key = keyBuffer.slice(45);
+        const isPriv = key[0] === 0;
+        if (version !== versions[isPriv ? 'private' : 'public']) {
+            throw new Error('Version mismatch');
+        }
+        if (isPriv) {
+            return new HDKey({ ...opt, privateKey: key.slice(1) });
+        }
+        else {
+            return new HDKey({ ...opt, publicKey: key });
+        }
+    }
+    static fromJSON(json) {
+        return HDKey.fromExtendedKey(json.xpriv);
+    }
+    versions;
+    depth = 0;
+    index = 0;
+    chainCode = null;
+    parentFingerprint = 0;
+    _privateKey;
+    _publicKey;
+    pubHash;
+    constructor(opt) {
+        if (!opt || typeof opt !== 'object') {
+            throw new Error('HDKey.constructor must not be called directly');
+        }
+        this.versions = opt.versions || BITCOIN_VERSIONS;
+        this.depth = opt.depth || 0;
+        this.chainCode = opt.chainCode || null;
+        this.index = opt.index || 0;
+        this.parentFingerprint = opt.parentFingerprint || 0;
+        if (!this.depth) {
+            if (this.parentFingerprint || this.index) {
+                throw new Error('HDKey: zero depth with non-zero index/parent fingerprint');
+            }
+        }
+        if (this.depth > 255) {
+            throw new Error('HDKey: depth exceeds the serializable value 255');
+        }
+        if (opt.publicKey && opt.privateKey) {
+            throw new Error('HDKey: publicKey and privateKey at same time.');
+        }
+        if (opt.privateKey) {
+            if (!secp256k1.utils.isValidSecretKey(opt.privateKey))
+                throw new Error('Invalid private key');
+            this._privateKey = opt.privateKey;
+            this._publicKey = secp256k1.getPublicKey(opt.privateKey, true);
+        }
+        else if (opt.publicKey) {
+            this._publicKey = Point.fromBytes(opt.publicKey).toBytes(true); // force compressed point
+        }
+        else {
+            throw new Error('HDKey: no public or private key provided');
+        }
+        this.pubHash = hash160(this._publicKey);
+    }
+    derive(path) {
+        if (!/^[mM]'?/.test(path)) {
+            throw new Error('Path must start with "m" or "M"');
+        }
+        if (/^[mM]'?$/.test(path)) {
+            return this;
+        }
+        const parts = path.replace(/^[mM]'?\//, '').split('/');
+        // tslint:disable-next-line
+        let child = this;
+        for (const c of parts) {
+            const m = /^(\d+)('?)$/.exec(c);
+            const m1 = m && m[1];
+            if (!m || m.length !== 3 || typeof m1 !== 'string')
+                throw new Error('invalid child index: ' + c);
+            let idx = +m1;
+            if (!Number.isSafeInteger(idx) || idx >= HARDENED_OFFSET) {
+                throw new Error('Invalid index');
+            }
+            // hardened key
+            if (m[2] === "'") {
+                idx += HARDENED_OFFSET;
+            }
+            child = child.deriveChild(idx);
+        }
+        return child;
+    }
+    deriveChild(index) {
+        if (!this._publicKey || !this.chainCode) {
+            throw new Error('No publicKey or chainCode set');
+        }
+        let data = toU32(index);
+        if (index >= HARDENED_OFFSET) {
+            // Hardened
+            const priv = this._privateKey;
+            if (!priv) {
+                throw new Error('Could not derive hardened child key');
+            }
+            // Hardened child: 0x00 || ser256(kpar) || ser32(index)
+            data = concatBytes(Uint8Array.of(0), priv, data);
+        }
+        else {
+            // Normal child: serP(point(kpar)) || ser32(index)
+            data = concatBytes(this._publicKey, data);
+        }
+        const I = hmac(sha512, this.chainCode, data);
+        const childTweak = I.slice(0, 32);
+        const chainCode = I.slice(32);
+        if (!secp256k1.utils.isValidSecretKey(childTweak)) {
+            throw new Error('Tweak bigger than curve order');
+        }
+        const opt = {
+            versions: this.versions,
+            chainCode,
+            depth: this.depth + 1,
+            parentFingerprint: this.fingerprint,
+            index,
+        };
+        const ctweak = Fn.fromBytes(childTweak);
+        try {
+            // Private parent key -> private child key
+            if (this._privateKey) {
+                const added = Fn.create(Fn.fromBytes(this._privateKey) + ctweak);
+                if (!Fn.isValidNot0(added)) {
+                    throw new Error('The tweak was out of range or the resulted private key is invalid');
+                }
+                opt.privateKey = Fn.toBytes(added);
+            }
+            else {
+                const added = Point.fromBytes(this._publicKey).add(Point.BASE.multiply(ctweak));
+                // Cryptographically impossible: hmac-sha512 preimage would need to be found
+                if (added.equals(Point.ZERO)) {
+                    throw new Error('The tweak was equal to negative P, which made the result key invalid');
+                }
+                opt.publicKey = added.toBytes(true);
+            }
+            return new HDKey(opt);
+        }
+        catch (err) {
+            return this.deriveChild(index + 1);
+        }
+    }
+    sign(hash) {
+        if (!this._privateKey) {
+            throw new Error('No privateKey set!');
+        }
+        abytes(hash, 32);
+        return secp256k1.sign(hash, this._privateKey, { prehash: false });
+    }
+    verify(hash, signature) {
+        abytes(hash, 32);
+        abytes(signature, 64);
+        if (!this._publicKey) {
+            throw new Error('No publicKey set!');
+        }
+        return secp256k1.verify(signature, hash, this._publicKey, { prehash: false });
+    }
+    wipePrivateData() {
+        if (this._privateKey) {
+            this._privateKey.fill(0);
+            this._privateKey = undefined;
+        }
+        return this;
+    }
+    toJSON() {
+        return {
+            xpriv: this.privateExtendedKey,
+            xpub: this.publicExtendedKey,
+        };
+    }
+    serialize(version, key) {
+        if (!this.chainCode) {
+            throw new Error('No chainCode set');
+        }
+        abytes(key, 33);
+        // version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+        return concatBytes(toU32(version), new Uint8Array([this.depth]), toU32(this.parentFingerprint), toU32(this.index), this.chainCode, key);
+    }
+}
+
+//#region src/keypairs/secp256k1/keypair.ts
+const DEFAULT_SECP256K1_DERIVATION_PATH = "m/54'/784'/0'/0/0";
+/**
+* An Secp256k1 Keypair used for signing transactions.
+*/
+var Secp256k1Keypair = class Secp256k1Keypair extends Keypair {
+	/**
+	* Create a new keypair instance.
+	* Generate random keypair if no {@link Secp256k1Keypair} is provided.
+	*
+	* @param keypair secp256k1 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = keypair;
+		else {
+			const secretKey = secp256k1.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: secp256k1.getPublicKey(secretKey, true),
+				secretKey
+			};
+		}
+	}
+	/**
+	* Get the key scheme of the keypair Secp256k1
+	*/
+	getKeyScheme() {
+		return "Secp256k1";
+	}
+	/**
+	* Generate a new random keypair
+	*/
+	static generate() {
+		return new Secp256k1Keypair();
+	}
+	/**
+	* Create a keypair from a raw secret key byte array.
+	*
+	* This method should only be used to recreate a keypair from a previously
+	* generated secret key. Generating keypairs from a random seed should be done
+	* with the {@link Keypair.fromSeed} method.
+	*
+	* @throws error if the provided secret key is invalid and validation is not skipped.
+	*
+	* @param secretKey secret key byte array  or Bech32 secret key string
+	* @param options: skip secret key validation
+	*/
+	static fromSecretKey(secretKey, options) {
+		if (typeof secretKey === "string") {
+			const decoded = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "Secp256k1") throw new Error(`Expected a Secp256k1 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const publicKey = secp256k1.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const msgHash = blake2b(new TextEncoder().encode("sui validation"), { dkLen: 32 });
+			const signature = secp256k1.sign(msgHash, secretKey, { prehash: false });
+			if (!secp256k1.verify(signature, msgHash, publicKey, {
+				lowS: true,
+				prehash: false
+			})) throw new Error("Provided secretKey is invalid");
+		}
+		return new Secp256k1Keypair({
+			publicKey,
+			secretKey
+		});
+	}
+	/**
+	* Generate a keypair from a 32 byte seed.
+	*
+	* @param seed seed byte array
+	*/
+	static fromSeed(seed) {
+		return new Secp256k1Keypair({
+			publicKey: secp256k1.getPublicKey(seed, true),
+			secretKey: seed
+		});
+	}
+	/**
+	* The public key for this keypair
+	*/
+	getPublicKey() {
+		return new Secp256k1PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Secp256k1 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data.
+	*/
+	async sign(data) {
+		return secp256k1.sign(data, this.keypair.secretKey, { lowS: true });
+	}
+	/**
+	* Derive Secp256k1 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/54'/784'/0'/0/0, otherwise the path must
+	* be compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_SECP256K1_DERIVATION_PATH;
+		if (!isValidBIP32Path(path)) throw new Error("Invalid derivation path");
+		const key = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path);
+		if (key.publicKey == null || key.privateKey == null) throw new Error("Invalid key");
+		return new Secp256k1Keypair({
+			publicKey: key.publicKey,
+			secretKey: key.privateKey
+		});
+	}
+};
+
+//#region src/keypairs/secp256r1/keypair.ts
+const DEFAULT_SECP256R1_DERIVATION_PATH = "m/74'/784'/0'/0/0";
+/**
+* An Secp256r1 Keypair used for signing transactions.
+*/
+var Secp256r1Keypair = class Secp256r1Keypair extends Keypair {
+	/**
+	* Create a new keypair instance.
+	* Generate random keypair if no {@link Secp256r1Keypair} is provided.
+	*
+	* @param keypair Secp256r1 keypair
+	*/
+	constructor(keypair) {
+		super();
+		if (keypair) this.keypair = keypair;
+		else {
+			const secretKey = p256.utils.randomSecretKey();
+			this.keypair = {
+				publicKey: p256.getPublicKey(secretKey, true),
+				secretKey
+			};
+		}
+	}
+	/**
+	* Get the key scheme of the keypair Secp256r1
+	*/
+	getKeyScheme() {
+		return "Secp256r1";
+	}
+	/**
+	* Generate a new random keypair
+	*/
+	static generate() {
+		return new Secp256r1Keypair();
+	}
+	/**
+	* Create a keypair from a raw secret key byte array.
+	*
+	* This method should only be used to recreate a keypair from a previously
+	* generated secret key. Generating keypairs from a random seed should be done
+	* with the {@link Keypair.fromSeed} method.
+	*
+	* @throws error if the provided secret key is invalid and validation is not skipped.
+	*
+	* @param secretKey secret key byte array or Bech32 secret key string
+	* @param options: skip secret key validation
+	*/
+	static fromSecretKey(secretKey, options) {
+		if (typeof secretKey === "string") {
+			const decoded = decodeSuiPrivateKey(secretKey);
+			if (decoded.scheme !== "Secp256r1") throw new Error(`Expected a Secp256r1 keypair, got ${decoded.scheme}`);
+			return this.fromSecretKey(decoded.secretKey, options);
+		}
+		const publicKey = p256.getPublicKey(secretKey, true);
+		if (!options || !options.skipValidation) {
+			const msgHash = blake2b(new TextEncoder().encode("sui validation"), { dkLen: 32 });
+			const signature = p256.sign(msgHash, secretKey, {
+				lowS: true,
+				prehash: false
+			});
+			if (!p256.verify(signature, msgHash, publicKey, {
+				lowS: true,
+				prehash: false
+			})) throw new Error("Provided secretKey is invalid");
+		}
+		return new Secp256r1Keypair({
+			publicKey,
+			secretKey
+		});
+	}
+	/**
+	* Generate a keypair from a 32 byte seed.
+	*
+	* @param seed seed byte array
+	*/
+	static fromSeed(seed) {
+		return new Secp256r1Keypair({
+			publicKey: p256.getPublicKey(seed, true),
+			secretKey: seed
+		});
+	}
+	/**
+	* The public key for this keypair
+	*/
+	getPublicKey() {
+		return new Secp256r1PublicKey(this.keypair.publicKey);
+	}
+	/**
+	* The Bech32 secret key string for this Secp256r1 keypair
+	*/
+	getSecretKey() {
+		return encodeSuiPrivateKey(this.keypair.secretKey, this.getKeyScheme());
+	}
+	/**
+	* Return the signature for the provided data.
+	*/
+	async sign(data) {
+		return p256.sign(data, this.keypair.secretKey, { lowS: true });
+	}
+	/**
+	* Derive Secp256r1 keypair from mnemonics and path. The mnemonics must be normalized
+	* and validated against the english wordlist.
+	*
+	* If path is none, it will default to m/74'/784'/0'/0/0, otherwise the path must
+	* be compliant to BIP-32 in form m/74'/784'/{account_index}'/{change_index}/{address_index}.
+	*/
+	static deriveKeypair(mnemonics, path) {
+		if (path == null) path = DEFAULT_SECP256R1_DERIVATION_PATH;
+		if (!isValidBIP32Path(path)) throw new Error("Invalid derivation path");
+		const privateKey = HDKey.fromMasterSeed(mnemonicToSeed(mnemonics)).derive(path).privateKey;
+		return Secp256r1Keypair.fromSecretKey(privateKey);
+	}
+};
+
+class SuiKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic({
+    derivationPath,
+    scheme
+  }) {
+    const keyPairHandler = this.getKeyPairHandler(scheme);
+    const keyPair = keyPairHandler.deriveKeypair(this.mnemonic.getMnemonic(), derivationPath);
+    const privateKey = keyPair.getSecretKey();
+    const publicKey = this.getPublicKey(keyPair);
+    return { privateKey, publicKey };
+  }
+  importByPrivateKey({
+    privateKey,
+    scheme
+  }) {
+    const keyPairHandler = this.getKeyPairHandler(scheme);
+    const keyPair = keyPairHandler.fromSecretKey(privateKey);
+    const publicKey = this.getPublicKey(keyPair);
+    return { privateKey, publicKey };
+  }
+  getPublicKey(keyPair) {
+    return keyPair.getPublicKey().toSuiPublicKey();
+  }
+  getKeyPairHandler(scheme) {
+    switch (scheme) {
+      case "secp256k1":
+        return Secp256k1Keypair;
+      case "secp256r1":
+        return Secp256r1Keypair;
+      case "ed25519":
+        return Ed25519Keypair;
+      default:
+        throw new KeyDerivationError(ExceptionMessage.INVALID_SCHEME);
+    }
+  }
+}
+
+export { SuiKeyDerivation };