@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/init-Clu8pxwQ.cjs

@@ -0,0 +1,1181 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_secret_box = require("./secret-box-DrjLZuS1.cjs");
+const require_util = require("./util-Bu4W5lF4.cjs");
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_bignum_vo = require("./bignum.vo-hx2kuqlA.cjs");
+const require_asyncoption = require("./asyncoption-i0VbqVTq.cjs");
+const require_first_state_of_status = require("./first-state-of-status-CbT7hPa4.cjs");
+require("./retry-config-BaCfVC1H.cjs");
+const require_activity_type = require("./activity-type-Ch6ljxBy.cjs");
+const require_cardano_network_id_vo = require("./cardano-network-id.vo-BEDPn6Li.cjs");
+const require_const = require("./const-D-eZIS4n.cjs");
+const require_TransactionBuilder = require("./TransactionBuilder-X1H9Gze6.cjs");
+const require_apply_vkey_witnesses = require("./apply-vkey-witnesses-ZnFS0jnJ.cjs");
+const require_account_guards = require("./account-guards-BtjTGxDZ.cjs");
+const require_unwrap_provider_result = require("./unwrap-provider-result-ZqfBsTkk.cjs");
+let _laceio_cardano_key_management = require("@laceio/cardano/key-management");
+let _laceio_cardano_crypto = require("@laceio/cardano/crypto");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+let _laceio_cardano_util = require("@laceio/cardano/util");
+let rxjs = require("rxjs");
+let _laceio_cardano_tx_construction = require("@laceio/cardano/tx-construction");
+//#region ../../packages/contract/cardano-context/src/value-objects/cardano-testnet-id.vo.ts
+const CARDANO_CHAIN_ID_BY_TESTNET = {
+	preprod: _laceio_cardano_core.Cardano.ChainIds.Preprod,
+	preview: _laceio_cardano_core.Cardano.ChainIds.Preview,
+	sanchonet: _laceio_cardano_core.Cardano.ChainIds.Sanchonet
+};
+const PREPROD_MAGIC = Number(_laceio_cardano_core.Cardano.ChainIds.Preprod.networkMagic);
+const PREVIEW_MAGIC = Number(_laceio_cardano_core.Cardano.ChainIds.Preview.networkMagic);
+const SANCHONET_MAGIC = Number(_laceio_cardano_core.Cardano.ChainIds.Sanchonet.networkMagic);
+const getCardanoTestnetIdByNetworkMagic = (networkMagic) => {
+	const magic = Number(networkMagic);
+	if (magic === PREPROD_MAGIC) return "preprod";
+	if (magic === PREVIEW_MAGIC) return "preview";
+	if (magic === SANCHONET_MAGIC) return "sanchonet";
+};
+const getCardanoChainIdByTestnetId = (id) => CARDANO_CHAIN_ID_BY_TESTNET[id];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/resolve-validity-interval.ts
+/** Two hours, matching the send flow's window (`build-tx.ts`). */
+const DEFAULT_VALIDITY_SECONDS = 7200;
+/**
+* The era covering `slot`: the last summary that has already started.
+* Summaries arrive oldest-first, so this walks forward while the next
+* era's start is still at or below the slot.
+*/
+const eraSummaryAtSlot = (eraSummaries, slot) => {
+	let index = 0;
+	while (index + 1 < eraSummaries.length && eraSummaries[index + 1].start.slot <= slot) index++;
+	return eraSummaries[index];
+};
+const secondsToSlots = (seconds, slotLengthMs) => Math.ceil(seconds * 1e3 / slotLengthMs);
+/**
+* Convert a tip-relative duration into the absolute slots a Cardano
+* validity interval needs.
+*
+* @throws If the era summaries are missing/unusable, or the requested
+*   window is not a positive, coherent interval.
+*/
+const resolveValidityInterval = ({ tipSlot, eraSummaries, validitySeconds = DEFAULT_VALIDITY_SECONDS, validityStartSeconds }) => {
+	if (eraSummaries.length === 0) throw new Error("Cannot resolve a validity interval: no Cardano era summaries available");
+	if (!Number.isFinite(validitySeconds) || validitySeconds <= 0) throw new Error(`Validity window must be a positive number of seconds, got ${validitySeconds}`);
+	const { slotLength } = eraSummaryAtSlot(eraSummaries, tipSlot).parameters;
+	if (!Number.isFinite(slotLength) || slotLength <= 0) throw new Error(`Era summary reports an unusable slot length: ${slotLength}`);
+	const invalidHereafter = _laceio_cardano_core.Cardano.Slot(tipSlot + secondsToSlots(validitySeconds, slotLength));
+	if (validityStartSeconds === void 0) return { invalidHereafter };
+	if (!Number.isFinite(validityStartSeconds) || validityStartSeconds < 0) throw new Error(`Validity start must be a non-negative number of seconds, got ${validityStartSeconds}`);
+	const invalidBefore = _laceio_cardano_core.Cardano.Slot(tipSlot + secondsToSlots(validityStartSeconds, slotLength));
+	if (invalidBefore >= invalidHereafter) throw new Error(`Validity window is empty: start slot ${invalidBefore} is not before end slot ${invalidHereafter}`);
+	return {
+		invalidBefore,
+		invalidHereafter
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/build-composer-tx.ts
+/** Failure with a code the side-effect maps to actionable copy. */
+const fail = (message, code) => Object.assign(new Error(message), { code });
+const utxoRefKey = (txIn) => `${txIn.txId}#${txIn.index}`;
+/**
+* An address from the request, as the SDK's payment address.
+*
+* The SDK's own constructor throws an UNCODED `InvalidStringError`, which would
+* reach the side-effect as a build fault rather than as the request mistake it
+* is — a bech32 the user mistyped would then read as "we couldn't build your
+* transaction" instead of "check what you entered".
+*
+* @param what - names the address in the message, since a request may carry
+* several and the failure has to say which one is unusable.
+*/
+const toPaymentAddress = (value, what) => {
+	try {
+		return _laceio_cardano_core.Cardano.PaymentAddress(value);
+	} catch {
+		throw fail(`${what} is not a Cardano address: "${value}"`, "invalid-address");
+	}
+};
+/**
+* Quantities cross the slice boundary as decimal strings, so a malformed
+* one is a request error rather than a programming error — parse it into
+* a coded failure instead of letting `BigInt` throw an uncoded SyntaxError.
+*/
+const toQuantity = (value, what) => {
+	if (!/^-?\d+$/.test(value)) throw fail(`${what} is not a whole number: "${value}"`, "invalid-output");
+	return BigInt(value);
+};
+const toValue = (output) => {
+	const coins = toQuantity(output.lovelace, `Lovelace amount for the output to ${output.address}`);
+	if (coins < 0n) throw fail(`Output to ${output.address} requests a negative amount of lovelace`, "invalid-output");
+	if (!output.assets || output.assets.length === 0) return { coins };
+	const assets = /* @__PURE__ */ new Map();
+	for (const asset of output.assets) {
+		const quantity = toQuantity(asset.quantity, `Quantity for asset ${asset.assetId}`);
+		if (quantity <= 0n) throw fail(`Asset ${asset.assetId} requests a non-positive quantity`, "invalid-output");
+		const assetId = asset.assetId;
+		assets.set(assetId, (assets.get(assetId) ?? 0n) + quantity);
+	}
+	return {
+		coins,
+		assets
+	};
+};
+/**
+* Raise the output's lovelace to the protocol minimum for its size when
+* the request is below it. An assets-only output can therefore ask for
+* `'0'` and still be spendable.
+*/
+const withMinimumCoin = (address, value, params) => {
+	if ((0, _laceio_cardano_tx_construction.tokenBundleSizeExceedsLimit)(params.maxValueSize)(value.assets)) throw fail(`Output to ${address} exceeds the maximum token bundle size`, "invalid-output");
+	const minimumCoin = BigInt((0, _laceio_cardano_tx_construction.computeMinimumCoinQuantity)(params.coinsPerUtxoByte)({
+		address,
+		value
+	}));
+	return value.coins >= minimumCoin ? value : {
+		...value,
+		coins: minimumCoin
+	};
+};
+const parseMetadata = (request) => {
+	if (!request.metadata || request.metadata.length === 0) return void 0;
+	const blob = /* @__PURE__ */ new Map();
+	for (const entry of request.metadata) {
+		if (!/^\d+$/.test(entry.label)) throw fail(`Metadata label "${entry.label}" is not a non-negative integer`, "invalid-metadata");
+		let parsed;
+		try {
+			parsed = JSON.parse(entry.json);
+		} catch (error) {
+			throw fail(`Metadata for label ${entry.label} is not valid JSON: ${error.message}`, "invalid-metadata");
+		}
+		blob.set(BigInt(entry.label), _laceio_cardano_core.metadatum.jsonToMetadatum(parsed));
+	}
+	return blob;
+};
+const resolveSelectedInputs = (request, spendableUtxos) => {
+	if (!request.selectedInputs || request.selectedInputs.length === 0) return [];
+	const byRef = new Map(spendableUtxos.map((utxo) => [utxoRefKey(utxo[0]), utxo]));
+	return request.selectedInputs.map((ref) => {
+		const utxo = byRef.get(`${ref.txId}#${ref.index}`);
+		if (!utxo) throw fail(`Selected input ${ref.txId}#${ref.index} is not among the account's spendable UTxOs`, "input-unavailable");
+		return utxo;
+	});
+};
+/**
+* The balancer's own failure type is the only signal that the account cannot
+* cover what was asked for — an unaffordable amount is a request mistake, not a
+* build fault, and only the coded form reaches the copy that says so.
+*
+* Tagged rather than replaced: the reported name and message stay the
+* balancer's, which is what names the shortfall for a diagnostic.
+*/
+const codeInputSelectionFailure = async (build) => {
+	try {
+		return await build;
+	} catch (error) {
+		if (error instanceof require_TransactionBuilder.InputSelectionError) throw Object.assign(error, { code: "insufficient-funds" });
+		throw error;
+	}
+};
+const buildComposerTx = async ({ request, changeAddress, networkMagic, protocolParameters, spendableUtxos, tipSlot, eraSummaries }) => {
+	if (request.outputs.length === 0) throw fail("A composed transaction needs at least one output", "no-outputs");
+	if (spendableUtxos.length === 0) throw fail("The account has no spendable UTxOs to fund this transaction", "no-utxos");
+	const validityInterval = resolveValidityInterval({
+		tipSlot,
+		eraSummaries,
+		validitySeconds: request.validitySeconds,
+		validityStartSeconds: request.validityStartSeconds
+	});
+	const selectedInputs = resolveSelectedInputs(request, spendableUtxos);
+	const selectedReferences = new Set(selectedInputs.map((utxo) => utxoRefKey(utxo[0])));
+	const coverUtxos = spendableUtxos.filter((utxo) => !selectedReferences.has(utxoRefKey(utxo[0])));
+	const builder = new require_TransactionBuilder.TransactionBuilder(networkMagic, protocolParameters).setChangeAddress(changeAddress).setUnspentOutputs(coverUtxos).setValidityInterval(validityInterval);
+	for (const utxo of selectedInputs) builder.addInput(utxo);
+	const metadataBlob = parseMetadata(request);
+	if (metadataBlob) for (const [label, value] of metadataBlob) builder.setMetadata(label, value);
+	for (const output of request.outputs) {
+		const address = toPaymentAddress(output.address, "The address of an output");
+		builder.addOutput({
+			address,
+			value: withMinimumCoin(address, toValue(output), protocolParameters)
+		});
+	}
+	const transaction = await codeInputSelectionFailure(builder.build());
+	return {
+		cbor: transaction.toCbor(),
+		txId: transaction.getId(),
+		fee: transaction.toCore().body.fee
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer/build-side-effect.ts
+const GENERIC_BUILD_ERROR_KEYS$1 = {
+	title: "v2.composer.build.error.title",
+	subtitle: "v2.composer.build.error.subtitle"
+};
+const BUILD_ERROR_KEYS_BY_CODE$1 = {
+	"no-utxos": {
+		title: "v2.composer.build.error.no-utxos.title",
+		subtitle: "v2.composer.build.error.no-utxos.subtitle"
+	},
+	"no-outputs": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-output": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-metadata": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"input-unavailable": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"invalid-address": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	},
+	"insufficient-funds": {
+		title: "v2.composer.build.error.invalid-request.title",
+		subtitle: "v2.composer.build.error.invalid-request.subtitle"
+	}
+};
+const failure$1 = (error, code) => ({
+	success: false,
+	error: {
+		name: error.name,
+		message: error.message
+	},
+	errorTranslationKeys: (code ? BUILD_ERROR_KEYS_BY_CODE$1[code] : void 0) ?? GENERIC_BUILD_ERROR_KEYS$1
+});
+const buildComposition = async (state, stateObservables, dependencies) => {
+	try {
+		const { accountId, request } = state;
+		const cardano = dependencies.txExecutorCardano;
+		const cardanoContext = stateObservables.cardanoContext;
+		const [networkMagic, protocolParameters, tip, eraSummaries, accountUtxos, unspendableUtxos, addresses] = await Promise.all([
+			(0, rxjs.firstValueFrom)(cardano.cardanoNetworkMagic$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectProtocolParameters$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectTip$),
+			(0, rxjs.firstValueFrom)(cardanoContext.selectEraSummaries$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUtxos$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUnspendableUtxos$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAddresses$)
+		]);
+		if (networkMagic === void 0) throw new Error("Cardano network magic not available");
+		if (!protocolParameters) throw new Error("Cardano protocol parameters not available");
+		if (!tip) throw new Error("Cardano chain tip not available");
+		if (!eraSummaries) throw new Error("Cardano era summaries not available");
+		require_account_guards.refuseExtensionAccount(accountId, addresses);
+		const primary = addresses.filter((address) => address.accountId === accountId && address.blockchainName === "Cardano")[0];
+		if (!primary) throw new Error("No Cardano addresses found for account");
+		const result = await buildComposerTx({
+			request,
+			changeAddress: toPaymentAddress(request.changeAddress ?? primary.address, "The change address"),
+			networkMagic,
+			protocolParameters,
+			spendableUtxos: require_util.filterSpendableUtxos(accountUtxos[accountId] ?? [], unspendableUtxos[accountId] ?? []),
+			tipSlot: Number(tip.slot),
+			eraSummaries
+		});
+		return {
+			success: true,
+			serializedTx: result.cbor,
+			txId: result.txId,
+			fees: [{
+				tokenId: require_const.LOVELACE_TOKEN_ID,
+				amount: require_bignum_vo.BigNumber(result.fee)
+			}]
+		};
+	} catch (error) {
+		return failure$1(error instanceof Error ? error : new Error(String(error)), error.code);
+	}
+};
+const makeComposerBuilding = () => (_, stateObservables, dependencies) => require_first_state_of_status.firstStateOfStatus(stateObservables.composerFlow.selectState$, "Building").pipe((0, rxjs.switchMap)((state) => (0, rxjs.from)(buildComposition(state, stateObservables, dependencies)).pipe((0, rxjs.map)((result) => dependencies.actions.composerFlow.buildCompleted({
+	accountId: state.accountId,
+	result
+})))));
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/composer-flow-side-effects.ts
+const composerFlowSideEffects = [makeComposerBuilding()];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/dependencies.ts
+const initializeDependencies = async (_, { logger }) => ({ cardanoInMemorySigning: { signTransaction: (props) => (0, rxjs.forkJoin)([(0, rxjs.from)(_laceio_cardano_crypto.SodiumBip32Ed25519.create()), (0, rxjs.from)(_laceio_cardano_key_management.util.createTxInKeyPathMap(props.tx.body().toCore(), props.knownAddresses, require_util.createInputResolver(props.utxo)))]).pipe((0, rxjs.mergeMap)(([bip32Ed25519, txInKeyPathMap]) => {
+	const encryptedRootPrivateKeyBytes = require_bytes_vo.ByteArray.fromHex(props.encryptedRootPrivateKey);
+	return (0, rxjs.from)(new _laceio_cardano_key_management.InMemoryKeyAgent({
+		accountIndex: props.accountIndex,
+		chainId: props.chainId,
+		encryptedRootPrivateKeyBytes: [...encryptedRootPrivateKeyBytes],
+		extendedAccountPublicKey: props.extendedAccountPublicKey,
+		getPassphrase: async () => props.authSecret,
+		purpose: _laceio_cardano_key_management.KeyPurpose.STANDARD
+	}, {
+		bip32Ed25519,
+		logger,
+		rootPrivateKeyEncryption: require_secret_box.SecretBox.isSealed(encryptedRootPrivateKeyBytes) ? {
+			encrypt: require_secret_box.SecretBox.seal,
+			decrypt: require_secret_box.SecretBox.open
+		} : void 0
+	}).signTransaction(props.tx.body(), {
+		knownAddresses: props.knownAddresses,
+		txInKeyPathMap,
+		scripts: props.tx.toCore().witness.scripts
+	})).pipe((0, rxjs.map)((signatures) => {
+		const witnessSet = props.tx.witnessSet();
+		require_apply_vkey_witnesses.applyVkeyWitnesses(witnessSet, signatures);
+		props.tx.setWitnessSet(witnessSet);
+		return require_asyncoption.Ok(props.tx);
+	}));
+}), (0, rxjs.catchError)((error) => (0, rxjs.of)(require_asyncoption.Err({
+	code: "SIGNING_FAILED",
+	message: error.message
+})))) } });
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/constants.ts
+const LOVELACE_FOR_REGISTRATION = 1586080n;
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/errors.ts
+const Ok = (value) => ({
+	ok: true,
+	value
+});
+const Err = (error) => ({
+	ok: false,
+	error
+});
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/value-objects/network-id.vo.ts
+const CardanoDustNetwork = {
+	mainnet: "mainnet",
+	testnet: "testnet",
+	fromNetworkMagic: (networkMagic) => networkMagic === 764824073 ? CardanoDustNetwork.mainnet : CardanoDustNetwork.testnet,
+	toNetworkId: (network) => network === CardanoDustNetwork.mainnet ? 1 : 0
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/cnight-asset.ts
+const TESTNET_CNIGHT_POLICY_ID = _laceio_cardano_core.Cardano.PolicyId("d2dbff622e509dda256fedbd31ef6e9fd98ed49ad91d5c0e07f68af1");
+const TESTNET_CNIGHT_ASSET_NAME = _laceio_cardano_core.Cardano.AssetName("");
+const MAINNET_CNIGHT_POLICY_ID = _laceio_cardano_core.Cardano.PolicyId("0691b2fecca1ac4f53cb6dfb00b7013e561d1f34403b957cbb5af1fa");
+/** "NIGHT" in hex — the mainnet cNIGHT token is named NIGHT. */
+const MAINNET_CNIGHT_ASSET_NAME = _laceio_cardano_core.Cardano.AssetName("4e49474854");
+const getCnightAssetId = (network) => {
+	const policyId = network === CardanoDustNetwork.mainnet ? MAINNET_CNIGHT_POLICY_ID : TESTNET_CNIGHT_POLICY_ID;
+	const assetName = network === CardanoDustNetwork.mainnet ? MAINNET_CNIGHT_ASSET_NAME : TESTNET_CNIGHT_ASSET_NAME;
+	return _laceio_cardano_core.Cardano.AssetId.fromParts(policyId, assetName);
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/scripts/mainnet.ts
+const CNIGHT_GENERATES_DUST_MAINNET_CBOR = "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";
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/scripts/testnet.ts
+const CNIGHT_GENERATES_DUST_TESTNET_CBOR = "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";
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/scripts/index.ts
+const cborWrapHexBytes = (payloadHex) => {
+	const lengthBytes = payloadHex.length / 2;
+	let header;
+	if (lengthBytes < 24) header = (64 | lengthBytes).toString(16).padStart(2, "0");
+	else if (lengthBytes < 256) header = "58" + lengthBytes.toString(16).padStart(2, "0");
+	else if (lengthBytes < 65536) header = "59" + lengthBytes.toString(16).padStart(4, "0");
+	else if (lengthBytes < 4294967296) header = "5a" + lengthBytes.toString(16).padStart(8, "0");
+	else throw new Error(`script too large to CBOR-wrap (${lengthBytes} bytes)`);
+	return header + payloadHex;
+};
+const getDustGeneratorScriptCbor = (network) => (0, _laceio_cardano_util.HexBlob)(cborWrapHexBytes(network === CardanoDustNetwork.mainnet ? CNIGHT_GENERATES_DUST_MAINNET_CBOR : CNIGHT_GENERATES_DUST_TESTNET_CBOR));
+const getDustGeneratorPlutusV3Script = (network) => _laceio_cardano_core.Serialization.PlutusV3Script.fromCbor(getDustGeneratorScriptCbor(network));
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/plutus/datum.ts
+const encodeCWallet = (cWallet) => {
+	const fields = new _laceio_cardano_core.Serialization.PlutusList();
+	const hashBytes = cWallet.kind === "verificationKey" ? cWallet.stakeKeyHash : cWallet.scriptHash;
+	fields.add(_laceio_cardano_core.Serialization.PlutusData.newBytes(hashBytes));
+	const alternative = cWallet.kind === "verificationKey" ? 0n : 1n;
+	return _laceio_cardano_core.Serialization.PlutusData.newConstrPlutusData(new _laceio_cardano_core.Serialization.ConstrPlutusData(alternative, fields));
+};
+const encodeDustMappingDatum = (value) => {
+	const fields = new _laceio_cardano_core.Serialization.PlutusList();
+	fields.add(encodeCWallet(value.cWallet));
+	fields.add(_laceio_cardano_core.Serialization.PlutusData.newBytes(value.dustAddress));
+	return _laceio_cardano_core.Serialization.PlutusData.newConstrPlutusData(new _laceio_cardano_core.Serialization.ConstrPlutusData(0n, fields));
+};
+const dustMappingDatumToCbor = (value) => encodeDustMappingDatum(value).toCbor();
+var CardanoStakeKeyHashError = class extends Error {
+	code;
+	constructor(message) {
+		super(message);
+		this.name = "CardanoStakeKeyHashError";
+		this.code = "invalid-length";
+	}
+};
+const CardanoStakeKeyHash = (bytes) => {
+	if (bytes.length !== 28) throw new CardanoStakeKeyHashError(`CardanoStakeKeyHash expects 28 bytes, got ${bytes.length}`);
+	return bytes;
+};
+CardanoStakeKeyHash.toHex = (hash) => Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
+CardanoStakeKeyHash.fromHex = (hex) => {
+	const normalised = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (normalised.length !== 56) throw new CardanoStakeKeyHashError(`CardanoStakeKeyHash hex expects 56 chars, got ${normalised.length}`);
+	if (!/^[0-9a-fA-F]+$/.test(normalised)) throw new CardanoStakeKeyHashError(`CardanoStakeKeyHash hex contains non-hex characters: ${hex}`);
+	const bytes = new Uint8Array(28);
+	for (let index = 0; index < bytes.length; index++) bytes[index] = parseInt(normalised.slice(index * 2, index * 2 + 2), 16);
+	return CardanoStakeKeyHash(bytes);
+};
+var MidnightCoinPubkeyError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "MidnightCoinPubkeyError";
+		this.code = code;
+	}
+};
+const MidnightCoinPubkey = (bytes) => {
+	if (bytes.length > 33) throw new MidnightCoinPubkeyError("invalid-length", `MidnightCoinPubkey accepts at most 33 bytes, got ${bytes.length}`);
+	return bytes;
+};
+MidnightCoinPubkey.toHex = (pubkey) => Array.from(pubkey).map((b) => b.toString(16).padStart(2, "0")).join("");
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/plutus/datum-decode.ts
+const decodeDustMappingDatum = (cbor) => {
+	let data;
+	try {
+		data = _laceio_cardano_core.Serialization.PlutusData.fromCbor((0, _laceio_cardano_util.HexBlob)(cbor.toString()));
+	} catch {
+		return;
+	}
+	const outer = data.asConstrPlutusData();
+	if (!outer || outer.getAlternative() !== 0n) return void 0;
+	const fields = outer.getData();
+	if (fields.getLength() !== 2) return void 0;
+	const cWalletData = fields.get(0).asConstrPlutusData();
+	if (!cWalletData) return void 0;
+	const cWalletFields = cWalletData.getData();
+	if (cWalletFields.getLength() !== 1) return void 0;
+	const credBytes = cWalletFields.get(0).asBoundedBytes();
+	if (!credBytes || credBytes.length !== 28) return void 0;
+	let cWallet;
+	if (cWalletData.getAlternative() === 0n) cWallet = {
+		kind: "verificationKey",
+		stakeKeyHash: CardanoStakeKeyHash(credBytes)
+	};
+	else if (cWalletData.getAlternative() === 1n) cWallet = {
+		kind: "script",
+		scriptHash: credBytes
+	};
+	else return;
+	const dustBytes = fields.get(1).asBoundedBytes();
+	if (!dustBytes || dustBytes.length > 33) return void 0;
+	let dustAddress;
+	try {
+		dustAddress = MidnightCoinPubkey(dustBytes);
+	} catch {
+		return;
+	}
+	return {
+		cWallet,
+		dustAddress
+	};
+};
+/**
+* True when the datum's c_wallet VerificationKey hash matches the
+* given stake-key-hash. Used by the designation-detection hook to
+* find the active account's registration UTxO among the script
+* address's outputs.
+*/
+const datumMatchesStakeKey = (datum, stakeKeyHash) => {
+	if (datum.cWallet.kind !== "verificationKey") return false;
+	if (datum.cWallet.stakeKeyHash.length !== stakeKeyHash.length) return false;
+	for (let index = 0; index < stakeKeyHash.length; index++) if (datum.cWallet.stakeKeyHash[index] !== stakeKeyHash[index]) return false;
+	return true;
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/plutus/redeemer.ts
+const emptyConstr = (alternative) => _laceio_cardano_core.Serialization.PlutusData.newConstrPlutusData(new _laceio_cardano_core.Serialization.ConstrPlutusData(alternative, new _laceio_cardano_core.Serialization.PlutusList()));
+const dustActionCreate = () => emptyConstr(0n);
+const dustActionBurn = () => emptyConstr(1n);
+const dataVoid = () => emptyConstr(0n);
+const dustActionCreateCbor = () => dustActionCreate().toCbor();
+const dustActionBurnCbor = () => dustActionBurn().toCbor();
+const dataVoidCbor = () => dataVoid().toCbor();
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/plutus/script-address.ts
+const getDustGeneratorScriptHash = (network) => getDustGeneratorPlutusV3Script(network).hash();
+const getDustGeneratorPaymentAddress = (network) => {
+	const scriptHash = getDustGeneratorScriptHash(network);
+	const networkId = CardanoDustNetwork.toNetworkId(network);
+	const credential = {
+		type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+		hash: scriptHash
+	};
+	return _laceio_cardano_core.Cardano.EnterpriseAddress.fromCredentials(networkId, credential).toAddress().toBech32();
+};
+const getDustGeneratorRewardAccount = (network) => {
+	const scriptHash = getDustGeneratorScriptHash(network);
+	const networkId = CardanoDustNetwork.toNetworkId(network);
+	const credential = {
+		type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+		hash: scriptHash
+	};
+	return _laceio_cardano_core.Cardano.RewardAddress.fromCredentials(networkId, credential).toAddress().toBech32();
+};
+const getDustMappingNftPolicyId = (network) => _laceio_cardano_core.Cardano.PolicyId(getDustGeneratorScriptHash(network));
+/**
+* The DUST-mapping NFT minted by the validator has policy = script
+* hash and asset_name = empty bytestring. This is the on-chain
+* identifier callers query for to determine "is this account
+* designated?".
+*/
+const getDustMappingNftAssetId = (network) => _laceio_cardano_core.Cardano.AssetId.fromParts(getDustMappingNftPolicyId(network), _laceio_cardano_core.Cardano.AssetName(""));
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/dust-address-decode.ts
+const COMPACT_MODE_1_MIN = 64n;
+const COMPACT_MODE_2_MIN = 1n << 14n;
+const COMPACT_MODE_3_MIN = 1n << 30n;
+const BLS12_381_SCALAR_MODULUS = BigInt("0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001");
+const leBytesToScalar = (bytes) => {
+	let scalar = 0n;
+	for (let index = bytes.length - 1; index >= 0; index--) scalar = scalar << 8n | BigInt(bytes[index]);
+	return scalar;
+};
+/**
+* Why `payload` is not the canonical (minimal) SCALE-compact encoding of an
+* in-field BLS12-381 scalar, or `undefined` when it is.
+*
+* Minimality is ours to enforce: neither the Midnight SDK codec nor the
+* midnight-node pallet checks it, and a padded encoding's claimability is
+* unknown — so a non-canonical target must never reach the datum.
+*
+* Returns a reason instead of throwing so each boundary can surface it in its
+* own channel: this file throws at the address-string input boundary, the
+* blueprint builder returns `Err` at the datum-write boundary.
+*/
+const canonicalDustPayloadDefect = (payload) => {
+	if (payload.length === 0) return "empty payload";
+	const header = payload[0];
+	const mode = header & 3;
+	let scalar;
+	if (mode === 0) {
+		if (payload.length !== 1) return `single-byte mode declared, ${payload.length}-byte payload`;
+		scalar = BigInt(header >> 2);
+	} else if (mode === 1) {
+		if (payload.length !== 2) return `two-byte mode declared, ${payload.length}-byte payload`;
+		scalar = BigInt(header >> 2) + (BigInt(payload[1]) << 6n);
+		if (scalar < COMPACT_MODE_1_MIN) return `${scalar} fits a shorter mode`;
+	} else if (mode === 2) {
+		if (payload.length !== 4) return `four-byte mode declared, ${payload.length}-byte payload`;
+		scalar = BigInt(header >> 2) + (BigInt(payload[1]) << 6n) + (BigInt(payload[2]) << 14n) + (BigInt(payload[3]) << 22n);
+		if (scalar < COMPACT_MODE_2_MIN) return `${scalar} fits a shorter mode`;
+	} else {
+		const declaredScalarBytes = (header >> 2) + 4;
+		if (payload.length !== declaredScalarBytes + 1) return `${declaredScalarBytes}-byte scalar declared, ${payload.length - 1} bytes present`;
+		if (payload[payload.length - 1] === 0) return "most significant scalar byte is zero";
+		scalar = leBytesToScalar(payload.subarray(1));
+		if (scalar < COMPACT_MODE_3_MIN) return `${scalar} fits a shorter mode`;
+	}
+	return scalar >= BLS12_381_SCALAR_MODULUS ? "scalar is outside the BLS12-381 field" : void 0;
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/builders/build-night-designation-tx.ts
+const NFT_ASSET_NAME = _laceio_cardano_core.Cardano.AssetName("");
+const computeScriptOutputLovelace = ({ scriptAddress, nftAsset, datumCbor, coinsPerUtxoByte }) => {
+	const datum = _laceio_cardano_core.Serialization.PlutusData.fromCbor(datumCbor).toCore();
+	const representativeOutput = {
+		address: scriptAddress,
+		value: {
+			coins: LOVELACE_FOR_REGISTRATION,
+			assets: new Map([[nftAsset, 1n]])
+		},
+		datum
+	};
+	const minCoin = (0, _laceio_cardano_tx_construction.computeMinimumCoinQuantity)(coinsPerUtxoByte)(representativeOutput);
+	return minCoin < 1586080n ? LOVELACE_FOR_REGISTRATION : minCoin;
+};
+const dustPubkeyError = (dustPubkey) => {
+	if (dustPubkey.length > 33) return {
+		code: "dust-address-too-long",
+		message: `dust_address exceeds the on-chain 33-byte limit enforced by the validator.`,
+		actualBytes: dustPubkey.length,
+		maxBytes: 33
+	};
+	const defect = canonicalDustPayloadDefect(dustPubkey);
+	return defect === void 0 ? void 0 : {
+		code: "invalid-dust-payload",
+		message: `dust_address is not a canonical SCALE-compact payload (${defect}).`
+	};
+};
+const buildNightDesignationTxBlueprint = (params) => {
+	if (params.cnightUtxos.length === 0) return Err({
+		code: "no-cnight",
+		message: "No cNIGHT in this account."
+	});
+	const scriptAddress = getDustGeneratorPaymentAddress(params.network);
+	const scriptRewardAccount = getDustGeneratorRewardAccount(params.network);
+	const nftPolicyId = getDustMappingNftPolicyId(params.network);
+	const nftAsset = getDustMappingNftAssetId(params.network);
+	const scriptCbor = getDustGeneratorScriptCbor(params.network);
+	const requiredSigners = {
+		paymentKeyHash: params.paymentKeyHash,
+		stakeKeyHash: params.stakeKeyHash
+	};
+	if (params.action.kind === "register") {
+		const dustError = dustPubkeyError(params.action.dustPubkey);
+		if (dustError) return Err(dustError);
+		const datumCbor = dustMappingDatumToCbor({
+			cWallet: {
+				kind: "verificationKey",
+				stakeKeyHash: params.stakeKeyHash
+			},
+			dustAddress: params.action.dustPubkey
+		});
+		return Ok({
+			network: params.network,
+			scriptAddress,
+			scriptRewardAccount,
+			dustMappingNftAssetId: nftAsset,
+			forcedInputs: params.cnightUtxos,
+			scriptOutput: {
+				address: scriptAddress,
+				lovelace: computeScriptOutputLovelace({
+					scriptAddress,
+					nftAsset,
+					datumCbor,
+					coinsPerUtxoByte: params.coinsPerUtxoByte
+				}),
+				nftAsset,
+				nftQuantity: 1n,
+				inlineDatumCbor: datumCbor
+			},
+			mint: {
+				policyId: nftPolicyId,
+				assetName: NFT_ASSET_NAME,
+				quantity: 1n,
+				redeemerCbor: dustActionCreateCbor()
+			},
+			spendRedeemer: null,
+			withdrawal: null,
+			requiredSigners,
+			scriptCbor
+		});
+	}
+	if (params.action.kind === "update") {
+		const dustError = dustPubkeyError(params.action.dustPubkey);
+		if (dustError) return Err(dustError);
+		const datumCbor = dustMappingDatumToCbor({
+			cWallet: {
+				kind: "verificationKey",
+				stakeKeyHash: params.stakeKeyHash
+			},
+			dustAddress: params.action.dustPubkey
+		});
+		return Ok({
+			network: params.network,
+			scriptAddress,
+			scriptRewardAccount,
+			dustMappingNftAssetId: nftAsset,
+			forcedInputs: [...params.cnightUtxos, params.action.registrationUtxo],
+			scriptOutput: {
+				address: scriptAddress,
+				lovelace: computeScriptOutputLovelace({
+					scriptAddress,
+					nftAsset,
+					datumCbor,
+					coinsPerUtxoByte: params.coinsPerUtxoByte
+				}),
+				nftAsset,
+				nftQuantity: 1n,
+				inlineDatumCbor: datumCbor
+			},
+			mint: null,
+			spendRedeemer: {
+				registrationUtxo: params.action.registrationUtxo,
+				redeemerCbor: dataVoidCbor()
+			},
+			withdrawal: {
+				rewardAccount: scriptRewardAccount,
+				lovelace: params.action.scriptWithdrawableLovelace,
+				redeemerCbor: dataVoidCbor()
+			},
+			requiredSigners,
+			scriptCbor
+		});
+	}
+	return Ok({
+		network: params.network,
+		scriptAddress,
+		scriptRewardAccount,
+		dustMappingNftAssetId: nftAsset,
+		forcedInputs: [...params.cnightUtxos, params.action.registrationUtxo],
+		scriptOutput: null,
+		mint: {
+			policyId: nftPolicyId,
+			assetName: NFT_ASSET_NAME,
+			quantity: -1n,
+			redeemerCbor: dustActionBurnCbor()
+		},
+		spendRedeemer: {
+			registrationUtxo: params.action.registrationUtxo,
+			redeemerCbor: dataVoidCbor()
+		},
+		withdrawal: null,
+		requiredSigners,
+		scriptCbor
+	});
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/value-objects/cardano-payment-key-hash.vo.ts
+var CardanoPaymentKeyHashError = class extends Error {
+	code;
+	constructor(message) {
+		super(message);
+		this.name = "CardanoPaymentKeyHashError";
+		this.code = "invalid-length";
+	}
+};
+const CardanoPaymentKeyHash = (bytes) => {
+	if (bytes.length !== 28) throw new CardanoPaymentKeyHashError(`CardanoPaymentKeyHash expects 28 bytes, got ${bytes.length}`);
+	return bytes;
+};
+CardanoPaymentKeyHash.toHex = (hash) => Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
+CardanoPaymentKeyHash.fromHex = (hex) => {
+	const normalised = hex.startsWith("0x") ? hex.slice(2) : hex;
+	if (normalised.length !== 56) throw new CardanoPaymentKeyHashError(`CardanoPaymentKeyHash hex expects 56 chars, got ${normalised.length}`);
+	if (!/^[0-9a-fA-F]+$/.test(normalised)) throw new CardanoPaymentKeyHashError(`CardanoPaymentKeyHash hex contains non-hex characters: ${hex}`);
+	const bytes = new Uint8Array(28);
+	for (let index = 0; index < bytes.length; index++) bytes[index] = parseInt(normalised.slice(index * 2, index * 2 + 2), 16);
+	return CardanoPaymentKeyHash(bytes);
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/account-key-hashes.ts
+const hexToBytes = (hex) => {
+	if (hex.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(hex)) throw new Error(`Invalid hex string: "${hex}"`);
+	return Uint8Array.from((hex.match(/.{1,2}/g) ?? []).map((byte) => parseInt(byte, 16)));
+};
+/**
+* Read the account's credentials off its primary Cardano address.
+*
+* Throws when the account has no Cardano address or its address carries no
+* stake credential — an enterprise address cannot satisfy the validator's
+* `check_auth`, so there is no designation to build or index for it.
+*/
+const resolveAccountKeyHashes = (addresses, accountId) => {
+	const primary = addresses.find((address) => address.accountId === accountId && address.blockchainName === "Cardano");
+	if (!primary) throw new Error("No Cardano addresses found for account");
+	const baseAddress = _laceio_cardano_core.Cardano.Address.fromString(primary.address)?.asBase();
+	if (!baseAddress) throw new Error("Account address is not a base (payment+stake) address");
+	return {
+		primaryAddress: _laceio_cardano_core.Cardano.PaymentAddress(primary.address),
+		paymentKeyHash: CardanoPaymentKeyHash(hexToBytes(baseAddress.getPaymentCredential().hash)),
+		stakeKeyHash: CardanoStakeKeyHash(hexToBytes(baseAddress.getStakeCredential().hash))
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/build-night-designation-tx.ts
+const toPlutusData = (cbor) => _laceio_cardano_core.Serialization.PlutusData.fromCbor(cbor).toCore();
+const toKeyHashHex = (bytes) => Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+const sameRef = (a, b) => a.txId === b.txId && a.index === b.index;
+const buildNightDesignationTx = async (params, dependencies) => {
+	const blueprintResult = buildNightDesignationTxBlueprint({
+		network: params.network,
+		cnightUtxos: params.cnightUtxos,
+		stakeKeyHash: params.stakeKeyHash,
+		paymentKeyHash: params.paymentKeyHash,
+		action: params.action,
+		coinsPerUtxoByte: params.protocolParameters.coinsPerUtxoByte
+	});
+	if (!blueprintResult.ok) return blueprintResult;
+	const blueprint = blueprintResult.value;
+	const builder = new require_TransactionBuilder.TransactionBuilder(dependencies.networkMagic, params.protocolParameters);
+	builder.setChangeAddress(params.changeAddress).setUnspentOutputs(dependencies.coverUtxos).setCollateralUtxos(dependencies.collateralUtxos).setCollateralChangeAddress(params.changeAddress).setPlutusContext({
+		costModels: params.protocolParameters.costModels,
+		txEvaluator: dependencies.txEvaluator,
+		inputResolver: dependencies.inputResolver
+	});
+	builder.attachScript({
+		__type: _laceio_cardano_core.Cardano.ScriptType.Plutus,
+		version: _laceio_cardano_core.Cardano.PlutusLanguageVersion.V3,
+		bytes: _laceio_cardano_core.Serialization.PlutusV3Script.fromCbor(blueprint.scriptCbor).rawBytes()
+	});
+	const registrationRef = blueprint.spendRedeemer?.registrationUtxo[0];
+	for (const utxo of blueprint.forcedInputs) if (blueprint.spendRedeemer && registrationRef && sameRef(utxo[0], registrationRef)) builder.addInput(utxo, { redeemer: toPlutusData(blueprint.spendRedeemer.redeemerCbor) });
+	else builder.addInput(utxo);
+	if (blueprint.mint) {
+		const assetId = _laceio_cardano_core.Cardano.AssetId.fromParts(blueprint.mint.policyId, blueprint.mint.assetName);
+		builder.mintAssets(new Map([[assetId, blueprint.mint.quantity]]), toPlutusData(blueprint.mint.redeemerCbor));
+	}
+	if (blueprint.scriptOutput) builder.addOutput({
+		address: blueprint.scriptOutput.address,
+		value: {
+			coins: blueprint.scriptOutput.lovelace,
+			assets: new Map([[blueprint.scriptOutput.nftAsset, blueprint.scriptOutput.nftQuantity]])
+		},
+		datum: toPlutusData(blueprint.scriptOutput.inlineDatumCbor)
+	});
+	if (blueprint.withdrawal) builder.addScriptWithdrawal(blueprint.withdrawal.rewardAccount, blueprint.withdrawal.lovelace, toPlutusData(blueprint.withdrawal.redeemerCbor));
+	builder.addRequiredSigner(toKeyHashHex(blueprint.requiredSigners.paymentKeyHash));
+	builder.addRequiredSigner(toKeyHashHex(blueprint.requiredSigners.stakeKeyHash));
+	builder.setValidityInterval({ invalidHereafter: params.ttlSlot });
+	const transaction = await builder.build();
+	const cbor = transaction.toCbor();
+	const fee = transaction.body().fee();
+	return Ok({
+		cbor,
+		txId: transaction.getId(),
+		fee
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/bounded-ex-units-evaluator.ts
+const BOUNDED_EX_UNITS_PER_REDEEMER = {
+	memory: 2e6,
+	steps: 7e8
+};
+/**
+* A {@link TxEvaluator} that returns a fixed, conservative budget for
+* every redeemer in the transaction (no network round-trip).
+*/
+const boundedExUnitsEvaluator = { evaluate: async (tx) => (tx.witness.redeemers ?? []).map((redeemer) => ({
+	purpose: redeemer.purpose,
+	index: redeemer.index,
+	budget: BOUNDED_EX_UNITS_PER_REDEEMER
+})) };
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/provider-ex-units-evaluator.ts
+/**
+* Padding on every evaluated budget. The builder rewrites the fee (and the
+* change output that absorbs it) AFTER evaluation, so the script context the
+* node executes is not byte-identical to the one it priced. Under-declaring
+* fails phase-2 and forfeits the collateral, so the difference is paid for
+* rather than gambled on.
+*/
+const EX_UNITS_MARGIN_PERCENT = 10;
+const withMargin = (budget) => ({
+	memory: Math.ceil(budget.memory * (100 + EX_UNITS_MARGIN_PERCENT) / 100),
+	steps: Math.ceil(budget.steps * (100 + EX_UNITS_MARGIN_PERCENT) / 100)
+});
+/**
+* A {@link TxEvaluator} that prices redeemers through the Cardano provider,
+* leaving any redeemer the provider did not price on the fixed budget
+* `boundedExUnitsEvaluator` assigns it.
+*/
+const createProviderExUnitsEvaluator = ({ cardanoProvider, chainId, logger }) => {
+	const evaluate = async (tx) => {
+		try {
+			const result = await (0, rxjs.firstValueFrom)(cardanoProvider.evaluateTx({ tx: _laceio_cardano_core.Serialization.Transaction.fromCore(tx).toCbor() }, { chainId }));
+			if (result.isOk()) return result.value;
+			logger.warn("cNIGHT designation: ex-units evaluation declined, using the bounded budget", result.error);
+		} catch (error) {
+			logger.warn("cNIGHT designation: ex-units evaluation failed, using the bounded budget", error);
+		}
+	};
+	return { evaluate: async (tx, resolvedInputs) => {
+		const bounded = await boundedExUnitsEvaluator.evaluate(tx, resolvedInputs);
+		if (bounded.length === 0) return bounded;
+		const evaluated = await evaluate(tx);
+		return bounded.map((entry) => {
+			const match = evaluated?.find((budget) => budget.purpose === entry.purpose && budget.index === entry.index);
+			return match ? {
+				...entry,
+				budget: withMargin(match.budget)
+			} : entry;
+		});
+	} };
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/registration-utxo.ts
+const decodeDatumOrSkip = (datum) => {
+	try {
+		return decodeDustMappingDatum(_laceio_cardano_core.Serialization.PlutusData.fromCore(datum).toCbor());
+	} catch {
+		return;
+	}
+};
+/**
+* Pick the account's registration out of the UTxOs sitting at the dust
+* generator's script address.
+*
+* A registration is identified by the singleton DUST-mapping NFT plus an
+* inline `DustMappingDatum` whose `c_wallet` verification-key hash is the
+* account's stake key hash. Undecodable datums belong to other accounts (or
+* to a future datum revision) and are skipped rather than treated as errors.
+*/
+const findRegistrationUtxo = (scriptUtxos, nftAssetId, stakeKeyHash) => {
+	for (const utxo of scriptUtxos) {
+		const [, out] = utxo;
+		if (out.value.assets?.get(nftAssetId) !== 1n) continue;
+		if (!out.datum) continue;
+		const datum = decodeDatumOrSkip(out.datum);
+		if (datum && datumMatchesStakeKey(datum, stakeKeyHash)) return {
+			utxo,
+			datum
+		};
+	}
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/build-side-effect.ts
+const TTL_BUFFER_SLOTS = 7200;
+const LIVE_PENDING_WINDOW_MS = TTL_BUFFER_SLOTS * 1e3 + 6e5;
+const PENDING_READ_TIMEOUT_MS = 2e3;
+const NO_PENDING_ACTIVITIES = [];
+/**
+* Only `designate` counts: an update/deregister with no confirmed marker
+* already fails `no-registration-utxo`, and with one the scan already refuses
+* a designate — so widening this over-blocks for no safety gain.
+*/
+const hasLivePendingDesignate = (pendingActivities) => pendingActivities.some((activity) => {
+	if (activity.blockchainSpecific?.Cardano?.nightDesignation?.action !== "designate") return false;
+	return Date.now() - activity.timestamp < LIVE_PENDING_WINDOW_MS;
+});
+const BUILD_ERROR_KEYS_BY_CODE = {
+	"already-registered": {
+		title: "v2.cnight-designation.build.error.already-registered.title",
+		subtitle: "v2.cnight-designation.build.error.already-registered.subtitle"
+	},
+	"no-cnight": {
+		title: "v2.cnight-designation.build.error.no-cnight.title",
+		subtitle: "v2.cnight-designation.build.error.no-cnight.subtitle"
+	},
+	"no-cardano-utxos": {
+		title: "v2.cnight-designation.build.error.no-cardano-utxos.title",
+		subtitle: "v2.cnight-designation.build.error.no-cardano-utxos.subtitle"
+	},
+	"no-registration-utxo": {
+		title: "v2.cnight-designation.build.error.no-registration-utxo.title",
+		subtitle: "v2.cnight-designation.build.error.no-registration-utxo.subtitle"
+	},
+	"script-stake-unregistered": {
+		title: "v2.cnight-designation.build.error.script-stake-unregistered.title",
+		subtitle: "v2.cnight-designation.build.error.script-stake-unregistered.subtitle"
+	}
+};
+const GENERIC_BUILD_ERROR_KEYS = {
+	title: "v2.cnight-designation.build.error.title",
+	subtitle: "v2.cnight-designation.build.error.subtitle"
+};
+const errorTranslationKeysForCode = (code) => (code ? BUILD_ERROR_KEYS_BY_CODE[code] : void 0) ?? GENERIC_BUILD_ERROR_KEYS;
+const failure = (error, code) => ({
+	success: false,
+	error: {
+		name: error.name,
+		message: error.message
+	},
+	errorTranslationKeys: errorTranslationKeysForCode(code)
+});
+/**
+* Resolve the rich cNIGHT action from the serializable `Building` state by
+* scanning the script address for the registration UTxO whose inline datum is
+* bound to the account's stake key. Every action needs that answer, not just
+* update/deregister: Midnight honours neither of two registrations and the
+* second revokes the first, so a designate over an existing one is refused
+* here (`already-registered`) rather than signed. For update it also reads the
+* script reward account so the withdrawal entry matches the amount the ledger
+* will actually let the tx take.
+*/
+const resolveAction = async ({ state, network, stakeKeyHash, dependencies, chainId, pendingActivities }) => {
+	const dustPubkey = state.dustPubkeyHex === void 0 ? void 0 : MidnightCoinPubkey(hexToBytes(state.dustPubkeyHex));
+	const scriptAddress = getDustGeneratorPaymentAddress(network);
+	const registration = findRegistrationUtxo(await (0, rxjs.firstValueFrom)(require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getUtxosAtAddress({ address: scriptAddress }, { chainId }))), getDustMappingNftAssetId(network), stakeKeyHash);
+	if (state.action === "designate") {
+		if (registration) throw Object.assign(/* @__PURE__ */ new Error("This account already has a cNIGHT designation"), { code: "already-registered" });
+		if (hasLivePendingDesignate(pendingActivities)) throw Object.assign(/* @__PURE__ */ new Error("A cNIGHT designation for this account is still confirming"), { code: "already-registered" });
+		if (!dustPubkey) throw new Error("Missing dust pubkey for designate");
+		return {
+			kind: "register",
+			dustPubkey
+		};
+	}
+	if (!registration) throw Object.assign(/* @__PURE__ */ new Error("No cNIGHT designation registration found for this account"), { code: "no-registration-utxo" });
+	if (state.action === "deregister") return {
+		kind: "deregister",
+		registrationUtxo: registration.utxo
+	};
+	if (!dustPubkey) throw new Error("Missing dust pubkey for update");
+	const scriptRewardAccountInfo = await (0, rxjs.firstValueFrom)(require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getRewardAccountInfo({ rewardAccount: require_util.CardanoRewardAccount(getDustGeneratorRewardAccount(network)) }, { chainId })));
+	if (!scriptRewardAccountInfo.isRegistered) throw Object.assign(/* @__PURE__ */ new Error("The cNIGHT validator's reward account is not registered on this network"), { code: "script-stake-unregistered" });
+	return {
+		kind: "update",
+		dustPubkey,
+		registrationUtxo: registration.utxo,
+		scriptWithdrawableLovelace: require_bignum_vo.BigNumber.valueOf(scriptRewardAccountInfo.withdrawableAmount)
+	};
+};
+const buildDesignation = async (state, dependencies, pendingActivities) => {
+	try {
+		const { accountId } = state;
+		const cardano = dependencies.txExecutorCardano;
+		const [chainId, allAccountUtxos, unspendableUtxos, cardanoAddresses] = await Promise.all([
+			(0, rxjs.firstValueFrom)(cardano.cardanoChainId$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUtxos$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAccountUnspendableUtxos$),
+			(0, rxjs.firstValueFrom)(cardano.cardanoAddresses$)
+		]);
+		if (!chainId) throw new Error("Cardano chain id not available");
+		require_account_guards.refuseExtensionAccount(accountId, cardanoAddresses);
+		const [protocolParameters, tip] = await Promise.all([(0, rxjs.firstValueFrom)(require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getProtocolParameters({ chainId }))), (0, rxjs.firstValueFrom)(require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getTip({ chainId })))]);
+		const network = CardanoDustNetwork.fromNetworkMagic(chainId.networkMagic);
+		const { primaryAddress, paymentKeyHash, stakeKeyHash } = resolveAccountKeyHashes(cardanoAddresses, accountId);
+		const accountUtxos = allAccountUtxos[accountId] ?? [];
+		const reservedUtxos = unspendableUtxos[accountId] ?? [];
+		const spendable = require_util.filterSpendableUtxos(accountUtxos, reservedUtxos);
+		const cnightAssetId = getCnightAssetId(network);
+		const cnightUtxos = spendable.filter(([, out]) => out.value.assets?.has(cnightAssetId));
+		const coverUtxos = spendable.filter(([, out]) => !out.value.assets?.has(cnightAssetId));
+		const reservedKeys = new Set(reservedUtxos.map(require_util.utxoKey));
+		const reservedCollateral = require_util.getEligibleCollateralUtxo(accountUtxos.filter((utxo) => reservedKeys.has(require_util.utxoKey(utxo)) && utxo[1].address === primaryAddress));
+		const action = await resolveAction({
+			state,
+			network,
+			stakeKeyHash,
+			dependencies,
+			chainId,
+			pendingActivities
+		});
+		if (coverUtxos.length === 0) return failure(/* @__PURE__ */ new Error("No ADA-only UTxO available to cover fee and outputs"), "no-cardano-utxos");
+		const result = await buildNightDesignationTx({
+			network,
+			action,
+			cnightUtxos,
+			paymentKeyHash,
+			stakeKeyHash,
+			changeAddress: primaryAddress,
+			ttlSlot: _laceio_cardano_core.Cardano.Slot(Number(tip.slot) + TTL_BUFFER_SLOTS),
+			protocolParameters
+		}, {
+			networkMagic: chainId.networkMagic,
+			coverUtxos,
+			collateralUtxos: reservedCollateral ? [reservedCollateral] : coverUtxos,
+			txEvaluator: createProviderExUnitsEvaluator({
+				cardanoProvider: dependencies.cardanoProvider,
+				chainId,
+				logger: dependencies.logger
+			}),
+			inputResolver: require_util.createInputResolver([
+				...cnightUtxos,
+				...coverUtxos,
+				...action.kind === "register" ? [] : [action.registrationUtxo]
+			])
+		});
+		if (!result.ok) return failure(new Error(result.error.message), result.error.code);
+		return {
+			success: true,
+			serializedTx: result.value.cbor,
+			fees: [{
+				tokenId: require_const.LOVELACE_TOKEN_ID,
+				amount: require_bignum_vo.BigNumber(result.value.fee)
+			}]
+		};
+	} catch (error) {
+		const code = error instanceof require_TransactionBuilder.InputSelectionError ? "no-cardano-utxos" : error.code;
+		return failure(error instanceof Error ? error : new Error(String(error)), code);
+	}
+};
+const makeNightDesignationBuilding = () => (_, stateObservables, dependencies) => require_first_state_of_status.firstStateOfStatus(stateObservables.nightDesignationFlow.selectState$, "Building").pipe((0, rxjs.switchMap)((state) => stateObservables.activities.selectPendingActivitiesByAccount$.pipe((0, rxjs.map)((byAccount) => byAccount[state.accountId] ?? NO_PENDING_ACTIVITIES), (0, rxjs.take)(1), (0, rxjs.timeout)({
+	first: PENDING_READ_TIMEOUT_MS,
+	with: () => (0, rxjs.of)(NO_PENDING_ACTIVITIES)
+}), (0, rxjs.switchMap)((pendingActivities) => (0, rxjs.from)(buildDesignation(state, dependencies, pendingActivities)).pipe((0, rxjs.map)((result) => dependencies.actions.nightDesignationFlow.buildCompleted({
+	accountId: state.accountId,
+	result
+})))))));
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/index-side-effect.ts
+/**
+* How long a refresh waits for the chain id and addresses it scans with.
+*
+* Only a bound, not a deadline: inputs that never arrive must resolve the entry
+* rather than leave it refreshing forever, with no way back to a retry.
+*/
+const INPUTS_TIMEOUT_MS = 2e4;
+const scanInputs$ = (accountId, cardano, inputsTimeoutMs) => (0, rxjs.combineLatest)([cardano.cardanoChainId$, cardano.cardanoAddresses$]).pipe((0, rxjs.filter)((inputs) => {
+	const [chainId, cardanoAddresses] = inputs;
+	return chainId !== void 0 && cardanoAddresses.some((address) => address.accountId === accountId && require_util.isCardanoAddressOfSupportedNetwork(address, chainId));
+}), (0, rxjs.take)(1), (0, rxjs.timeout)({
+	first: inputsTimeoutMs,
+	with: () => (0, rxjs.throwError)(() => /* @__PURE__ */ new Error("Cardano chain id / addresses never published"))
+}));
+const readSnapshot$ = ({ accountId, chainId, cardanoAddresses, dependencies }) => {
+	const { stakeKeyHash } = resolveAccountKeyHashes(cardanoAddresses, accountId);
+	const network = CardanoDustNetwork.fromNetworkMagic(chainId.networkMagic);
+	return (0, rxjs.forkJoin)([require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getUtxosAtAddress({ address: getDustGeneratorPaymentAddress(network) }, { chainId })), require_unwrap_provider_result.unwrapProviderResult(() => dependencies.cardanoProvider.getRewardAccountInfo({ rewardAccount: require_util.CardanoRewardAccount(getDustGeneratorRewardAccount(network)) }, { chainId })).pipe((0, rxjs.map)((info) => info.isRegistered), (0, rxjs.catchError)(() => (0, rxjs.of)(void 0)))]).pipe((0, rxjs.map)(([scriptUtxos, isScriptStakeCredentialRegistered]) => {
+		const registration = findRegistrationUtxo(scriptUtxos, getDustMappingNftAssetId(network), stakeKeyHash);
+		return {
+			scriptStakeCredentialRegistered: isScriptStakeCredentialRegistered,
+			...registration === void 0 ? {} : { registration: {
+				txId: String(registration.utxo[0].txId),
+				outputIndex: registration.utxo[0].index,
+				dustPubkeyHex: MidnightCoinPubkey.toHex(registration.datum.dustAddress)
+			} }
+		};
+	}));
+};
+const makeNightDesignationIndexRefresh = ({ inputsTimeoutMs = INPUTS_TIMEOUT_MS } = {}) => ({ nightDesignationIndex: { refreshRequested$ } }, _stateObservables, dependencies) => refreshRequested$.pipe((0, rxjs.groupBy)(({ payload }) => payload.accountId), (0, rxjs.mergeMap)((perAccount$) => perAccount$.pipe((0, rxjs.exhaustMap)(({ payload: { accountId } }) => scanInputs$(accountId, dependencies.txExecutorCardano, inputsTimeoutMs).pipe((0, rxjs.switchMap)(([chainId, cardanoAddresses]) => readSnapshot$({
+	accountId,
+	chainId,
+	cardanoAddresses,
+	dependencies
+})), (0, rxjs.map)((snapshot) => dependencies.actions.nightDesignationIndex.refreshCompleted({
+	accountId,
+	snapshot
+})), (0, rxjs.catchError)(() => (0, rxjs.of)(dependencies.actions.nightDesignationIndex.refreshFailed({ accountId }))))))));
+/**
+* How long an entry may stay provisional before the index re-reads anyway.
+*
+* The wait is on the submitted transaction's activity, which a dropped
+* transaction or a stalled account sync can leave pending forever; without a
+* bound the entry would offer no designation control for the rest of the
+* session.
+*/
+const SETTLING_TIMEOUT_MS = 600 * 1e3;
+/**
+* Hold the index provisional from submission until the designation
+* transaction is on chain, then re-read it.
+*
+* `Success` is a SUBMIT result — the txId comes back from submission — so the
+* script address still answers for the state before the designation. Scanning
+* here would write "not designated" over an account that has just designated,
+* and every later read would repeat it. The entry is marked settling instead,
+* and the scan waits for that transaction's activity to stop being pending.
+*/
+const makeNightDesignationIndexSettling = ({ settlingTimeoutMs = SETTLING_TIMEOUT_MS } = {}) => (_, stateObservables, { actions }) => require_first_state_of_status.firstStateOfStatus(stateObservables.nightDesignationFlow.selectState$, "Success").pipe((0, rxjs.mergeMap)(({ accountId, txId }) => (0, rxjs.concat)((0, rxjs.of)(actions.nightDesignationIndex.settlingStarted({
+	accountId,
+	txId
+})), (0, rxjs.merge)(stateObservables.activities.selectAllMap$.pipe((0, rxjs.filter)((byAccount) => (byAccount[accountId] ?? []).some((activity) => activity.activityId === txId && activity.type !== require_activity_type.ActivityType.Pending))), (0, rxjs.timer)(settlingTimeoutMs)).pipe((0, rxjs.take)(1), (0, rxjs.mergeMap)(() => (0, rxjs.from)([actions.nightDesignationIndex.refreshRequested({ accountId }), actions.nightDesignationIndex.settlingEnded({ accountId })]))))));
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/sdk-extensions.ts
+const sdkExtensionSideEffects = [...[
+	makeNightDesignationBuilding(),
+	makeNightDesignationIndexRefresh(),
+	makeNightDesignationIndexSettling()
+]];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/side-effects.ts
+const mainnetMagic = Number(_laceio_cardano_core.Cardano.NetworkMagics.Mainnet);
+const deriveCardanoTestnetOptions = (config) => {
+	const blockfrostConfigs = config.cardanoProvider.blockfrostConfigs;
+	return Object.keys(blockfrostConfigs ?? {}).map((key) => Number(key)).filter((magic) => magic !== mainnetMagic).map(getCardanoTestnetIdByNetworkMagic).filter((id) => Boolean(id)).map((id) => {
+		return {
+			id: require_cardano_network_id_vo.CardanoNetworkId(getCardanoChainIdByTestnetId(id).networkMagic),
+			label: id === "preprod" ? "v2.network-status.preprod" : id === "preview" ? "v2.network-status.preview" : "v2.network-status.preprod"
+		};
+	});
+};
+const registerCardanoTestnetOptions = (testnetOptions) => (_, { network: { selectTestnetOptions$ } }, { actions }) => selectTestnetOptions$.pipe((0, rxjs.filter)((options) => !options?.Cardano), (0, rxjs.map)(() => actions.network.setTestnetOptions({
+	blockchainName: "Cardano",
+	options: testnetOptions
+})));
+const createCardanoSideEffects = (config) => {
+	return [registerCardanoTestnetOptions(deriveCardanoTestnetOptions(config))];
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/init.ts
+const redux = async (props, dependencies) => ({
+	sideEffects: [
+		...createCardanoSideEffects(props.runtime.config),
+		...composerFlowSideEffects,
+		...sdkExtensionSideEffects
+	],
+	sideEffectDependencies: await initializeDependencies(props, dependencies)
+});
+//#endregion
+exports.default = redux;