@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/InMemoryKeyAgent-Bc_xZY-v.cjs

@@ -0,0 +1,652 @@
+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_isNotNil = require("./isNotNil-CrYIUFry.cjs");
+const require_Ed25519PublicKey = require("./Ed25519PublicKey-B3QcR0J2.cjs");
+const require_pbkdf2$1 = require("./pbkdf2-B1veireP.cjs");
+const require_types = require("./types-Cn6WlQV6.cjs");
+const require_secret_box = require("./secret-box-ZfbYwBgS.cjs");
+const require_Bip32Account = require("./Bip32Account-DOaGmKpv.cjs");
+const require_bip39 = require("./bip39-MAck9iod.cjs");
+let lodash_isEqual_js = require("lodash/isEqual.js");
+lodash_isEqual_js = require_chunk.__toESM(lodash_isEqual_js);
+let ts_custom_error = require("ts-custom-error");
+let lodash_uniqWith_js = require("lodash/uniqWith.js");
+lodash_uniqWith_js = require_chunk.__toESM(lodash_uniqWith_js);
+let lodash_uniqBy_js = require("lodash/uniqBy.js");
+lodash_uniqBy_js = require_chunk.__toESM(lodash_uniqBy_js);
+//#region \0stub-cardano-message-signing
+function stub() {
+	return new Proxy(stub, { get: () => stub });
+}
+const AlgorithmId = stub();
+const CBORValue = stub();
+const COSEKey = stub();
+const COSESign1Builder = stub();
+const CurveType = stub();
+const HeaderMap = stub();
+const Headers = stub();
+const Int = stub();
+const KeyType = stub();
+const Label = stub();
+const ProtectedHeaderMap = stub();
+stub();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/errors/AuthenticationError.js
+const formatMessage = (detail) => {
+	return `Authentication failure${detail ? `: ${detail}` : ""}`;
+};
+var AuthenticationError = class extends require_errors.ComposableError {
+	constructor(detail, innerError) {
+		super(formatMessage(detail), innerError);
+	}
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/errors/InvalidMnemonicError.js
+var InvalidMnemonicError = class extends ts_custom_error.CustomError {
+	constructor() {
+		super();
+		this.message = "Invalid Mnemonic";
+		this.name = "InvalidMnemonicError";
+	}
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/KeyAgentBase.js
+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 _KeyAgentBase_serializableData, _KeyAgentBase_bip32Ed25519, _KeyAgentBase_account;
+var KeyAgentBase = class {
+	constructor(serializableData, { bip32Ed25519 }) {
+		_KeyAgentBase_serializableData.set(this, void 0);
+		_KeyAgentBase_bip32Ed25519.set(this, void 0);
+		_KeyAgentBase_account.set(this, void 0);
+		__classPrivateFieldSet$1(this, _KeyAgentBase_serializableData, serializableData, "f");
+		__classPrivateFieldSet$1(this, _KeyAgentBase_bip32Ed25519, bip32Ed25519, "f");
+		__classPrivateFieldSet$1(this, _KeyAgentBase_account, new require_Bip32Account.Bip32Account(serializableData, {
+			bip32Ed25519,
+			blake2b: require_Address.blake2b
+		}), "f");
+	}
+	get serializableData() {
+		return __classPrivateFieldGet$1(this, _KeyAgentBase_serializableData, "f");
+	}
+	get extendedAccountPublicKey() {
+		return this.serializableData.extendedAccountPublicKey;
+	}
+	get chainId() {
+		return this.serializableData.chainId;
+	}
+	get accountIndex() {
+		return this.serializableData.accountIndex;
+	}
+	get bip32Ed25519() {
+		return __classPrivateFieldGet$1(this, _KeyAgentBase_bip32Ed25519, "f");
+	}
+	get purpose() {
+		return this.serializableData.purpose || require_types.KeyPurpose.STANDARD;
+	}
+	async deriveAddress(paymentKeyDerivationPath, stakeKeyDerivationIndex) {
+		return __classPrivateFieldGet$1(this, _KeyAgentBase_account, "f").deriveAddress(paymentKeyDerivationPath, stakeKeyDerivationIndex);
+	}
+	async derivePublicKey(derivationPath) {
+		return __classPrivateFieldGet$1(this, _KeyAgentBase_account, "f").derivePublicKey(derivationPath);
+	}
+};
+_KeyAgentBase_serializableData = /* @__PURE__ */ new WeakMap(), _KeyAgentBase_bip32Ed25519 = /* @__PURE__ */ new WeakMap(), _KeyAgentBase_account = /* @__PURE__ */ new WeakMap();
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/cip8/util.js
+const CoseLabel = {
+	address: Label.new_text("address"),
+	crv: Label.new_int(Int.new_i32(-1)),
+	x: Label.new_int(Int.new_i32(-2))
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/util/key.js
+const harden = (num) => 2147483648 + num;
+const STAKE_KEY_DERIVATION_PATH = {
+	index: 0,
+	role: require_types.KeyRole.Stake
+};
+const DREP_KEY_DERIVATION_PATH = {
+	index: 0,
+	role: require_types.KeyRole.DRep
+};
+const deriveAccountPrivateKey = async ({ rootPrivateKey, accountIndex, bip32Ed25519, purpose = require_types.KeyPurpose.STANDARD }) => await bip32Ed25519.derivePrivateKey(rootPrivateKey, [
+	harden(purpose),
+	harden(require_types.CardanoKeyConst.COIN_TYPE),
+	harden(accountIndex)
+]);
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/util/ownSignatureKeyPaths.js
+const checkWithdrawals = ({ withdrawals }, accounts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (withdrawals) for (const withdrawal of withdrawals) {
+		const account = accounts.find((acct) => acct.rewardAccount === withdrawal.stakeAddress);
+		if (account) signatureCheck.derivationPaths.push(account.derivationPath);
+		else signatureCheck.requiresForeignSignatures = true;
+	}
+	return signatureCheck;
+};
+const checkStakeKeyHashCertificate = (certificate, accounts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	switch (certificate.__typename) {
+		case require_Address.CertificateType.VoteDelegation:
+		case require_Address.CertificateType.StakeVoteDelegation:
+		case require_Address.CertificateType.StakeRegistrationDelegation:
+		case require_Address.CertificateType.VoteRegistrationDelegation:
+		case require_Address.CertificateType.StakeVoteRegistrationDelegation:
+		case require_Address.CertificateType.Registration:
+		case require_Address.CertificateType.Unregistration:
+		case require_Address.CertificateType.StakeDeregistration:
+		case require_Address.CertificateType.StakeDelegation: {
+			const account = accounts.find((acct) => certificate.stakeCredential.type === require_Address.CredentialType.KeyHash && acct.stakeKeyHash === certificate.stakeCredential.hash);
+			if (account) signatureCheck.derivationPaths = [account.derivationPath];
+			else signatureCheck.requiresForeignSignatures = true;
+		}
+	}
+	return signatureCheck;
+};
+const checkPoolRegistrationCertificate = (certificate, accounts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (certificate.__typename === require_Address.CertificateType.PoolRegistration) for (const owner of certificate.poolParameters.owners) {
+		const account = accounts.find((acct) => acct.rewardAccount === owner);
+		if (account) signatureCheck.derivationPaths.push(account.derivationPath);
+		else signatureCheck.requiresForeignSignatures = true;
+	}
+	return signatureCheck;
+};
+const checkPoolRetirementCertificate = (certificate, accounts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (certificate.__typename === require_Address.CertificateType.PoolRetirement) {
+		const account = accounts.find((acct) => acct.poolId === certificate.poolId);
+		if (account) signatureCheck.derivationPaths.push(account.derivationPath);
+		else signatureCheck.requiresForeignSignatures = true;
+	}
+	return signatureCheck;
+};
+const checkMirCertificate = (certificate, accounts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (certificate.__typename === require_Address.CertificateType.MIR) if (certificate.kind === require_Address.MirCertificateKind.ToStakeCreds) {
+		const account = accounts.find((acct) => require_Address.Hash28ByteBase16(acct.stakeKeyHash) === certificate.stakeCredential.hash);
+		if (account) signatureCheck.derivationPaths.push(account.derivationPath);
+		else signatureCheck.requiresForeignSignatures = true;
+	} else signatureCheck.requiresForeignSignatures = true;
+	return signatureCheck;
+};
+const checkStakeCredentialCertificates = (accounts, { certificates }) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (!certificates?.length) return signatureCheck;
+	for (const certificate of certificates) {
+		const stakeKeyHashCheck = checkStakeKeyHashCertificate(certificate, accounts);
+		signatureCheck.requiresForeignSignatures ||= stakeKeyHashCheck.requiresForeignSignatures;
+		signatureCheck.derivationPaths.push(...stakeKeyHashCheck.derivationPaths);
+		const poolOwnerCheck = checkPoolRegistrationCertificate(certificate, accounts);
+		signatureCheck.requiresForeignSignatures ||= poolOwnerCheck.requiresForeignSignatures;
+		signatureCheck.derivationPaths.push(...poolOwnerCheck.derivationPaths);
+		const poolIdCheck = checkPoolRetirementCertificate(certificate, accounts);
+		signatureCheck.requiresForeignSignatures ||= poolIdCheck.requiresForeignSignatures;
+		signatureCheck.derivationPaths.push(...poolIdCheck.derivationPaths);
+		const mirCheck = checkMirCertificate(certificate, accounts);
+		signatureCheck.requiresForeignSignatures ||= mirCheck.requiresForeignSignatures;
+		signatureCheck.derivationPaths.push(...mirCheck.derivationPaths);
+	}
+	signatureCheck.derivationPaths = (0, lodash_uniqWith_js.default)(signatureCheck.derivationPaths, lodash_isEqual_js.default);
+	return signatureCheck;
+};
+const getSignersData = (groupedAddresses) => (0, lodash_uniqBy_js.default)(groupedAddresses, "rewardAccount").map((groupedAddress) => {
+	const stakeKeyHash = require_Address.RewardAccount.toHash(groupedAddress.rewardAccount);
+	const poolId = require_Address.PoolId.fromKeyHash(stakeKeyHash);
+	return {
+		derivationPath: groupedAddress.stakeKeyDerivationPath,
+		poolId,
+		rewardAccount: groupedAddress.rewardAccount,
+		stakeKeyHash
+	};
+}).filter((acct) => acct.derivationPath !== void 0);
+const getStakeCredentialKeyPaths = (groupedAddresses, txBody) => {
+	let requiresForeignSignatures = false;
+	const paths = [];
+	const uniqueAccounts = getSignersData(groupedAddresses);
+	const withdrawalCheck = checkWithdrawals(txBody, uniqueAccounts);
+	requiresForeignSignatures ||= withdrawalCheck.requiresForeignSignatures;
+	paths.push(...withdrawalCheck.derivationPaths);
+	const stakeCredentialCertificatesCheck = checkStakeCredentialCertificates(uniqueAccounts, txBody);
+	requiresForeignSignatures ||= stakeCredentialCertificatesCheck.requiresForeignSignatures;
+	paths.push(...stakeCredentialCertificatesCheck.derivationPaths);
+	return {
+		derivationPaths: new Set(paths),
+		requiresForeignSignatures
+	};
+};
+const getVotingProcedureKeyPaths = ({ groupedAddresses, dRepKeyHash, txBody }) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	const accounts = getSignersData(groupedAddresses);
+	for (const { voter } of txBody.votingProcedures || []) switch (voter.__typename) {
+		case require_Address.VoterType.dRepKeyHash:
+			if (dRepKeyHash && voter.credential.hash === dRepKeyHash) signatureCheck.derivationPaths.push(DREP_KEY_DERIVATION_PATH);
+			else signatureCheck.requiresForeignSignatures = true;
+			break;
+		case require_Address.VoterType.stakePoolKeyHash: {
+			const account = accounts.find((acct) => acct.stakeKeyHash === voter.credential.hash);
+			if (account) signatureCheck.derivationPaths.push(account.derivationPath);
+			else signatureCheck.requiresForeignSignatures = true;
+			break;
+		}
+		default:
+			signatureCheck.requiresForeignSignatures = true;
+			break;
+	}
+	return signatureCheck;
+};
+const getRequiredSignersKeyPaths = (groupedAddresses, keyHashes) => {
+	const paths = [];
+	if (!keyHashes) return paths;
+	for (const keyHash of keyHashes) for (const address of groupedAddresses) {
+		const paymentCredential = require_Address.Address.fromBech32(address.address)?.asBase()?.getPaymentCredential().hash;
+		const stakeCredential = require_Address.RewardAccount.toHash(address.rewardAccount);
+		if (paymentCredential && paymentCredential.toString() === keyHash) paths.push({
+			index: address.index,
+			role: Number(address.type)
+		});
+		if (stakeCredential && address.stakeKeyDerivationPath && stakeCredential.toString() === keyHash) paths.push(address.stakeKeyDerivationPath);
+	}
+	return paths;
+};
+const checkStakeCredential = (address, keyHash) => address.stakeKeyDerivationPath && require_Address.RewardAccount.toHash(address.rewardAccount) === keyHash ? {
+	derivationPaths: [address.stakeKeyDerivationPath],
+	requiresForeignSignatures: false
+} : {
+	derivationPaths: [],
+	requiresForeignSignatures: true
+};
+const checkPaymentCredential = (address, keyHash) => {
+	if ((require_Address.Address.fromBech32(address.address)?.asBase()?.getPaymentCredential())?.hash === keyHash) return {
+		derivationPaths: [{
+			index: address.index,
+			role: Number(address.type)
+		}],
+		requiresForeignSignatures: false
+	};
+	return {
+		derivationPaths: [],
+		requiresForeignSignatures: true
+	};
+};
+const combineSignatureChecks = (a, b) => ({
+	derivationPaths: [...a.derivationPaths, ...b.derivationPaths],
+	requiresForeignSignatures: a.requiresForeignSignatures || b.requiresForeignSignatures
+});
+const processSignatureScript = (script, groupedAddresses) => {
+	let signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	for (const address of groupedAddresses) {
+		if (address.stakeKeyDerivationPath) signatureCheck = combineSignatureChecks(signatureCheck, checkStakeCredential(address, script.keyHash));
+		signatureCheck = combineSignatureChecks(signatureCheck, checkPaymentCredential(address, script.keyHash));
+	}
+	return signatureCheck;
+};
+const getNativeScriptKeyPaths = (groupedAddresses, nativeScripts) => {
+	const signatureCheck = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	if (!nativeScripts?.length) return signatureCheck;
+	const processScript = (script) => {
+		if (!require_Address.isNativeScript(script)) return {
+			derivationPaths: [],
+			requiresForeignSignatures: false
+		};
+		switch (script.kind) {
+			case require_Address.NativeScriptKind.RequireSignature: return processSignatureScript(script, groupedAddresses);
+			case require_Address.NativeScriptKind.RequireAllOf:
+			case require_Address.NativeScriptKind.RequireAnyOf:
+			case require_Address.NativeScriptKind.RequireNOf: return script.scripts.reduce((acc, subScript) => combineSignatureChecks(acc, processScript(subScript)), {
+				derivationPaths: [],
+				requiresForeignSignatures: false
+			});
+			case require_Address.NativeScriptKind.RequireTimeBefore:
+			case require_Address.NativeScriptKind.RequireTimeAfter: return {
+				derivationPaths: [],
+				requiresForeignSignatures: false
+			};
+			case require_Address.NativeScriptKind.RequireGuard: {
+				const guardScript = script;
+				return guardScript.credential.type === require_Address.CredentialType.KeyHash ? processSignatureScript({
+					__type: require_Address.ScriptType.Native,
+					keyHash: guardScript.credential.hash,
+					kind: require_Address.NativeScriptKind.RequireSignature
+				}, groupedAddresses) : {
+					derivationPaths: [],
+					requiresForeignSignatures: false
+				};
+			}
+		}
+	};
+	return nativeScripts.reduce((acc, script) => combineSignatureChecks(acc, processScript(script)), signatureCheck);
+};
+const getDRepCredentialKeyPaths = ({ dRepKeyHash, txBody }) => {
+	const signature = {
+		derivationPaths: [],
+		requiresForeignSignatures: false
+	};
+	for (const certificate of txBody.certificates || []) if (certificate.__typename === require_Address.CertificateType.UnregisterDelegateRepresentative || certificate.__typename === require_Address.CertificateType.UpdateDelegateRepresentative || certificate.__typename === require_Address.CertificateType.RegisterDelegateRepresentative) if (certificate.dRepCredential.type === require_Address.CredentialType.ScriptHash || !dRepKeyHash || certificate.dRepCredential.hash !== dRepKeyHash) signature.requiresForeignSignatures = true;
+	else signature.derivationPaths = [DREP_KEY_DERIVATION_PATH];
+	return signature;
+};
+const createTxInKeyPathMap = async (txBody, knownAddresses, inputResolver) => {
+	const result = {};
+	const txInputs = [...txBody.inputs, ...txBody.collaterals ? txBody.collaterals : []];
+	await Promise.all(txInputs.map(async (txIn) => {
+		const resolution = await inputResolver.resolveInput(txIn);
+		if (!resolution) return;
+		const ownAddress = knownAddresses.find(({ address }) => address === resolution.address);
+		if (!ownAddress) return;
+		result[require_types.TxInId(txIn)] = {
+			index: ownAddress.index,
+			role: Number(ownAddress.type)
+		};
+	}));
+	return result;
+};
+const ownSignatureKeyPaths = (txBody, knownAddresses, txInKeyPathMap, dRepKeyHash, scripts) => {
+	return (0, lodash_uniqWith_js.default)([
+		...Object.values(txInKeyPathMap).filter(require_isNotNil.isNotNil),
+		...getStakeCredentialKeyPaths(knownAddresses, txBody).derivationPaths,
+		...getDRepCredentialKeyPaths({
+			dRepKeyHash,
+			txBody
+		}).derivationPaths,
+		...getRequiredSignersKeyPaths(knownAddresses, txBody.requiredExtraSignatures),
+		...getVotingProcedureKeyPaths({
+			dRepKeyHash,
+			groupedAddresses: knownAddresses,
+			txBody
+		}).derivationPaths,
+		...getNativeScriptKeyPaths(knownAddresses, scripts).derivationPaths
+	], lodash_isEqual_js.default);
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/cip8/cip30signData.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var Cip30DataSignErrorCode;
+(function(Cip30DataSignErrorCode) {
+	Cip30DataSignErrorCode[Cip30DataSignErrorCode["ProofGeneration"] = 1] = "ProofGeneration";
+	Cip30DataSignErrorCode[Cip30DataSignErrorCode["AddressNotPK"] = 2] = "AddressNotPK";
+	Cip30DataSignErrorCode[Cip30DataSignErrorCode["UserDeclined"] = 3] = "UserDeclined";
+})(Cip30DataSignErrorCode || (Cip30DataSignErrorCode = {}));
+var Cip30DataSignError = class extends require_errors.ComposableError {
+	constructor(code, info, innerError) {
+		super(`DataSignError code: ${code}`, innerError);
+		this.code = code;
+		this.info = info;
+	}
+};
+const getAddressBytes = (signWith) => {
+	const address = require_Address.Address.fromString(signWith);
+	if (!address) throw new Cip30DataSignError(Cip30DataSignErrorCode.AddressNotPK, "Invalid address");
+	return require__polyfill_buffer_patch.import_buffer.Buffer.from(address.toBytes(), "hex");
+};
+const isPaymentAddress = (signWith) => signWith.startsWith("addr");
+const getDerivationPath = async (signWith, knownAddresses, dRepKeyHash) => {
+	if (signWith.startsWith("stake")) {
+		const knownRewardAddress = knownAddresses.find(({ rewardAccount }) => rewardAccount === signWith);
+		if (!knownRewardAddress) throw new Cip30DataSignError(Cip30DataSignErrorCode.ProofGeneration, "Unknown reward address");
+		return knownRewardAddress.stakeKeyDerivationPath || STAKE_KEY_DERIVATION_PATH;
+	}
+	if (isPaymentAddress(signWith)) {
+		const drepAddr = require_Address.Address.fromString(signWith);
+		if (drepAddr?.getType() === require_Address.AddressType.EnterpriseKey && drepAddr?.getProps().paymentPart?.hash === dRepKeyHash) return DREP_KEY_DERIVATION_PATH;
+	}
+	const knownAddress = knownAddresses.find(({ address }) => address === signWith);
+	if (!knownAddress) throw new Cip30DataSignError(Cip30DataSignErrorCode.ProofGeneration, "Unknown address");
+	return {
+		index: knownAddress.index,
+		role: knownAddress.type
+	};
+};
+const createSigStructureHeaders = (addressBytes) => {
+	const protectedHeaders = HeaderMap.new();
+	protectedHeaders.set_key_id(addressBytes);
+	protectedHeaders.set_header(CoseLabel.address, CBORValue.new_bytes(addressBytes));
+	protectedHeaders.set_algorithm_id(Label.from_algorithm_id(AlgorithmId.EdDSA));
+	return protectedHeaders;
+};
+const signSigStructure = (keyAgent, derivationPath, sigStructure) => {
+	try {
+		return keyAgent.signBlob(derivationPath, require_Address.bytesToHex(sigStructure.to_bytes()));
+	} catch (error) {
+		throw new Cip30DataSignError(Cip30DataSignErrorCode.UserDeclined, "Failed to sign", error);
+	}
+};
+const createCoseKey = (addressBytes, publicKey) => {
+	const coseKey = COSEKey.new(Label.from_key_type(KeyType.OKP));
+	coseKey.set_key_id(addressBytes);
+	coseKey.set_algorithm_id(Label.from_algorithm_id(AlgorithmId.EdDSA));
+	coseKey.set_header(CoseLabel.crv, CBORValue.from_label(Label.from_curve_type(CurveType.Ed25519)));
+	coseKey.set_header(CoseLabel.x, CBORValue.new_bytes(require__polyfill_buffer_patch.import_buffer.Buffer.from(publicKey, "hex")));
+	return coseKey;
+};
+const cip30signData = async (keyAgent, { knownAddresses, signWith, payload }) => {
+	const dRepKeyHash = require_Ed25519PublicKey.Ed25519PublicKey.fromHex(await keyAgent.derivePublicKey(DREP_KEY_DERIVATION_PATH)).hash().hex();
+	const addressBytes = getAddressBytes(signWith);
+	const derivationPath = await getDerivationPath(signWith, knownAddresses, dRepKeyHash);
+	const builder = COSESign1Builder.new(Headers.new(ProtectedHeaderMap.new(createSigStructureHeaders(addressBytes)), HeaderMap.new()), require__polyfill_buffer_patch.import_buffer.Buffer.from(payload, "hex"), false);
+	const { signature, publicKey } = await signSigStructure(keyAgent, derivationPath, builder.make_data_to_sign());
+	const coseSign1 = builder.build(require__polyfill_buffer_patch.import_buffer.Buffer.from(signature, "hex"));
+	const coseKey = createCoseKey(addressBytes, publicKey);
+	return {
+		key: require_Address.bytesToHex(coseKey.to_bytes()),
+		signature: require_Address.bytesToHex(coseSign1.to_bytes())
+	};
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/emip3.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+var import_pbkdf2 = require_pbkdf2$1.require_pbkdf2();
+var import_browser = /* @__PURE__ */ require_chunk.__toESM(require_secret_box.require_browser(), 1);
+var import_get_random_values = /* @__PURE__ */ require_chunk.__toESM(require_secret_box.require_get_random_values(), 1);
+const KEY_LENGTH = 32;
+const NONCE_LENGTH = 12;
+const PBKDF2_ITERATIONS = 19162;
+const SALT_LENGTH = 32;
+const TAG_LENGTH = 16;
+const AAD = require__polyfill_buffer_patch.import_buffer.Buffer.from("", "hex");
+const createPbkdf2Key = async (passphrase, salt) => await new Promise((resolve, reject) => (0, import_pbkdf2.pbkdf2)(passphrase, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512", (err, derivedKey) => {
+	if (err) return reject(err);
+	resolve(derivedKey);
+}));
+const emip3encrypt = async (data, passphrase) => {
+	const salt = new Uint8Array(SALT_LENGTH);
+	(0, import_get_random_values.default)(salt);
+	const key = await createPbkdf2Key(passphrase, salt);
+	const nonce = new Uint8Array(NONCE_LENGTH);
+	(0, import_get_random_values.default)(nonce);
+	const cipher = import_browser.createCipher(key, require__polyfill_buffer_patch.import_buffer.Buffer.from(nonce));
+	cipher.setAAD(AAD, { plaintextLength: data.length });
+	const head = cipher.update(data);
+	const final = cipher.final();
+	const tag = cipher.getAuthTag();
+	return require__polyfill_buffer_patch.import_buffer.Buffer.concat([
+		salt,
+		nonce,
+		tag,
+		head,
+		final
+	]);
+};
+const emip3decrypt = async (encrypted, passphrase) => {
+	const salt = encrypted.slice(0, SALT_LENGTH);
+	const nonce = encrypted.slice(SALT_LENGTH, SALT_LENGTH + NONCE_LENGTH);
+	const tag = encrypted.slice(SALT_LENGTH + NONCE_LENGTH, SALT_LENGTH + NONCE_LENGTH + TAG_LENGTH);
+	const data = encrypted.slice(SALT_LENGTH + NONCE_LENGTH + TAG_LENGTH);
+	const key = await createPbkdf2Key(passphrase, salt);
+	const decipher = import_browser.createDecipher(key, require__polyfill_buffer_patch.import_buffer.Buffer.from(nonce));
+	decipher.setAuthTag(require__polyfill_buffer_patch.import_buffer.Buffer.from(tag));
+	decipher.setAAD(AAD);
+	return require__polyfill_buffer_patch.import_buffer.Buffer.concat([decipher.update(require__polyfill_buffer_patch.import_buffer.Buffer.from(data)), decipher.final()]);
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/key-management/dist/esm/InMemoryKeyAgent.js
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+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 _InMemoryKeyAgent_instances, _InMemoryKeyAgent_getPassphrase, _InMemoryKeyAgent_rootPrivateKeyEncryption, _InMemoryKeyAgent_decryptRootPrivateKey;
+const defaultRootPrivateKeyEncryption = {
+	decrypt: emip3decrypt,
+	encrypt: emip3encrypt
+};
+const getPassphraseRethrowTypedError = async (getPassphrase) => {
+	try {
+		return await getPassphrase();
+	} catch (error) {
+		throw new AuthenticationError("Failed to enter passphrase", error);
+	}
+};
+var InMemoryKeyAgent = class InMemoryKeyAgent extends KeyAgentBase {
+	constructor({ getPassphrase, ...serializableData }, dependencies) {
+		super({
+			...serializableData,
+			__typename: require_types.KeyAgentType.InMemory
+		}, dependencies);
+		_InMemoryKeyAgent_instances.add(this);
+		_InMemoryKeyAgent_getPassphrase.set(this, void 0);
+		_InMemoryKeyAgent_rootPrivateKeyEncryption.set(this, void 0);
+		__classPrivateFieldSet(this, _InMemoryKeyAgent_getPassphrase, getPassphrase, "f");
+		__classPrivateFieldSet(this, _InMemoryKeyAgent_rootPrivateKeyEncryption, dependencies.rootPrivateKeyEncryption ?? defaultRootPrivateKeyEncryption, "f");
+	}
+	async signBlob({ index, role: type }, blob) {
+		const rootPrivateKey = await __classPrivateFieldGet(this, _InMemoryKeyAgent_instances, "m", _InMemoryKeyAgent_decryptRootPrivateKey).call(this);
+		const accountKey = await deriveAccountPrivateKey({
+			accountIndex: this.accountIndex,
+			bip32Ed25519: this.bip32Ed25519,
+			purpose: this.purpose,
+			rootPrivateKey
+		});
+		const bip32SigningKey = await this.bip32Ed25519.derivePrivateKey(accountKey, [type, index]);
+		const signingKey = await this.bip32Ed25519.getRawPrivateKey(bip32SigningKey);
+		const signature = await this.bip32Ed25519.sign(signingKey, blob);
+		return {
+			publicKey: await this.bip32Ed25519.getPublicKey(signingKey),
+			signature
+		};
+	}
+	async signCip8Data(context) {
+		return await cip30signData(this, context);
+	}
+	async exportRootPrivateKey() {
+		return await __classPrivateFieldGet(this, _InMemoryKeyAgent_instances, "m", _InMemoryKeyAgent_decryptRootPrivateKey).call(this, true);
+	}
+	static async fromBip39MnemonicWords({ chainId, getPassphrase, mnemonicWords, mnemonic2ndFactorPassphrase = "", accountIndex = 0, purpose = require_types.KeyPurpose.STANDARD }, dependencies) {
+		if (!require_bip39.validateMnemonic(require_bip39.joinMnemonicWords(mnemonicWords))) throw new InvalidMnemonicError();
+		const entropy = require__polyfill_buffer_patch.import_buffer.Buffer.from(require_bip39.mnemonicWordsToEntropy(mnemonicWords), "hex");
+		const rootPrivateKey = dependencies.bip32Ed25519.fromBip39Entropy(entropy, mnemonic2ndFactorPassphrase);
+		const passphrase = await getPassphraseRethrowTypedError(getPassphrase);
+		const encryptedRootPrivateKey = await (dependencies.rootPrivateKeyEncryption ?? defaultRootPrivateKeyEncryption).encrypt(require__polyfill_buffer_patch.import_buffer.Buffer.from(rootPrivateKey, "hex"), passphrase);
+		const accountPrivateKey = await deriveAccountPrivateKey({
+			accountIndex,
+			bip32Ed25519: dependencies.bip32Ed25519,
+			purpose,
+			rootPrivateKey
+		});
+		const extendedAccountPublicKey = await dependencies.bip32Ed25519.getBip32PublicKey(accountPrivateKey);
+		return new InMemoryKeyAgent({
+			accountIndex,
+			chainId,
+			encryptedRootPrivateKeyBytes: [...encryptedRootPrivateKey],
+			extendedAccountPublicKey,
+			getPassphrase,
+			purpose
+		}, dependencies);
+	}
+	async signTransaction(txBody, { txInKeyPathMap, knownAddresses, scripts }, { additionalKeyPaths = [] } = {}) {
+		const blob = txBody.hash();
+		const keyPaths = (0, lodash_uniqBy_js.default)([...ownSignatureKeyPaths(txBody.toCore(), knownAddresses, txInKeyPathMap, (await require_Ed25519PublicKey.Ed25519PublicKey.fromHex(await this.derivePublicKey(DREP_KEY_DERIVATION_PATH)).hash()).hex(), scripts), ...additionalKeyPaths], ({ role, index }) => `${role}.${index}`);
+		return new Map(await Promise.all(keyPaths.map(async ({ role, index }) => {
+			const { publicKey, signature } = await this.signBlob({
+				index,
+				role
+			}, blob);
+			return [publicKey, signature];
+		})));
+	}
+	async exportExtendedKeyPair(derivationPath) {
+		const rootPrivateKey = await this.exportRootPrivateKey();
+		const hardenedIndices = derivationPath.map((index) => harden(index));
+		const childKey = await this.bip32Ed25519.derivePrivateKey(rootPrivateKey, hardenedIndices);
+		return {
+			skey: childKey,
+			vkey: await this.bip32Ed25519.getBip32PublicKey(childKey)
+		};
+	}
+};
+_InMemoryKeyAgent_getPassphrase = /* @__PURE__ */ new WeakMap(), _InMemoryKeyAgent_rootPrivateKeyEncryption = /* @__PURE__ */ new WeakMap(), _InMemoryKeyAgent_instances = /* @__PURE__ */ new WeakSet(), _InMemoryKeyAgent_decryptRootPrivateKey = async function _InMemoryKeyAgent_decryptRootPrivateKey(noCache) {
+	const passphrase = await getPassphraseRethrowTypedError(() => __classPrivateFieldGet(this, _InMemoryKeyAgent_getPassphrase, "f").call(this, noCache));
+	let decryptedRootKeyBytes;
+	try {
+		decryptedRootKeyBytes = await __classPrivateFieldGet(this, _InMemoryKeyAgent_rootPrivateKeyEncryption, "f").decrypt(new Uint8Array(this.serializableData.encryptedRootPrivateKeyBytes), passphrase);
+	} catch (error) {
+		throw new AuthenticationError("Failed to decrypt root private key", error);
+	}
+	return require_Address.Bip32PrivateKeyHex(require__polyfill_buffer_patch.import_buffer.Buffer.from(decryptedRootKeyBytes).toString("hex"));
+};
+//#endregion
+Object.defineProperty(exports, "InMemoryKeyAgent", {
+	enumerable: true,
+	get: function() {
+		return InMemoryKeyAgent;
+	}
+});
+Object.defineProperty(exports, "createTxInKeyPathMap", {
+	enumerable: true,
+	get: function() {
+		return createTxInKeyPathMap;
+	}
+});
+Object.defineProperty(exports, "deriveAccountPrivateKey", {
+	enumerable: true,
+	get: function() {
+		return deriveAccountPrivateKey;
+	}
+});