@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/SodiumBip32Ed25519-BaD-kjyx.cjs

@@ -0,0 +1,380 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require_errors = require("./errors-lg3enbYs.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_Ed25519PublicKey = require("./Ed25519PublicKey-B3QcR0J2.cjs");
+const require_pbkdf2$1 = require("./pbkdf2-B1veireP.cjs");
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/arithmetic.js
+const add28Mul8 = (x, y) => {
+	let carry = 0;
+	const out = new Uint8Array(32);
+	for (let i = 0; i < 28; i++) {
+		const r = x[i] + (y[i] << 3) + carry;
+		out[i] = r & 255;
+		carry = r >> 8;
+	}
+	for (let i = 28; i < 32; i++) {
+		const r = x[i] + carry;
+		out[i] = r & 255;
+		carry = r >> 8;
+	}
+	return out;
+};
+const add256bits = (x, y) => {
+	let carry = 0;
+	const out = new Uint8Array(32);
+	for (let i = 0; i < 32; i++) {
+		const r = x[i] + y[i] + carry;
+		out[i] = r;
+		carry = r >> 8;
+	}
+	return out;
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32KeyDerivation.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_libsodium_wrappers = /* @__PURE__ */ require_chunk.__toESM(require_Address.require_libsodium_wrappers(), 1);
+const isHardenedDerivation = (index) => index >= 2147483648;
+const deriveHardened = (index, scalar, iv, chainCode) => {
+	const data = require__polyfill_buffer_patch.import_buffer.Buffer.allocUnsafe(69);
+	data.writeUInt32LE(index, 65);
+	scalar.copy(data, 1);
+	iv.copy(data, 33);
+	data[0] = 0;
+	const zMac = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode);
+	data[0] = 1;
+	return {
+		ccMac: import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode),
+		zMac
+	};
+};
+const deriveSoft = (index, scalar, chainCode) => {
+	const data = require__polyfill_buffer_patch.import_buffer.Buffer.allocUnsafe(37);
+	data.writeUInt32LE(index, 33);
+	require__polyfill_buffer_patch.import_buffer.Buffer.from(import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar)).copy(data, 1);
+	data[0] = 2;
+	const zMac = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode);
+	data[0] = 3;
+	return {
+		ccMac: import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, chainCode),
+		zMac
+	};
+};
+const pointOfTrunc28Mul8 = (sk) => {
+	const scalar = add28Mul8(new Uint8Array(32).fill(0), sk);
+	return import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+};
+const derivePrivate = (key, index) => {
+	const kl = key.subarray(0, 32);
+	const kr = key.subarray(32, 64);
+	const cc = key.subarray(64, 96);
+	const { ccMac, zMac } = isHardenedDerivation(index) ? deriveHardened(index, kl, kr, cc) : deriveSoft(index, kl, cc);
+	const chainCode = ccMac.slice(32, 64);
+	const zl = zMac.slice(0, 32);
+	const zr = zMac.slice(32, 64);
+	const left = add28Mul8(kl, zl);
+	const right = add256bits(kr, zr);
+	return require__polyfill_buffer_patch.import_buffer.Buffer.concat([
+		left,
+		right,
+		chainCode
+	]);
+};
+const derivePublic = (key, index) => {
+	const pk = key.subarray(0, 32);
+	const cc = key.subarray(32, 64);
+	const data = require__polyfill_buffer_patch.import_buffer.Buffer.allocUnsafe(37);
+	data.writeUInt32LE(index, 33);
+	if (isHardenedDerivation(index)) throw new require_errors.InvalidArgumentError("index", "Public key can not be derived from a hardened index.");
+	pk.copy(data, 1);
+	data[0] = 2;
+	const z = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, cc);
+	data[0] = 3;
+	const chainCode = import_libsodium_wrappers.default.crypto_auth_hmacsha512(data, cc).slice(32, 64);
+	const p = pointOfTrunc28Mul8(z.slice(0, 32));
+	return require__polyfill_buffer_patch.import_buffer.Buffer.concat([import_libsodium_wrappers.default.crypto_core_ed25519_add(p, pk), chainCode]);
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Ed25519e/Ed25519Signature.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var __classPrivateFieldSet$3 = 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$3 = 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 _Ed25519Signature_signature;
+var Ed25519Signature = class Ed25519Signature {
+	constructor(signature) {
+		_Ed25519Signature_signature.set(this, void 0);
+		__classPrivateFieldSet$3(this, _Ed25519Signature_signature, signature, "f");
+	}
+	static fromBytes(signature) {
+		if (signature.length !== 64) throw new require_errors.InvalidArgumentError("signature", `signature should be 64 bytes; however ${signature.length} bytes were provided.`);
+		return new Ed25519Signature(signature);
+	}
+	static fromHex(signature) {
+		return Ed25519Signature.fromBytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(signature, "hex"));
+	}
+	bytes() {
+		return __classPrivateFieldGet$3(this, _Ed25519Signature_signature, "f");
+	}
+	hex() {
+		return require_Address.Ed25519SignatureHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet$3(this, _Ed25519Signature_signature, "f")).toString("hex"));
+	}
+};
+_Ed25519Signature_signature = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Ed25519e/Ed25519PrivateKey.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var __classPrivateFieldSet$2 = 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$2 = 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 _Ed25519PrivateKey_keyMaterial;
+const SCALAR_INDEX$1 = 0;
+const SCALAR_SIZE$1 = 32;
+const IV_INDEX = 32;
+const IV_SIZE = 32;
+const extendedScalar$1 = (extendedKey) => extendedKey.slice(SCALAR_INDEX$1, SCALAR_SIZE$1);
+const extendedIv = (extendedKey) => extendedKey.slice(IV_INDEX, IV_INDEX + IV_SIZE);
+const signExtendedDetached = (extendedKey, message) => {
+	const scalar = extendedScalar$1(extendedKey);
+	const publicKey = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+	const nonce = import_libsodium_wrappers.default.crypto_core_ed25519_scalar_reduce(import_libsodium_wrappers.default.crypto_hash_sha512(require__polyfill_buffer_patch.import_buffer.Buffer.concat([extendedIv(extendedKey), message])));
+	const r = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(nonce);
+	let hram = import_libsodium_wrappers.default.crypto_hash_sha512(require__polyfill_buffer_patch.import_buffer.Buffer.concat([
+		r,
+		publicKey,
+		message
+	]));
+	hram = import_libsodium_wrappers.default.crypto_core_ed25519_scalar_reduce(hram);
+	return require__polyfill_buffer_patch.import_buffer.Buffer.concat([r, import_libsodium_wrappers.default.crypto_core_ed25519_scalar_add(import_libsodium_wrappers.default.crypto_core_ed25519_scalar_mul(hram, scalar), nonce)]);
+};
+var Ed25519PrivateKeyType;
+(function(Ed25519PrivateKeyType) {
+	Ed25519PrivateKeyType["Normal"] = "Normal";
+	Ed25519PrivateKeyType["Extended"] = "Extended";
+})(Ed25519PrivateKeyType || (Ed25519PrivateKeyType = {}));
+var Ed25519PrivateKey = class Ed25519PrivateKey {
+	constructor(keyMaterial, type) {
+		_Ed25519PrivateKey_keyMaterial.set(this, void 0);
+		__classPrivateFieldSet$2(this, _Ed25519PrivateKey_keyMaterial, keyMaterial, "f");
+		this.__type = type;
+	}
+	toPublic() {
+		return require_Ed25519PublicKey.Ed25519PublicKey.fromBytes(this.__type === Ed25519PrivateKeyType.Extended ? import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(extendedScalar$1(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"))) : import_libsodium_wrappers.default.crypto_sign_seed_keypair(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).publicKey);
+	}
+	sign(message) {
+		return Ed25519Signature.fromBytes(this.__type === Ed25519PrivateKeyType.Extended ? signExtendedDetached(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"), require__polyfill_buffer_patch.import_buffer.Buffer.from(message, "hex")) : import_libsodium_wrappers.default.crypto_sign_detached(require__polyfill_buffer_patch.import_buffer.Buffer.from(message, "hex"), require__polyfill_buffer_patch.import_buffer.Buffer.concat([__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f"), this.toPublic().bytes()])));
+	}
+	static fromNormalBytes(keyMaterial) {
+		if (keyMaterial.length !== 32) throw new require_errors.InvalidArgumentError("keyMaterial", `Key should be 32 bytes; however ${keyMaterial.length} bytes were provided.`);
+		return new Ed25519PrivateKey(keyMaterial, Ed25519PrivateKeyType.Normal);
+	}
+	static fromExtendedBytes(keyMaterial) {
+		if (keyMaterial.length !== 64) throw new require_errors.InvalidArgumentError("keyMaterial", `Key should be 64 bytes; however ${keyMaterial.length} bytes were provided.`);
+		return new Ed25519PrivateKey(keyMaterial, Ed25519PrivateKeyType.Extended);
+	}
+	static fromNormalHex(keyMaterial) {
+		return Ed25519PrivateKey.fromNormalBytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(keyMaterial, "hex"));
+	}
+	static fromExtendedHex(keyMaterial) {
+		return Ed25519PrivateKey.fromExtendedBytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(keyMaterial, "hex"));
+	}
+	bytes() {
+		return __classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f");
+	}
+	hex() {
+		return this.__type === Ed25519PrivateKeyType.Extended ? require_Address.Ed25519PrivateExtendedKeyHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).toString("hex")) : require_Address.Ed25519PrivateNormalKeyHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet$2(this, _Ed25519PrivateKey_keyMaterial, "f")).toString("hex"));
+	}
+};
+_Ed25519PrivateKey_keyMaterial = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32PublicKey.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var __classPrivateFieldSet$1 = 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$1 = 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 _Bip32PublicKey_key;
+var Bip32PublicKey = class Bip32PublicKey {
+	constructor(key) {
+		_Bip32PublicKey_key.set(this, void 0);
+		__classPrivateFieldSet$1(this, _Bip32PublicKey_key, key, "f");
+	}
+	static fromBytes(key) {
+		if (key.length !== 64) throw new require_errors.InvalidArgumentError("key", `Key should be 64 bytes; however ${key.length} bytes were provided.`);
+		return new Bip32PublicKey(key);
+	}
+	static fromHex(key) {
+		return Bip32PublicKey.fromBytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(key, "hex"));
+	}
+	toRawKey() {
+		return require_Ed25519PublicKey.Ed25519PublicKey.fromBytes(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f").slice(0, 32));
+	}
+	derive(derivationIndices) {
+		let key = require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f"));
+		for (const index of derivationIndices) key = derivePublic(key, index);
+		return Bip32PublicKey.fromBytes(key);
+	}
+	bytes() {
+		return __classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f");
+	}
+	hex() {
+		return require_Address.Bip32PublicKeyHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f")).toString("hex"));
+	}
+	hash() {
+		const hash = import_libsodium_wrappers.default.crypto_generichash(28, __classPrivateFieldGet$1(this, _Bip32PublicKey_key, "f"), null);
+		return require_Address.Bip32PublicKeyHashHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(hash).toString("hex"));
+	}
+};
+_Bip32PublicKey_key = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/Bip32/Bip32PrivateKey.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_pbkdf2 = require_pbkdf2$1.require_pbkdf2();
+var __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 = 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 _Bip32PrivateKey_key;
+const SCALAR_INDEX = 0;
+const SCALAR_SIZE = 32;
+const PBKDF2_ITERATIONS = 4096;
+const PBKDF2_KEY_SIZE = 96;
+const PBKDF2_DIGEST_ALGORITHM = "sha512";
+const CHAIN_CODE_INDEX = 64;
+const CHAIN_CODE_SIZE = 32;
+const clampScalar = (scalar) => {
+	scalar[0] &= 248;
+	scalar[31] &= 31;
+	scalar[31] |= 64;
+	return scalar;
+};
+const extendedScalar = (extendedKey) => extendedKey.slice(SCALAR_INDEX, SCALAR_SIZE);
+var Bip32PrivateKey = class Bip32PrivateKey {
+	constructor(key) {
+		_Bip32PrivateKey_key.set(this, void 0);
+		__classPrivateFieldSet(this, _Bip32PrivateKey_key, key, "f");
+	}
+	static fromBip39Entropy(entropy, password) {
+		const xprv = (0, import_pbkdf2.pbkdf2Sync)(password, entropy, PBKDF2_ITERATIONS, PBKDF2_KEY_SIZE, PBKDF2_DIGEST_ALGORITHM);
+		return Bip32PrivateKey.fromBytes(clampScalar(xprv));
+	}
+	static fromBytes(key) {
+		if (key.length !== 96) throw new require_errors.InvalidArgumentError("key", `Key should be 96 bytes; however ${key.length} bytes were provided.`);
+		return new Bip32PrivateKey(key);
+	}
+	static fromHex(key) {
+		return Bip32PrivateKey.fromBytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(key, "hex"));
+	}
+	derive(derivationIndices) {
+		let key = require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f"));
+		for (const index of derivationIndices) key = derivePrivate(key, index);
+		return Bip32PrivateKey.fromBytes(key);
+	}
+	toRawKey() {
+		return Ed25519PrivateKey.fromExtendedBytes(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(0, 64));
+	}
+	toPublic() {
+		const scalar = extendedScalar(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(0, 64));
+		const publicKey = import_libsodium_wrappers.default.crypto_scalarmult_ed25519_base_noclamp(scalar);
+		return Bip32PublicKey.fromBytes(require__polyfill_buffer_patch.import_buffer.Buffer.concat([publicKey, __classPrivateFieldGet(this, _Bip32PrivateKey_key, "f").slice(CHAIN_CODE_INDEX, CHAIN_CODE_INDEX + CHAIN_CODE_SIZE)]));
+	}
+	bytes() {
+		return __classPrivateFieldGet(this, _Bip32PrivateKey_key, "f");
+	}
+	hex() {
+		return require_Address.Bip32PrivateKeyHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(__classPrivateFieldGet(this, _Bip32PrivateKey_key, "f")).toString("hex"));
+	}
+};
+_Bip32PrivateKey_key = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/crypto/dist/esm/strategies/SodiumBip32Ed25519.js
+const EXTENDED_KEY_HEX_LENGTH = 128;
+var SodiumBip32Ed25519 = class SodiumBip32Ed25519 {
+	constructor() {}
+	static async create() {
+		await import_libsodium_wrappers.default.ready;
+		return Promise.resolve(new SodiumBip32Ed25519());
+	}
+	fromBip39Entropy(entropy, passphrase) {
+		return Bip32PrivateKey.fromBip39Entropy(entropy, passphrase).hex();
+	}
+	getPublicKey(privateKey) {
+		return (privateKey.length === EXTENDED_KEY_HEX_LENGTH ? Ed25519PrivateKey.fromExtendedHex(privateKey) : Ed25519PrivateKey.fromNormalHex(privateKey)).toPublic().hex();
+	}
+	getPubKeyHash(publicKey) {
+		return require_Ed25519PublicKey.Ed25519PublicKey.fromHex(publicKey).hash().hex();
+	}
+	getRawPrivateKey(bip32PrivateKey) {
+		return Bip32PrivateKey.fromHex(bip32PrivateKey).toRawKey().hex();
+	}
+	getRawPublicKey(bip32PublicKey) {
+		return Bip32PublicKey.fromHex(bip32PublicKey).toRawKey().hex();
+	}
+	getBip32PublicKey(privateKey) {
+		return Bip32PrivateKey.fromHex(privateKey).toPublic().hex();
+	}
+	derivePrivateKey(parentKey, derivationIndices) {
+		return Bip32PrivateKey.fromHex(parentKey).derive(derivationIndices).hex();
+	}
+	derivePublicKey(parentKey, derivationIndices) {
+		return Bip32PublicKey.fromHex(parentKey).derive(derivationIndices).hex();
+	}
+	async derivePublicKeyAsync(parentKey, derivationIndices) {
+		return this.derivePublicKey(parentKey, derivationIndices);
+	}
+	sign(privateKey, message) {
+		return (privateKey.length === EXTENDED_KEY_HEX_LENGTH ? Ed25519PrivateKey.fromExtendedHex(privateKey) : Ed25519PrivateKey.fromNormalHex(privateKey)).sign(message).hex();
+	}
+	verify(signature, message, publicKey) {
+		return require_Ed25519PublicKey.Ed25519PublicKey.fromHex(publicKey).verify(Ed25519Signature.fromHex(signature), message);
+	}
+};
+//#endregion
+Object.defineProperty(exports, "Bip32PublicKey", {
+	enumerable: true,
+	get: function() {
+		return Bip32PublicKey;
+	}
+});
+Object.defineProperty(exports, "Ed25519Signature", {
+	enumerable: true,
+	get: function() {
+		return Ed25519Signature;
+	}
+});
+Object.defineProperty(exports, "SodiumBip32Ed25519", {
+	enumerable: true,
+	get: function() {
+		return SodiumBip32Ed25519;
+	}
+});