@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/init-Dj4Cn7-P.js

@@ -0,0 +1,4789 @@
+import { r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import "./dist-B00GN41m.js";
+import { $t as blake2b, At as isPlutusScript, Bt as AssetName, C as Value, Ct as PoolId, Dt as PlutusLanguageVersion, E as CostModel, I as RewardAddress, L as CertificateType, M as isDRepCredential, Nt as CborReader, Ot as ScriptType, P as RewardAccount, Pt as CborReaderState, T as Costmdls, Vt as PolicyId, Zt as Hash28ByteBase16, b as RedeemerPurpose, bt as Slot, c as EnterpriseAddress, dt as AuxiliaryData, et as ConstrPlutusData, ft as Script, it as isConstrPlutusData, kt as isNativeScript, n as AddressType, nt as PlutusData, ot as isPlutusBoundedBytes, p as Transaction, pt as PlutusV3Script, r as CredentialType, st as isPlutusList, t as Address, tn as HexBlob, tt as PlutusList, zt as AssetId } from "./Address-_c_-9hLC.js";
+import { t as Serializable } from "./serializable-F7OtYl8d.js";
+import { _ as encodeCustodyGrant, b as custodyRecipientToAddress, c as isCustodyLovelaceAsset, d as parseCustodyAccountTokenName, g as encodeCustodyAccountState, i as findCustodyGrantViolations, l as CUSTODY_SLOT_LIMIT, o as isCustodyGrantCurrent, s as isCustodyGrantExpired, t as minAdaRequired, u as custodyGrantAssetId, y as custodyRecipientFromAddress } from "./fees-6C2uEWFK.js";
+import "./_web-crypto-random-bytes-BvzwTYPG.js";
+import { t as SodiumBip32Ed25519 } from "./SodiumBip32Ed25519-DCikAMsl.js";
+import "./safe-buffer-CqGpSFCQ.js";
+import "./browser-D5jRKv_L.js";
+import { t as jsonToMetadatum } from "./metadatum-BVocMYy_.js";
+import { r as NetworkMagics, t as ChainIds } from "./ChainId-CeoG8Sov.js";
+import { t as PaymentAddress } from "./PaymentAddress-Cml3EA1n.js";
+import { i as KeyPurpose } from "./types-By-XeXWg.js";
+import { n as createTxInKeyPathMap, t as InMemoryKeyAgent } from "./InMemoryKeyAgent-D8T3vtXy.js";
+import "./src-CgINPlSx.js";
+import { t as SecretBox } from "./secret-box-CSmRp6Tt.js";
+import { _ as CardanoRewardAccount, d as utxoKey, g as CardanoPaymentAddress, l as outpointKey$1, n as filterSpendableUtxos, s as isCardanoAddressOfSupportedNetwork, t as createInputResolver } from "./util-DHxtzUzY.js";
+import { t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { t as BigNumber } from "./bignum.vo-Co6tMH2q.js";
+import { n as Ok$1, t as Err$1 } from "./asyncoption-DZQGfznq.js";
+import { t as firstStateOfStatus } from "./first-state-of-status-BscbKj_t.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Bu5Yn5ua.js";
+import { t as ActivityType } from "./activity-type-C1geyPsH.js";
+import { t as CardanoNetworkId } from "./cardano-network-id.vo-CeLJqmb_.js";
+import { r as LOVELACE_TOKEN_ID } from "./const-DbuUHSzR.js";
+import { i as identityOfValidatedCreator, n as chainIdFromNetworkMagic, o as isCardanoCustodyAccount, r as deriveCustodyAccountIdentity, t as verifyCardanoCustodyAccountIdentity } from "./identity-DxPhxkZs.js";
+import { a as CURRENT_CUSTODY_CONTRACT_VERSION, c as custodyReferenceScriptUtxos, d as fail$1, f as ok, l as findCustodyContractVersion, r as isHash28Hex, t as bytesToHex, u as findCustodyLogic } from "./hex-CGYJPK_Z.js";
+import { a as serializeCustodyRequestedGrantScope, c as encodeCustodyLogicRedeemer, g as findCustodyScopeViolations, h as custodyGrantAfterSpend, i as parseCustodyRequestedGrantScope, l as encodeCustodyMintRedeemer, n as deriveCustodyDeviceKey, o as inspectCustodyTransaction, p as createCustodyAccountRecord, s as encodeCustodyAccountRedeemer, u as encodeCustodyStakeRedeemer } from "./device-key-BToCoS4D.js";
+import { i as classifyCardanoCustodyAccount, n as isCardanoCustodyGrantExhausted, o as custodyGrantLiveness, r as CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND } from "./grant-status-CDmZpx32.js";
+import { a as referenceScriptSize, c as getUniqueSignerKeyHashes, i as referenceScriptFee, n as TransactionBuilder, o as EvaluatedFeeShortfallError, r as LargeFirstCoinSelector, s as InputSelectionError, t as InsufficientCollateralError } from "./TransactionBuilder-D2ErwVWv.js";
+import { t as applyVkeyWitnesses } from "./apply-vkey-witnesses-Byb40-yJ.js";
+import { t as isRetriableError } from "./is-retriable-error-CmFR20pe.js";
+import { t as refuseExtensionAccount } from "./account-guards-qnFXuXSE.js";
+import { catchError, combineLatest, concat, defer, exhaustMap, filter, first, firstValueFrom, forkJoin, from, groupBy, map, merge, mergeMap, of, switchMap, take, throwError, timeout, timer } from "rxjs";
+//#region ../../packages/contract/cardano-context/src/value-objects/cardano-testnet-id.vo.ts
+const CARDANO_CHAIN_ID_BY_TESTNET = {
+	preprod: ChainIds.Preprod,
+	preview: ChainIds.Preview,
+	sanchonet: ChainIds.Sanchonet
+};
+const PREPROD_MAGIC = Number(ChainIds.Preprod.networkMagic);
+const PREVIEW_MAGIC = Number(ChainIds.Preview.networkMagic);
+const SANCHONET_MAGIC = Number(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/lib/cardano-custody/src/analysis/sponsor-rules.ts
+/** The service's limit on the size of a transaction it inspects, in bytes. */
+const MAX_TRANSACTION_BYTES = 16 * 1024;
+/** The service's default limit on the fee a leased fee UTxO pays, in lovelace. */
+const MAX_FEE_LOVELACE = 2000000n;
+/**
+* The most devices a well formed state lists, which bounds the stake scripts
+* a creation has the service derive.
+*/
+const MAX_DEVICES = 8;
+const outpointKey = ({ txId, index }) => `${txId.toLowerCase()}#${index}`;
+const toTxIn = ({ txId, index }) => ({
+	txId,
+	index
+});
+const paymentCredentialOf = (address) => {
+	const parsed = Address.fromString(address);
+	return (parsed?.asBase() ?? parsed?.asEnterprise() ?? parsed?.asPointer())?.getPaymentCredential();
+};
+const stakeCredentialOf = (address) => {
+	const parsed = Address.fromString(address);
+	return parsed?.asBase()?.getStakeCredential() ?? parsed?.asReward()?.getPaymentCredential();
+};
+const keyHashOf = (credential) => credential?.type === CredentialType.KeyHash ? credential.hash : void 0;
+const scriptHashOf$1 = (credential) => credential?.type === CredentialType.ScriptHash ? credential.hash : void 0;
+const sponsorKeysOf = (address) => ({
+	paymentKeyHash: keyHashOf(paymentCredentialOf(address)),
+	stakeKeyHash: keyHashOf(stakeCredentialOf(address))
+});
+const namesSponsorKey = (credential, { paymentKeyHash, stakeKeyHash }) => credential.type === CredentialType.KeyHash && (credential.hash === paymentKeyHash || credential.hash === stakeKeyHash);
+const isAccountOutput = (output, { contractVersion }) => scriptHashOf$1(paymentCredentialOf(output.address)) === contractVersion.accountValidatorHash;
+const policyIdOf = (assetId) => AssetId.getPolicyId(assetId);
+/** The 28-byte hash a datum field holds, or undefined for a field of any other shape. */
+const hashFieldOf = (field) => isPlutusBoundedBytes(field) && field.length === 28 ? Hash28ByteBase16(bytesToHex(field)) : void 0;
+/** The fields of an inline datum that is constructor 0, or undefined for any other datum. */
+const inlineFieldsOf = (output) => isConstrPlutusData(output.datum) && output.datum.constructor === 0n ? output.datum.fields.items : void 0;
+/** The logic a control datum names: a 28-byte hash in its first field. */
+const logicHashOf = (output) => hashFieldOf(inlineFieldsOf(output)?.[0]);
+/** The devices a control datum lists: a list of 28-byte hashes in its second field. */
+const devicesOf = (output) => {
+	const list = inlineFieldsOf(output)?.[1];
+	if (!isPlutusList(list)) return void 0;
+	const devices = list.items.map(hashFieldOf);
+	return devices.every((device) => device !== void 0) ? devices : void 0;
+};
+/**
+* The account token an input holds, when it is a control or a grant UTxO:
+* the output sits at an account address staked to a script and holds a
+* token under the account policy named after that very script, alone or
+* followed by a slot. The validator mints a token only into such an
+* output, so an output shaped otherwise is never read as an account's. The
+* control token wins when an output holds both kinds.
+*/
+const accountTokenOf = ({ input, output }, context) => {
+	if (output === void 0 || !isAccountOutput(output, context)) return;
+	const account = scriptHashOf$1(stakeCredentialOf(output.address));
+	if (account === void 0) return void 0;
+	const kinds = [...output.value.assets ?? /* @__PURE__ */ new Map()].flatMap(([assetId, quantity]) => {
+		if (policyIdOf(assetId) !== context.contractVersion.accountValidatorHash || quantity <= 0n) return [];
+		const name = parseCustodyAccountTokenName(AssetId.getAssetName(assetId));
+		return name?.stakeScriptHash === account ? [name.kind] : [];
+	});
+	if (kinds.length === 0) return void 0;
+	return {
+		input,
+		output,
+		account,
+		kind: kinds.includes("state-nft") ? "control" : "grant"
+	};
+};
+/**
+* The account a control output belongs to: an output at an account address
+* staked to a script, holding exactly one state NFT named after that script.
+* The validator pins the state NFT to such an output, so its datum names
+* the logic the account runs once the transaction lands.
+*/
+const controlOutputAccount = (output, context) => {
+	if (!isAccountOutput(output, context)) return void 0;
+	const account = scriptHashOf$1(stakeCredentialOf(output.address));
+	if (account === void 0) return void 0;
+	const stateNft = AssetId.fromParts(PolicyId(context.contractVersion.accountValidatorHash), AssetName(account));
+	return output.value.assets?.get(stateNft) === 1n ? account : void 0;
+};
+/**
+* Every logic the transaction names: the one each control UTxO it spends or
+* references names, then the one each control output it writes names. A
+* creation names its initial logic in its control output, and an upgrade
+* names the logic it leaves in the control UTxO and the one it arrives at in
+* the control output.
+*/
+const namedLogicsOf = ({ spent, referencedControls }, body, context) => [...[...spent.filter(({ kind }) => kind === "control"), ...referencedControls].map(({ input, output, account }) => ({
+	logic: logicHashOf(output),
+	control: {
+		kind: "control-utxo",
+		input
+	},
+	stakeScriptHash: account
+})), ...body.outputs.flatMap((output, outputIndex) => {
+	const account = controlOutputAccount(output, context);
+	return account === void 0 ? [] : [{
+		logic: logicHashOf(output),
+		control: {
+			kind: "control-output",
+			outputIndex
+		},
+		stakeScriptHash: account
+	}];
+})];
+/**
+* A sponsor UTxO is the leased fee UTxO, the shared collateral, or any
+* output locked by the sponsor payment key: the sponsor's signature
+* authorises every one of them.
+*/
+const isSponsorInput = ({ input, output }, context, sponsorKeys) => {
+	const key = outpointKey(input);
+	return context.mode.kind === "fee" && key === outpointKey(context.mode.feeUtxo[0]) || key === outpointKey(context.collateralUtxo[0]) || output !== void 0 && sponsorKeys.paymentKeyHash !== void 0 && keyHashOf(paymentCredentialOf(output.address)) === sponsorKeys.paymentKeyHash;
+};
+/** Every credential a certificate names, any of which may have to sign. */
+const certificateCredentials = (certificate) => {
+	const named = [];
+	if ("stakeCredential" in certificate) named.push(certificate.stakeCredential);
+	if ("dRep" in certificate && isDRepCredential(certificate.dRep)) named.push(certificate.dRep);
+	if ("dRepCredential" in certificate) named.push(certificate.dRepCredential);
+	if ("coldCredential" in certificate) named.push(certificate.coldCredential);
+	if ("hotCredential" in certificate) named.push(certificate.hotCredential);
+	const poolIds = [];
+	if ("poolId" in certificate) poolIds.push(certificate.poolId);
+	if ("poolParameters" in certificate) {
+		const { id, rewardAccount, owners } = certificate.poolParameters;
+		poolIds.push(id);
+		named.push(stakeCredentialOf(rewardAccount), ...owners.map((owner) => stakeCredentialOf(owner)));
+	}
+	for (const poolId of poolIds) named.push({
+		type: CredentialType.KeyHash,
+		hash: PoolId.toKeyHash(poolId)
+	});
+	return named.filter((credential) => credential !== void 0);
+};
+const LOVELACE_KEY = "";
+/** Lovelace and every asset a list of values holds, keyed by asset id ('' for lovelace). */
+const balanceOf = (values) => {
+	const balance = /* @__PURE__ */ new Map();
+	const add = (key, quantity) => balance.set(key, (balance.get(key) ?? 0n) + quantity);
+	for (const value of values) {
+		add(LOVELACE_KEY, value.coins);
+		for (const [assetId, quantity] of value.assets ?? []) add(assetId, quantity);
+	}
+	return balance;
+};
+/** Reads each entry of the CBOR map the reader is at, definite or not. */
+const readMapEntries = (reader, readEntry) => {
+	const count = reader.readStartMap();
+	for (let read = 0; count === null ? reader.peekState() !== CborReaderState.EndMap : read < count; read++) readEntry();
+};
+/** The fields of an encoded body or witness set by key, each as the bytes it is stated in. */
+const fieldsOf = (encoded) => {
+	const reader = new CborReader(bytesToHex(encoded));
+	const fields = /* @__PURE__ */ new Map();
+	readMapEntries(reader, () => fields.set(reader.readUInt(), bytesToHex(reader.readEncodedValue())));
+	return fields;
+};
+const BODY_WITHDRAWALS = 5n;
+const WITNESS_DATUMS = 4n;
+const WITNESS_REDEEMERS = 5n;
+/**
+* The body withdrawals and the witness script data as the transaction's
+* bytes state them, which is what the service reads: the decoded body keeps
+* one withdrawal per reward account, and the script data hash is taken over
+* the bytes the witness set carries.
+*/
+const statedOf = (transaction) => {
+	const reader = new CborReader(HexBlob(transaction.toCbor()));
+	reader.readStartArray();
+	const body = fieldsOf(reader.readEncodedValue());
+	const witnessSet = fieldsOf(reader.readEncodedValue());
+	const withdrawals = [];
+	const encodedWithdrawals = body.get(BODY_WITHDRAWALS);
+	if (encodedWithdrawals !== void 0) {
+		const withdrawalReader = new CborReader(encodedWithdrawals);
+		readMapEntries(withdrawalReader, () => withdrawals.push({
+			stakeAddress: RewardAccount(Address.fromBytes(bytesToHex(withdrawalReader.readByteString())).toBech32()),
+			quantity: withdrawalReader.readUInt()
+		}));
+	}
+	return {
+		withdrawals,
+		witnessScriptData: {
+			redeemers: witnessSet.get(WITNESS_REDEEMERS),
+			datums: witnessSet.get(WITNESS_DATUMS)
+		}
+	};
+};
+/**
+* Reads an account creation, or the reason the transaction is none:
+* exactly one token minted under the account policy, named with the 28
+* bytes of a stake script hash, exactly one registration of a script stake
+* credential with its deposit, the token named after that credential and
+* held by exactly one output at an account address staked to it, and that
+* credential the version's stake script of a device the output's datum
+* lists. A datum listing more devices than a well formed state is refused
+* before any script is derived.
+*/
+const readCreation = (body, context) => {
+	const refuse = (reason) => ({
+		rule: "account_transaction",
+		reason
+	});
+	const { accountValidatorHash } = context.contractVersion;
+	const minted = [...body.mint ?? /* @__PURE__ */ new Map()].filter(([assetId]) => policyIdOf(assetId) === accountValidatorHash);
+	if (minted.length === 0) return refuse("not-account-transaction");
+	const [[assetId, quantity]] = minted;
+	if (minted.length !== 1 || quantity !== 1n) return refuse("mint-count");
+	if (parseCustodyAccountTokenName(AssetId.getAssetName(assetId))?.kind !== "state-nft") return refuse("state-nft-name-length");
+	const registrations = (body.certificates ?? []).filter((certificate) => certificate.__typename === CertificateType.Registration && certificate.stakeCredential.type === CredentialType.ScriptHash);
+	if (registrations.length !== 1) return refuse("registration-count");
+	const [registration] = registrations;
+	const stakeScriptHash = registration.stakeCredential.hash;
+	if (AssetId.getAssetName(assetId) !== stakeScriptHash) return refuse("state-nft-name");
+	const holders = body.outputs.filter((output) => output.value.assets?.get(assetId) === 1n);
+	if (holders.length !== 1 || !isAccountOutput(holders[0], context)) return refuse("control-output-placement");
+	const [controlOutput] = holders;
+	if (scriptHashOf$1(stakeCredentialOf(controlOutput.address)) !== stakeScriptHash) return refuse("control-output-stake");
+	const devices = devicesOf(controlOutput);
+	if (devices === void 0) return refuse("control-output-devices");
+	if (devices.length > MAX_DEVICES) return {
+		rule: "account_transaction",
+		reason: "device-count",
+		count: devices.length,
+		limit: MAX_DEVICES
+	};
+	const chainId = chainIdFromNetworkMagic(context.networkMagic);
+	if (!devices.some((device) => identityOfValidatedCreator({
+		contractVersion: context.contractVersion,
+		creatorKeyHash: device,
+		chainId
+	}).stakeScriptHash === stakeScriptHash)) return {
+		rule: "account_transaction",
+		reason: "underived-stake-credential",
+		stakeScriptHash
+	};
+	return {
+		deposit: registration.deposit,
+		controlLovelace: controlOutput.value.coins,
+		stakeScriptHash
+	};
+};
+/** The accounts whose control UTxO the transaction spends or references. */
+const controlledAccountsOf = ({ spent, referencedControls }) => new Set([...spent, ...referencedControls].filter(({ kind }) => kind === "control").map(({ account }) => account));
+/**
+* Reads what the transaction does to the account contract. A referenced
+* control UTxO serves only an account the transaction operates, so one of
+* any other account is refused first, even beside a creation. A
+* transaction spending no account token is a creation, or no account
+* transaction at all. One spending a token is an operation, and every
+* account it operates needs its control UTxO spent or referenced, as the
+* contract needs on the owner, the sweep and the agent path alike.
+*/
+const readAccountTransaction = (body, { spent, referencedControls }, context) => {
+	const refuse = (reason, { input, account }) => ({
+		kind: "refused",
+		violation: {
+			rule: "account_transaction",
+			reason,
+			input,
+			stakeScriptHash: account
+		}
+	});
+	const operated = new Set(spent.map(({ account }) => account));
+	const foreignControl = referencedControls.find(({ account }) => !operated.has(account));
+	if (foreignControl) return refuse("foreign-referenced-control", foreignControl);
+	if (spent.length === 0) {
+		const creation = readCreation(body, context);
+		return "rule" in creation ? {
+			kind: "refused",
+			violation: creation
+		} : {
+			kind: "creation",
+			creation
+		};
+	}
+	const controlled = controlledAccountsOf({
+		spent,
+		referencedControls
+	});
+	const orphan = spent.find(({ account }) => !controlled.has(account));
+	return orphan ? refuse("orphan-grant", orphan) : { kind: "operation" };
+};
+/**
+* The stake scripts of the accounts the transaction belongs to: those of
+* the control UTxOs it spends or references, which name them, and the one
+* it registers at creation. A grant UTxO alone names none: an agent spend
+* references the control UTxO of its account.
+*/
+const stakeScriptHashesOf = (tokens, reading) => {
+	const hashes = controlledAccountsOf(tokens);
+	if (reading.kind === "creation") hashes.add(reading.creation.stakeScriptHash);
+	return hashes;
+};
+const analyse = (transaction, resolvedInputs, context) => {
+	const body = transaction.body().toCore();
+	const sponsorKeys = sponsorKeysOf(context.sponsorAddress);
+	const resolutions = new Map(resolvedInputs.map(([input, output]) => [outpointKey(input), output]));
+	const resolve = (input) => ({
+		input: toTxIn(input),
+		output: resolutions.get(outpointKey(input))
+	});
+	const inputs = body.inputs.map(resolve);
+	const referenceInputs = (body.referenceInputs ?? []).map(resolve);
+	const sponsorInputs = inputs.filter((input) => isSponsorInput(input, context, sponsorKeys));
+	const tokens = {
+		spent: inputs.filter((input) => !sponsorInputs.includes(input)).flatMap((input) => accountTokenOf(input, context) ?? []),
+		referencedControls: referenceInputs.flatMap((input) => accountTokenOf(input, context) ?? []).filter(({ kind }) => kind === "control")
+	};
+	const reading = readAccountTransaction(body, tokens, context);
+	const namedLogics = namedLogicsOf(tokens, body, context);
+	const sponsorOutputs = body.outputs.flatMap((output, outputIndex) => output.address === context.sponsorAddress ? [{
+		output,
+		outputIndex
+	}] : []);
+	return {
+		transaction,
+		body,
+		witness: transaction.witnessSet().toCore(),
+		inputs,
+		referenceInputs,
+		sponsorInputs,
+		sponsorOutputs,
+		foreignOutputs: body.outputs.filter((output) => output.address !== context.sponsorAddress && !isAccountOutput(output, context)),
+		...statedOf(transaction),
+		reading,
+		stakeScriptHashes: stakeScriptHashesOf(tokens, reading),
+		namedLogics,
+		logicHashes: new Set(namedLogics.flatMap(({ logic }) => logic ?? [])),
+		sponsorKeys
+	};
+};
+const wellFormed = ({ transaction, body }) => {
+	const size = transaction.toCbor().length / 2;
+	if (size > MAX_TRANSACTION_BYTES) return {
+		rule: "well_formed",
+		reason: "too-large",
+		size,
+		limit: MAX_TRANSACTION_BYTES
+	};
+	if ((body.proposalProcedures ?? []).length > 0) return {
+		rule: "well_formed",
+		reason: "proposal-procedures"
+	};
+	return body.donation === void 0 ? void 0 : {
+		rule: "well_formed",
+		reason: "treasury-donation"
+	};
+};
+/**
+* Fee mode spends the leased fee UTxO and no other sponsor UTxO; collateral
+* mode spends none. An input whose payment credential cannot be read
+* cannot be told from the sponsor's.
+*/
+const sponsorInputsRule = ({ inputs, sponsorInputs }, { mode }) => {
+	const rule = mode.kind === "fee" ? "uses_leased_fee_input" : "no_sponsor_inputs";
+	const feeKey = mode.kind === "fee" ? outpointKey(mode.feeUtxo[0]) : void 0;
+	if (mode.kind === "fee" && !inputs.some(({ input }) => outpointKey(input) === feeKey)) return {
+		rule: "uses_leased_fee_input",
+		reason: "fee-input-missing",
+		input: toTxIn(mode.feeUtxo[0])
+	};
+	const unreadable = inputs.find(({ output }) => output !== void 0 && paymentCredentialOf(output.address) === void 0);
+	if (unreadable) return {
+		rule,
+		reason: "unreadable-input",
+		input: unreadable.input
+	};
+	const extra = sponsorInputs.find(({ input }) => outpointKey(input) !== feeKey);
+	return extra ? {
+		rule,
+		reason: "sponsor-input",
+		input: extra.input
+	} : void 0;
+};
+/**
+* The transaction is not flagged as failing phase two, and its collateral
+* is exactly the shared collateral UTxO, returned plainly to the sponsor,
+* with the total collateral set within what it holds. The ledger also
+* takes collateral of at least the collateral percentage of the fee, so a
+* fee above what the shared collateral covers is refused: the service
+* would refuse the total it needs, and the ledger any less.
+*/
+const sharedCollateral = ({ transaction, body }, context) => {
+	const refuse = (reason) => ({
+		rule: "uses_shared_collateral",
+		reason
+	});
+	if (!transaction.isValid()) return refuse("phase-two-invalid");
+	const collaterals = body.collaterals ?? [];
+	if (collaterals.length !== 1 || outpointKey(collaterals[0]) !== outpointKey(context.collateralUtxo[0])) return refuse("collateral-inputs");
+	const { collateralReturn, totalCollateral } = body;
+	if (!collateralReturn) return refuse("no-collateral-return");
+	if (collateralReturn.address !== context.sponsorAddress) return refuse("collateral-return-address");
+	if (collateralReturn.datum !== void 0 || collateralReturn.datumHash !== void 0) return refuse("collateral-return-datum");
+	if (collateralReturn.scriptReference !== void 0) return refuse("collateral-return-reference-script");
+	if (totalCollateral === void 0) return refuse("no-total-collateral");
+	const available = context.collateralUtxo[1].value.coins;
+	if (totalCollateral > available) return {
+		rule: "uses_shared_collateral",
+		reason: "total-collateral-exceeds",
+		totalCollateral,
+		available
+	};
+	const percentage = BigInt(context.collateralPercentage);
+	return body.fee * percentage > available * 100n ? {
+		rule: "uses_shared_collateral",
+		reason: "fee-exceeds-collateral",
+		fee: body.fee,
+		limit: available * 100n / percentage
+	} : void 0;
+};
+const boundedValidity = ({ body }, context) => {
+	const upperBound = body.validityInterval?.invalidHereafter;
+	if (upperBound === void 0) return {
+		rule: "bounded_validity",
+		reason: "no-upper-bound"
+	};
+	if (upperBound > context.latestValiditySlot) return {
+		rule: "bounded_validity",
+		reason: "upper-bound-too-late",
+		upperBound,
+		latest: context.latestValiditySlot
+	};
+	return upperBound <= context.currentSlot ? {
+		rule: "bounded_validity",
+		reason: "upper-bound-not-future",
+		upperBound,
+		current: context.currentSlot
+	} : void 0;
+};
+const accountTransaction = ({ reading }) => reading.kind === "refused" ? reading.violation : void 0;
+/**
+* Every logic the transaction names is one the service knows. The proxy
+* runs whatever registered script a control datum names, so the service
+* pays for and lends collateral to no account under rules it has not read,
+* and refuses a control datum that names no script hash at all.
+*/
+const knownLogic = ({ namedLogics }, { contractVersion }) => {
+	const known = new Set(contractVersion.logics.map(({ hash }) => hash));
+	for (const { logic, control, stakeScriptHash } of namedLogics) {
+		if (logic === void 0) return {
+			rule: "known_logic",
+			reason: "logic-missing",
+			control,
+			stakeScriptHash
+		};
+		if (!known.has(logic)) return {
+			rule: "known_logic",
+			reason: "unknown-logic",
+			control,
+			logic,
+			stakeScriptHash
+		};
+	}
+};
+/**
+* The leased fee UTxO pays for an account creation and nothing else: an
+* operation on an existing account pays its own fee and takes the
+* collateral route, whatever it draws. The fee stays within the service's
+* limit, and the fee UTxO is drawn down by exactly the fee, the
+* registration deposit and the control output, within the sponsored limit,
+* and returns as one plain change output the pool can spend.
+*/
+const sponsorOutflowBounded = ({ body, sponsorOutputs, reading }, mode) => {
+	const rule = "sponsor_outflow_bounded";
+	if (reading.kind !== "creation") return {
+		rule,
+		reason: "not-creation"
+	};
+	if (body.fee > MAX_FEE_LOVELACE) return {
+		rule,
+		reason: "fee-exceeds-limit",
+		fee: body.fee,
+		limit: MAX_FEE_LOVELACE
+	};
+	for (const { output, outputIndex } of sponsorOutputs) {
+		if (output.datum !== void 0 || output.datumHash !== void 0) return {
+			rule,
+			reason: "sponsor-output-datum",
+			outputIndex
+		};
+		if (output.scriptReference !== void 0) return {
+			rule,
+			reason: "sponsor-output-reference-script",
+			outputIndex
+		};
+	}
+	if (sponsorOutputs.length !== 1) return {
+		rule,
+		reason: "sponsor-output-count",
+		count: sponsorOutputs.length
+	};
+	const sponsored = mode.feeUtxo[1].value.coins - sponsorOutputs[0].output.value.coins;
+	const { deposit, controlLovelace } = reading.creation;
+	const expected = body.fee + deposit + controlLovelace;
+	if (sponsored !== expected) return {
+		rule,
+		reason: "draw-mismatch",
+		sponsored,
+		expected
+	};
+	return sponsored > mode.maxSponsoredLovelace ? {
+		rule,
+		reason: "draw-exceeds-limit",
+		sponsored,
+		limit: mode.maxSponsoredLovelace
+	} : void 0;
+};
+/** In collateral mode nothing pays the sponsor key and nothing draws from its reward account. */
+const sponsorOutflowZero = ({ body, withdrawals, sponsorKeys }) => {
+	const outputIndex = body.outputs.findIndex((output) => sponsorKeys.paymentKeyHash !== void 0 && keyHashOf(paymentCredentialOf(output.address)) === sponsorKeys.paymentKeyHash);
+	if (outputIndex >= 0) return {
+		rule: "sponsor_outflow_zero",
+		reason: "pays-sponsor",
+		outputIndex
+	};
+	const withdrawal = withdrawals.find(({ stakeAddress }) => sponsorKeys.stakeKeyHash !== void 0 && keyHashOf(stakeCredentialOf(stakeAddress)) === sponsorKeys.stakeKeyHash);
+	return withdrawal ? {
+		rule: "sponsor_outflow_zero",
+		reason: "sponsor-withdrawal",
+		rewardAccount: withdrawal.stakeAddress
+	} : void 0;
+};
+const sponsorOutflow = (analysis, { mode }) => mode.kind === "fee" ? sponsorOutflowBounded(analysis, mode) : sponsorOutflowZero(analysis);
+/** Outputs away from the sponsor and the account are covered by what non-sponsor inputs and withdrawals bring. */
+const noSponsorValueElsewhere = ({ withdrawals, inputs, sponsorInputs, foreignOutputs, sponsorKeys }) => {
+	const supply = balanceOf(inputs.filter((input) => !sponsorInputs.includes(input)).flatMap(({ output }) => output ? [output.value] : []));
+	for (const { stakeAddress, quantity } of withdrawals) if (!(sponsorKeys.stakeKeyHash !== void 0 && keyHashOf(stakeCredentialOf(stakeAddress)) === sponsorKeys.stakeKeyHash)) supply.set(LOVELACE_KEY, (supply.get(LOVELACE_KEY) ?? 0n) + quantity);
+	const demand = balanceOf(foreignOutputs.map((output) => output.value));
+	for (const [key, demanded] of demand) {
+		const supplied = supply.get(key) ?? 0n;
+		if (demanded > supplied) return {
+			rule: "no_sponsor_value_elsewhere",
+			reason: "uncovered-outflow",
+			demanded,
+			supplied,
+			...key === LOVELACE_KEY ? {} : { assetId: key }
+		};
+	}
+};
+/**
+* Lace's own rule on reference inputs: one carrying a script must be a
+* version's parked script UTxO on the network, carrying exactly the script
+* parked there, and a parked script's UTxO must carry its script.
+*/
+const foreignReferenceScriptOf = (referenceInputs, { contractVersion, networkMagic }) => {
+	const parked = new Map((contractVersion.referenceScripts[networkMagic] ?? []).map(({ txIn, scriptHash }) => [outpointKey(txIn), scriptHash]));
+	for (const { input, output } of referenceInputs) {
+		const script = output?.scriptReference;
+		const scriptHash = script && Script.fromCore(script).hash();
+		const expected = parked.get(outpointKey(input));
+		if (expected === void 0 ? scriptHash !== void 0 : output !== void 0 && scriptHash !== expected) return {
+			rule: "no_foreign_scripts",
+			reason: "foreign-reference-script",
+			input,
+			...scriptHash && { scriptHash }
+		};
+	}
+};
+/**
+* Every script the transaction runs or attaches belongs to the account.
+* Inputs and mints use the account proxy alone. A certificate or a vote may
+* name the proxy or the stake script of an account the transaction belongs
+* to. A logic its control datums name may also run through a withdrawal,
+* of zero only, and be attached. No reward account is drawn from twice.
+*/
+const noForeignScripts = ({ body, witness, inputs, referenceInputs, withdrawals, stakeScriptHashes, logicHashes }, context) => {
+	const rule = "no_foreign_scripts";
+	const proxy = context.contractVersion.accountValidatorHash;
+	const accountScripts = new Set([proxy, ...stakeScriptHashes]);
+	const runnable = new Set([...accountScripts, ...logicHashes]);
+	for (const { input, output } of inputs) {
+		const scriptHash = output && scriptHashOf$1(paymentCredentialOf(output.address));
+		if (scriptHash !== void 0 && scriptHash !== proxy) return {
+			rule,
+			reason: "foreign-script-input",
+			input,
+			scriptHash
+		};
+	}
+	for (const assetId of body.mint?.keys() ?? []) {
+		const policyId = policyIdOf(assetId);
+		if (policyId !== proxy) return {
+			rule,
+			reason: "foreign-mint",
+			policyId
+		};
+	}
+	for (const [certificateIndex, certificate] of (body.certificates ?? []).entries()) {
+		const scriptHash = certificateCredentials(certificate).map(scriptHashOf$1).find((hash) => hash !== void 0 && !accountScripts.has(hash));
+		if (scriptHash) return {
+			rule,
+			reason: "foreign-certificate",
+			certificateIndex,
+			scriptHash
+		};
+	}
+	const drawn = /* @__PURE__ */ new Set();
+	for (const { stakeAddress: rewardAccount, quantity } of withdrawals) {
+		if (drawn.has(rewardAccount)) return {
+			rule,
+			reason: "duplicate-withdrawal",
+			rewardAccount
+		};
+		drawn.add(rewardAccount);
+		const scriptHash = scriptHashOf$1(stakeCredentialOf(rewardAccount));
+		if (scriptHash !== void 0 && !runnable.has(scriptHash)) return {
+			rule,
+			reason: "foreign-withdrawal",
+			rewardAccount
+		};
+		if (scriptHash !== void 0 && logicHashes.has(scriptHash) && quantity !== 0n) return {
+			rule,
+			reason: "logic-draw",
+			rewardAccount,
+			logic: scriptHash,
+			quantity
+		};
+	}
+	for (const { voter } of body.votingProcedures ?? []) {
+		const scriptHash = scriptHashOf$1(voter.credential);
+		if (scriptHash !== void 0 && !accountScripts.has(scriptHash)) return {
+			rule,
+			reason: "foreign-voter",
+			scriptHash
+		};
+	}
+	const scripts = witness.scripts ?? [];
+	if (scripts.some((script) => isNativeScript(script))) return {
+		rule,
+		reason: "native-script"
+	};
+	for (const script of scripts) {
+		const scriptHash = Script.fromCore(script).hash();
+		if (!runnable.has(scriptHash)) return {
+			rule,
+			reason: "foreign-attached-script",
+			scriptHash
+		};
+	}
+	return foreignReferenceScriptOf(referenceInputs, context);
+};
+/**
+* The Plutus languages of the scripts the transaction attaches, then of the
+* reference scripts its inputs and reference inputs carry: the service's
+* language view covers all of them, not only the scripts that run.
+*/
+const languagesOf = ({ witness, inputs, referenceInputs }) => [...(witness.scripts ?? []).flatMap((script) => isPlutusScript(script) ? [script.version] : []), ...[...inputs, ...referenceInputs].flatMap(({ output }) => output?.scriptReference && isPlutusScript(output.scriptReference) ? [output.scriptReference.version] : [])];
+/** The redeemers that stand in for a witness set carrying datums and no redeemers. */
+const EMPTY_REDEEMERS = "a0";
+/**
+* The script data hash the body commits to is the one the witness set's
+* redeemers and datums hash to, under the cost models, with the language
+* view of every attached and referenced script. Every script an account
+* runs is Plutus V3, so a transaction carrying any other language is
+* refused before a view is formed.
+*/
+const scriptDataHash = (analysis, { costModels }) => {
+	const rule = "script_data_hash";
+	const declared = analysis.body.scriptIntegrityHash;
+	const { redeemers, datums } = analysis.witnessScriptData;
+	if (redeemers === void 0 && datums === void 0) return declared === void 0 ? void 0 : {
+		rule,
+		reason: "unexpected-script-data-hash",
+		declared
+	};
+	if (declared === void 0) return {
+		rule,
+		reason: "missing-script-data-hash"
+	};
+	const languages = languagesOf(analysis);
+	const foreign = languages.find((language) => language !== PlutusLanguageVersion.V3);
+	if (foreign !== void 0) return {
+		rule,
+		reason: "non-v3-script",
+		language: foreign
+	};
+	const views = new Costmdls();
+	for (const language of new Set(languages)) {
+		const costs = costModels.get(language);
+		if (!costs) return {
+			rule,
+			reason: "missing-cost-model",
+			language
+		};
+		views.insert(new CostModel(language, costs));
+	}
+	const computed = blake2b.hash(HexBlob(`${redeemers ?? EMPTY_REDEEMERS}${datums ?? ""}${views.languageViewsEncoding()}`), 32);
+	return computed === declared ? void 0 : {
+		rule,
+		reason: "script-data-hash-mismatch",
+		declared,
+		computed
+	};
+};
+/** Neither sponsor key signs for anything but the sponsor's own inputs. */
+const signers = ({ body, withdrawals, sponsorKeys }) => {
+	const keyHash = (body.requiredExtraSignatures ?? []).find((signer) => signer === sponsorKeys.paymentKeyHash || signer === sponsorKeys.stakeKeyHash);
+	if (keyHash) return {
+		rule: "signers",
+		reason: "sponsor-required-signer",
+		keyHash
+	};
+	const withdrawal = withdrawals.find(({ stakeAddress }) => {
+		const credential = stakeCredentialOf(stakeAddress);
+		return credential !== void 0 && namesSponsorKey(credential, sponsorKeys);
+	});
+	if (withdrawal) return {
+		rule: "signers",
+		reason: "sponsor-withdrawal",
+		rewardAccount: withdrawal.stakeAddress
+	};
+	const certificateIndex = (body.certificates ?? []).findIndex((certificate) => certificateCredentials(certificate).some((credential) => namesSponsorKey(credential, sponsorKeys)));
+	if (certificateIndex >= 0) return {
+		rule: "signers",
+		reason: "sponsor-certificate",
+		certificateIndex
+	};
+	return (body.votingProcedures ?? []).some(({ voter }) => namesSponsorKey(voter.credential, sponsorKeys)) ? {
+		rule: "signers",
+		reason: "sponsor-voter"
+	} : void 0;
+};
+/** The service's rules in its check order; it evaluates the scripts between the last two. */
+const RULES = [
+	wellFormed,
+	sponsorInputsRule,
+	sharedCollateral,
+	boundedValidity,
+	accountTransaction,
+	knownLogic,
+	sponsorOutflow,
+	noSponsorValueElsewhere,
+	noForeignScripts,
+	scriptDataHash,
+	signers
+];
+/**
+* Every rule of the fee sponsor service's policy that a transaction breaks,
+* at most one per rule and in the service's check order, so the first is
+* the one the service would answer with. Lace checks its custody builds
+* with it before asking the sponsor for a witness, so a refusal from the
+* service points at a real defect rather than a build Lace knew to be wrong.
+*
+* The script evaluation rule is not mirrored: it needs the chain. Of the
+* sponsor's UTxOs, only the leased fee UTxO, the shared collateral and
+* outputs locked by the sponsor payment key are recognised; the service
+* also knows the rest of its pool. The service knows the logics its
+* operator lists, which Lace takes to be the contract version's. Beyond the
+* service's rules, the shared collateral rule refuses a fee above what the
+* shared collateral covers, which the ledger would refuse after the service
+* signed, and the script rule refuses a reference script other than the
+* version's parked scripts on the network.
+*
+* @param resolvedInputs - the outputs the transaction's inputs spend and its
+*   reference inputs name; an input or a reference input without one is
+*   read as the service reads one the chain does not know, which is never
+*   an account's control or grant UTxO and carries no reference script
+*/
+const findCustodySponsorRuleViolations = (transaction, resolvedInputs, context) => {
+	const analysis = analyse(transaction, resolvedInputs, context);
+	return RULES.flatMap((rule) => {
+		const violation = rule(analysis, context);
+		return violation ? [violation] : [];
+	});
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/state/transitions.ts
+/**
+* The state Lace creates an account with: `logic` as its rules, the creator
+* as the only device, generation zero and zero counters. The logic accepts
+* any generation at creation; consent refuses every other initial state.
+*
+* @param logic - the applied hash of the logic the account runs, normally the
+*   contract version's `currentLogicHash`
+*/
+const createInitialCustodyAccountState = (creatorKeyHash, logic) => {
+	if (!isHash28Hex(logic)) return fail$1({
+		code: "invalid-logic-hash",
+		logic
+	});
+	return isHash28Hex(creatorKeyHash) ? ok({
+		logic,
+		devices: [creatorKeyHash],
+		grantGeneration: 0n,
+		nextSlot: 0n,
+		revoked: [],
+		outstanding: 0n
+	}) : fail$1({
+		code: "invalid-device-key-hash",
+		device: creatorKeyHash
+	});
+};
+/** Checks a grant Lace is about to write: authoring rules, expiry, separation. */
+const checkAuthoredGrant = (state, grant, now) => {
+	const violations = findCustodyGrantViolations(grant);
+	if (violations.length > 0) return {
+		code: "invalid-grant",
+		violations
+	};
+	if (!Number.isFinite(now)) return {
+		code: "invalid-now",
+		now
+	};
+	if (isCustodyGrantExpired(grant, now)) return {
+		code: "grant-expired",
+		slot: grant.slot,
+		expiresAt: grant.scope.expiresAt
+	};
+	if (state.devices.includes(grant.grantee)) return {
+		code: "grantee-is-device",
+		grantee: grant.grantee
+	};
+};
+/**
+* Refuses a grantee that still holds a grant it could spend. One grant per
+* agent key keeps each agent's authority in one place, so a revocation or a
+* replacement always covers all of it. A grant judged against an older
+* state than its own counts too: it is in flight and about to be current.
+*/
+const checkGranteeHoldsNoCurrentGrant = (state, grants, { grantee, now }) => {
+	const held = grants.find((grant) => {
+		if (grant.grantee !== grantee) return false;
+		const liveness = custodyGrantLiveness(grant, state, now);
+		return liveness === "current" || liveness === "future-generation";
+	});
+	return held ? {
+		code: "grantee-has-grant",
+		grantee,
+		slot: held.slot
+	} : void 0;
+};
+/**
+* Issues one grant in the state's next slot under its current generation:
+* the next slot and the outstanding count move by one, and the result
+* carries the datum of the new grant UTxO.
+*
+* @param grants - every grant of the account, from its grant UTxOs and from
+*   issues still in flight, to keep one current grant per agent key
+*/
+const issueCustodyGrant = (state, { grantee, scope, now }, grants) => {
+	if (state.nextSlot >= CUSTODY_SLOT_LIMIT) return fail$1({
+		code: "slot-space-exhausted",
+		nextSlot: state.nextSlot
+	});
+	const grant = {
+		slot: state.nextSlot,
+		grantee,
+		generation: state.grantGeneration,
+		scope
+	};
+	const error = checkAuthoredGrant(state, grant, now) ?? checkGranteeHoldsNoCurrentGrant(state, grants, {
+		grantee,
+		now
+	});
+	if (error) return fail$1(error);
+	if (state.outstanding >= BigInt(16)) return fail$1({
+		code: "grant-limit",
+		limit: 16
+	});
+	return ok({
+		state: {
+			...state,
+			nextSlot: state.nextSlot + 1n,
+			outstanding: state.outstanding + 1n
+		},
+		grant
+	});
+};
+/**
+* Revokes the current grant in `slot` by appending the slot to the revoked
+* list. The grant UTxO stays until a sweep burns its token.
+*
+* @param grants - every grant of the account; the one in `slot` must be current
+*/
+const revokeCustodyGrant = (state, slot, grants) => {
+	const grant = grants.find((candidate) => candidate.slot === slot);
+	if (!grant) return fail$1({
+		code: "grant-not-found",
+		slot
+	});
+	if (!isCustodyGrantCurrent(grant, state)) return fail$1({
+		code: "grant-not-current",
+		slot,
+		liveness: custodyGrantLiveness(grant, state, 0)
+	});
+	if (state.revoked.length >= 32) return fail$1({
+		code: "revoked-list-full",
+		limit: 32
+	});
+	return ok({
+		...state,
+		revoked: [...state.revoked, slot]
+	});
+};
+/**
+* Revokes the current grant in `request.slot` and issues its replacement in
+* the next slot, in one state. Both happen in one transaction; the old
+* grant UTxO stays until a later sweep.
+*
+* @param grants - every grant of the account, as for `issueCustodyGrant`
+*/
+const replaceCustodyGrant = (state, { slot, ...request }, grants) => {
+	const revoked = revokeCustodyGrant(state, slot, grants);
+	return revoked.ok ? issueCustodyGrant(revoked.value, request, grants) : revoked;
+};
+/** Kills every grant: the generation moves on and the revoked list clears. */
+const revokeAllCustodyGrants = (state) => ({
+	...state,
+	grantGeneration: state.grantGeneration + 1n,
+	revoked: []
+});
+/**
+* Sweeps dead grants: their tokens burn, the outstanding count drops, and
+* their slots leave the revoked list. Pruning is safe because slots are never
+* reissued, and it keeps the list from filling up. Each grant must be dead
+* against `state`, the state before the sweep.
+*
+* @param grants - the grants to sweep, at most `CUSTODY_MAX_GRANT_BATCH`
+* @param now - POSIX milliseconds; a grant dead by expiry alone must have
+*   expired strictly before it, so a validity interval can start after the
+*   expiry
+*/
+const sweepCustodyGrants = (state, grants, now) => {
+	if (!Number.isFinite(now)) return fail$1({
+		code: "invalid-now",
+		now
+	});
+	if (grants.length === 0) return fail$1({ code: "sweep-empty" });
+	if (grants.length > 8) return fail$1({
+		code: "sweep-batch-limit",
+		count: grants.length,
+		limit: 8
+	});
+	const slots = /* @__PURE__ */ new Set();
+	let startsAfter;
+	for (const grant of grants) {
+		if (slots.has(grant.slot)) return fail$1({
+			code: "duplicate-grant-slot",
+			slot: grant.slot
+		});
+		slots.add(grant.slot);
+		const liveness = custodyGrantLiveness(grant, state, now);
+		const { expiresAt } = grant.scope;
+		if (!(liveness === "superseded" || liveness === "revoked" || liveness === "expired" && expiresAt < BigInt(Math.floor(now)))) return fail$1({
+			code: "grant-not-dead",
+			slot: grant.slot,
+			liveness
+		});
+		if (liveness === "expired" && (startsAfter === void 0 || expiresAt > startsAfter)) startsAfter = expiresAt;
+	}
+	return ok({
+		state: {
+			...state,
+			revoked: state.revoked.filter((slot) => !slots.has(slot)),
+			outstanding: state.outstanding - BigInt(grants.length)
+		},
+		...startsAfter !== void 0 && { startsAfter }
+	});
+};
+/**
+* Lists a new device key. Every device has full owner authority, so a key
+* that holds a current grant is refused: removing the device later would
+* leave the grant in force.
+*
+* @param grants - every grant of the account
+*/
+const addCustodyDevice = (state, device, grants) => {
+	if (!isHash28Hex(device)) return fail$1({
+		code: "invalid-device-key-hash",
+		device
+	});
+	if (state.devices.includes(device)) return fail$1({
+		code: "device-already-listed",
+		device
+	});
+	if (state.devices.length >= 8) return fail$1({
+		code: "device-limit",
+		limit: 8
+	});
+	const slots = grants.filter((grant) => grant.grantee === device && isCustodyGrantCurrent(grant, state)).map((grant) => grant.slot);
+	if (slots.length > 0) return fail$1({
+		code: "device-is-grantee",
+		device,
+		slots
+	});
+	return ok({
+		...state,
+		devices: [...state.devices, device]
+	});
+};
+/**
+* Removes a device key. Refuses when no well-formed device key would remain,
+* because the account would then accept no owner operation ever again. Grants
+* held by the same key stay in force.
+*/
+const removeCustodyDevice = (state, device) => {
+	const listed = state.devices.find((existing) => existing === device);
+	if (listed === void 0) return fail$1({
+		code: "device-not-listed",
+		device
+	});
+	const devices = state.devices.filter((existing) => existing !== device);
+	if (!devices.some((remaining) => isHash28Hex(remaining))) return fail$1({
+		code: "last-device",
+		device: listed
+	});
+	return ok({
+		...state,
+		devices
+	});
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/tx-construction/dist/esm/input-selection/selectionConstraints.js
+init__polyfill_buffer_patch();
+const MAX_U64 = 18446744073709551615n;
+const computeMinimumCoinQuantity = (coinsPerUtxoByte) => (output) => minAdaRequired(output, BigInt(coinsPerUtxoByte));
+const tokenBundleSizeExceedsLimit = (maxValueSize) => (tokenBundle) => {
+	if (!tokenBundle) return false;
+	const value = new Value(MAX_U64);
+	value.setMultiasset(tokenBundle);
+	return value.toCbor().length / 2 > maxValueSize;
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/estimate-signed-tx-size.ts
+const DUMMY_SIGNATURE = "f".repeat(128);
+const dummyVkey = (index) => index.toString(16).padStart(64, "0");
+/**
+* Byte length of `tx` once signed. Estimated exactly by populating one dummy
+* vkey witness per unique signer and letting the serializer measure the result
+* (the cardano-sdk `getTxSize` technique), which counts the real Conway witness
+* set framing, unlike a hand-summed byte formula.
+*
+* `resolvedInputs` must resolve every input so the signer count (input payment
+* keys plus withdrawal / certificate stake keys) is complete: an incomplete set
+* would under-count witnesses and under-estimate the size, the dangerous
+* direction for a size guard.
+*/
+const estimateSignedTxSize = (tx, resolvedInputs) => {
+	const core = tx.toCore();
+	const signerCount = getUniqueSignerKeyHashes(core, resolvedInputs).size;
+	const signatures = /* @__PURE__ */ new Map();
+	for (let index = 0; index < signerCount; index++) signatures.set(dummyVkey(index), DUMMY_SIGNATURE);
+	return Transaction.fromCore({
+		...core,
+		witness: {
+			...core.witness,
+			signatures
+		}
+	}).toCbor().length / 2;
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/tx-builder/transaction-limits.ts
+/**
+* Conway's cap on the reference-script bytes one transaction reads, summed
+* over its spent and reference inputs. A ledger constant, not a protocol
+* parameter.
+*/
+const MAX_REFERENCE_SCRIPT_SIZE_PER_TX = 204800;
+/** A built transaction would be refused by the ledger for exceeding a limit. */
+var TransactionLimitsExceededError = class extends Error {
+	constructor(exceeded, usage, limits) {
+		super(`Transaction exceeds protocol limits (${exceeded.join(", ")}): execution units ${usage.executionUnits.memory}/${limits.maxExecutionUnitsPerTransaction.memory} memory, ${usage.executionUnits.steps}/${limits.maxExecutionUnitsPerTransaction.steps} steps; signed size ${usage.signedTxSize}/${limits.maxTxSize} bytes; reference scripts ${usage.referenceScriptSize}/${MAX_REFERENCE_SCRIPT_SIZE_PER_TX} bytes`);
+		this.exceeded = exceeded;
+		this.usage = usage;
+		this.limits = limits;
+		this.name = "TransactionLimitsExceededError";
+	}
+};
+/**
+* Checks a built transaction against the per-transaction execution-unit,
+* size and reference-script limits, which `TransactionBuilder` does not
+* enforce. Run it on the final (evaluated) transaction. The size is measured
+* with one vkey witness per required signer, so `resolvedInputs` must resolve
+* every input and collateral input, as for `estimateSignedTxSize`. It must
+* also resolve every reference input, whose scripts count toward the
+* reference-script limit.
+*
+* @returns The measured usage when every limit holds.
+* @throws `TransactionLimitsExceededError` When any limit is exceeded.
+*/
+const assertWithinTransactionLimits = (tx, resolvedInputs, limits) => {
+	const redeemers = tx.witnessSet().redeemers()?.toCore() ?? [];
+	const body = tx.body().toCore();
+	const usage = {
+		executionUnits: redeemers.reduce((total, { executionUnits }) => ({
+			memory: total.memory + executionUnits.memory,
+			steps: total.steps + executionUnits.steps
+		}), {
+			memory: 0,
+			steps: 0
+		}),
+		signedTxSize: estimateSignedTxSize(tx, resolvedInputs),
+		referenceScriptSize: referenceScriptSize([...body.inputs, ...body.referenceInputs ?? []], resolvedInputs)
+	};
+	const exceeded = [];
+	if (usage.executionUnits.memory > limits.maxExecutionUnitsPerTransaction.memory) exceeded.push("executionMemory");
+	if (usage.executionUnits.steps > limits.maxExecutionUnitsPerTransaction.steps) exceeded.push("executionSteps");
+	if (usage.signedTxSize > limits.maxTxSize) exceeded.push("txSize");
+	if (usage.referenceScriptSize > MAX_REFERENCE_SCRIPT_SIZE_PER_TX) exceeded.push("referenceScriptSize");
+	if (exceeded.length > 0) throw new TransactionLimitsExceededError(exceeded, usage, limits);
+	return usage;
+};
+//#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 = 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 = 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 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 (tokenBundleSizeExceedsLimit(params.maxValueSize)(value.assets)) throw fail(`Output to ${address} exceeds the maximum token bundle size`, "invalid-output");
+	const minimumCoin = BigInt(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), 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 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 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([
+			firstValueFrom(cardano.cardanoNetworkMagic$),
+			firstValueFrom(cardanoContext.selectProtocolParameters$),
+			firstValueFrom(cardanoContext.selectTip$),
+			firstValueFrom(cardanoContext.selectEraSummaries$),
+			firstValueFrom(cardano.cardanoAccountUtxos$),
+			firstValueFrom(cardano.cardanoAccountUnspendableUtxos$),
+			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");
+		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: filterSpendableUtxos(accountUtxos[accountId] ?? [], unspendableUtxos[accountId] ?? []),
+			tipSlot: Number(tip.slot),
+			eraSummaries
+		});
+		return {
+			success: true,
+			serializedTx: result.cbor,
+			txId: result.txId,
+			fees: [{
+				tokenId: LOVELACE_TOKEN_ID,
+				amount: BigNumber(result.fee)
+			}]
+		};
+	} catch (error) {
+		return failure$1(error instanceof Error ? error : new Error(String(error)), error.code);
+	}
+};
+const makeComposerBuilding = () => (_, stateObservables, dependencies) => firstStateOfStatus(stateObservables.composerFlow.selectState$, "Building").pipe(switchMap((state) => from(buildComposition(state, stateObservables, dependencies)).pipe(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) => forkJoin([from(SodiumBip32Ed25519.create()), from(createTxInKeyPathMap(props.tx.body().toCore(), props.knownAddresses, createInputResolver(props.utxo)))]).pipe(mergeMap(([bip32Ed25519, txInKeyPathMap]) => {
+	const encryptedRootPrivateKeyBytes = ByteArray.fromHex(props.encryptedRootPrivateKey);
+	return from(new InMemoryKeyAgent({
+		accountIndex: props.accountIndex,
+		chainId: props.chainId,
+		encryptedRootPrivateKeyBytes: [...encryptedRootPrivateKeyBytes],
+		extendedAccountPublicKey: props.extendedAccountPublicKey,
+		getPassphrase: async () => props.authSecret,
+		purpose: KeyPurpose.STANDARD
+	}, {
+		bip32Ed25519,
+		logger,
+		rootPrivateKeyEncryption: SecretBox.isSealed(encryptedRootPrivateKeyBytes) ? {
+			encrypt: SecretBox.seal,
+			decrypt: SecretBox.open
+		} : void 0
+	}).signTransaction(props.tx.body(), {
+		knownAddresses: props.knownAddresses,
+		txInKeyPathMap,
+		scripts: props.tx.toCore().witness.scripts
+	})).pipe(map((signatures) => {
+		const witnessSet = props.tx.witnessSet();
+		applyVkeyWitnesses(witnessSet, signatures);
+		props.tx.setWitnessSet(witnessSet);
+		return Ok$1(props.tx);
+	}));
+}), catchError((error) => of(Err$1({
+	code: "SIGNING_FAILED",
+	message: error.message
+})))) } });
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/build-failure.ts
+/**
+* Stops a custody build with a typed reason. The build side effect reports
+* it as the failure; any other error thrown during a build is a defect and
+* is reported as `build-failed`.
+*/
+var CustodyBuildFailure = class extends Error {
+	constructor(reason) {
+		super(`Custody transaction build failed: ${reason.code}`);
+		this.reason = reason;
+		this.name = "CustodyBuildFailure";
+	}
+};
+const failCustodyBuild = (reason) => {
+	throw new CustodyBuildFailure(reason);
+};
+/**
+* The build failure a state transition's refusal stands for. A full account
+* the owner can act on has its own code: sweep dead grants to free the
+* outstanding count or the revoked list, or wait for a grant to die.
+*/
+const transitionFailureOf = (error) => {
+	if (error.code === "grant-limit" || error.code === "revoked-list-full") return {
+		code: error.code,
+		limit: error.limit
+	};
+	if (error.code === "grant-not-dead") return {
+		code: "sweep-not-dead",
+		slot: error.slot,
+		liveness: error.liveness
+	};
+	return {
+		code: "invalid-operation",
+		reason: "state-transition",
+		error
+	};
+};
+/** What a library transition produced, or the build refused with its reason. */
+const transitioned = (result) => result.ok ? result.value : failCustodyBuild(transitionFailureOf(result.error));
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-execution-estimate.ts
+/**
+* Net memory units of one run of each handler: the largest figure the
+* budget table of contract b48545f's security review ("Resource
+* exhaustion": `aiken check -D` less each fixture's baseline, over the
+* largest state) gives for a transaction Lace builds, which issues one
+* grant, sweeps at most eight and spends at most twelve funds.
+*/
+const HANDLER_NET_MEMORY = {
+	device: 48e4,
+	spendWithGrant: 4e5,
+	sweepGrant: 43e4,
+	fund: 2e5,
+	issueGrants: 15e4,
+	burnGrants: 34e4,
+	createAccount: 15e4,
+	operate: 16e4
+};
+/**
+* Net memory units of the logic run per path, from the same table, and
+* what each issued grant, swept grant and fund input adds: the owner path
+* runs 1.11 M for a revoke, 1.99 M issuing one grant, 1.54 M sweeping one
+* and 1.21 M with a reserve beside the control; the agent path 1.96 M over
+* one deposit and 5.94 M over forty.
+*
+* Summed per transaction they reach at least the review's figures, given
+* in brackets: a creation 0.75 M (0.73 M), a revoke 1.59 M (1.33 M), an
+* issue 2.62 M (2.41 M), a sweep of eight 8.81 M (8.08 M) and an agent
+* spend over eight funds 4.76 M (4.17 M).
+*/
+const LOGIC_NET_MEMORY = {
+	path: {
+		agent: 196e4,
+		arrival: 44e4,
+		owner: 111e4
+	},
+	issuedGrant: 88e4,
+	sweptGrant: 43e4,
+	fund: 1e5
+};
+/**
+* What one run is expected to cost on chain, as a multiple of its net
+* figure. The runner leaves out decoding the script context, which every
+* run pays and which grows with the transaction. On upstream's devnet with
+* Preprod's parameters (docs/devnet-evidence.md, "Budget comparison") a
+* revoke over the largest state measured 1.74 M against 1.10 M net, a
+* sweep of eight 9.20 M against 8.26 M and an agent spend over twelve
+* deposits 4.28 M. A transaction that measures above the estimate is
+* reseeded once at the measurement.
+*/
+const CUSTODY_EXECUTION_ESTIMATE_FACTOR = 2;
+/**
+* CPU steps the estimate charges per memory unit. Every redeemer of the
+* devnet run measured between 290 and 460 steps per memory unit, the
+* smallest Fund runs at the top of that range; the large logic and proxy
+* runs, which dominate every total, stay below 370.
+*/
+const CUSTODY_ESTIMATE_STEPS_PER_MEMORY_UNIT = 400;
+/**
+* What a reseed adds to the measured execution units, in percent. The
+* measurement already holds the evaluation margin; this one covers the
+* reseeded transaction measuring differently, since a higher fee changes
+* its change output.
+*/
+const CUSTODY_RESEED_MARGIN_PERCENT = 10;
+const withReseedMargin = (units) => Math.ceil(units * (100 + CUSTODY_RESEED_MARGIN_PERCENT) / 100);
+const logicNetMemory = ({ logic, issueGrants = 0, sweepGrant = 0, fund = 0 }) => logic ? LOGIC_NET_MEMORY.path[logic] + LOGIC_NET_MEMORY.issuedGrant * issueGrants + LOGIC_NET_MEMORY.sweptGrant * sweepGrant + LOGIC_NET_MEMORY.fund * fund : 0;
+/**
+* The execution units a transaction that runs `runs` is expected to
+* measure: the handlers' and the logic's net memory units times the
+* estimate factor, and steps in proportion. It is not capped at the
+* per-transaction limit.
+*/
+const custodyExecutionEstimate = (runs) => {
+	const memory = Object.keys(HANDLER_NET_MEMORY).reduce((total, handler) => total + HANDLER_NET_MEMORY[handler] * (runs[handler] ?? 0), logicNetMemory(runs)) * CUSTODY_EXECUTION_ESTIMATE_FACTOR;
+	return {
+		memory,
+		steps: memory * CUSTODY_ESTIMATE_STEPS_PER_MEMORY_UNIT
+	};
+};
+/**
+* The plan's estimate within the per-transaction limit, which no valid
+* transaction exceeds: what balancing prices a plan's fee at until a
+* reseed.
+*/
+const estimateWithinLimit = (estimate, limit) => ({
+	memory: Math.min(estimate.memory, limit.memory),
+	steps: Math.min(estimate.steps, limit.steps)
+});
+/** What a build learned from redeemers that measured above `seeded`. */
+const custodyReseedOf = (evaluated, seeded) => {
+	const sum = evaluated.reduce((total, units) => ({
+		memory: total.memory + units.memory,
+		steps: total.steps + units.steps
+	}), {
+		memory: 0,
+		steps: 0
+	});
+	return {
+		measured: {
+			memory: Math.max(sum.memory, seeded.memory),
+			steps: Math.max(sum.steps, seeded.steps)
+		},
+		redeemers: evaluated.length,
+		dearest: {
+			memory: Math.max(0, ...evaluated.map(({ memory }) => memory)),
+			steps: Math.max(0, ...evaluated.map(({ steps }) => steps))
+		}
+	};
+};
+/**
+* What a reseed prices a plan of `redeemers` redeemers at: the measurement
+* plus the reseed margin, with each redeemer the plan has beyond the
+* measured transaction, such as a fund input the selection round added,
+* priced as the dearest one measured. It is not capped at the
+* per-transaction limit, so a transaction over the limit still builds and
+* its limit check reports the overrun.
+*/
+const reseededExecutionUnits = ({ measured, redeemers: measuredRedeemers, dearest }, redeemers) => {
+	const added = Math.max(0, redeemers - measuredRedeemers);
+	return {
+		memory: withReseedMargin(measured.memory + added * dearest.memory),
+		steps: withReseedMargin(measured.steps + added * dearest.steps)
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-assembly.ts
+/**
+* The account's control output: lovelace and the state NFT only, with the
+* state encoded afresh as an inline datum.
+*/
+const controlOutputOf = (identity, state, lovelace) => ({
+	address: identity.address,
+	value: {
+		coins: lovelace,
+		assets: new Map([[identity.stateNftAssetId, 1n]])
+	},
+	datum: encodeCustodyAccountState(state)
+});
+/**
+* A grant UTxO at the account: lovelace and the grant's token only, with
+* the grant as an inline datum and no reference script.
+*/
+const grantOutputOf = (identity, grant, lovelace) => ({
+	address: identity.address,
+	value: {
+		coins: lovelace,
+		assets: new Map([[custodyGrantAssetId({
+			accountValidatorHash: identity.contractVersion.accountValidatorHash,
+			stakeScriptHash: identity.stakeScriptHash
+		}, grant.slot), 1n]])
+	},
+	datum: encodeCustodyGrant(grant)
+});
+/**
+* The least lovelace an output holds at its own size, at least `floor`. The
+* coin's own width changes the size, so the minimum is taken until it
+* settles.
+*/
+const outputLovelaceFor = (outputWith, floor, coinsPerUtxoByte) => {
+	let lovelace = floor;
+	for (;;) {
+		const minimum = minAdaRequired(outputWith(lovelace), BigInt(coinsPerUtxoByte));
+		if (minimum <= lovelace) return lovelace;
+		lovelace = minimum;
+	}
+};
+/**
+* The lovelace a control output carrying `state` holds: at least `floor`
+* and at least the minimum for its size.
+*/
+const controlLovelaceFor = ({ identity, state, floor }, coinsPerUtxoByte) => outputLovelaceFor((lovelace) => controlOutputOf(identity, state, lovelace), floor, coinsPerUtxoByte);
+/** What `units` of execution cost at the protocol's prices. */
+const executionFeeOf = (units, { prices }) => BigInt(Math.ceil(prices.memory * units.memory + prices.steps * units.steps));
+/**
+* The most the builder prices a fee at before evaluation, when it seeds
+* `seed` execution units: the largest transaction's size fee plus the seed
+* at the protocol's prices. Balancing must fund that fee from the inputs
+* before evaluation lowers it.
+*/
+const preEvaluationFeeBound = (parameters, seed) => BigInt(parameters.minFeeConstant) + BigInt(parameters.minFeeCoefficient) * BigInt(parameters.maxTxSize) + executionFeeOf(seed, parameters);
+/**
+* The least fee a plan's transaction pays, whatever its body and its
+* scripts measure: the size fee of the scripts it attaches and the
+* reference-script fee of the scripts its reference inputs carry.
+*/
+const leastFeeOf = (plan, parameters) => {
+	const references = plan.referenceInputs ?? [];
+	return BigInt(parameters.minFeeConstant) + BigInt(parameters.minFeeCoefficient) * BigInt(plan.scripts.reduce((bytes, script) => bytes + script.bytes.length / 2, 0)) + referenceScriptFee(referenceScriptSize(references.map(([txIn]) => txIn), references), parameters);
+};
+/**
+* The fee a plan is expected to balance at before evaluation, less the
+* bytes of its body beyond its scripts: its least fee and its seed
+* execution units at the protocol's prices. Fund selection aims at it; a
+* selection that falls short gains the next fund UTxO when balancing
+* fails, before any evaluation.
+*/
+const plannedFeeOf = (plan, parameters) => leastFeeOf(plan, parameters) + executionFeeOf(estimateWithinLimit(plan.executionEstimate, parameters.maxExecutionUnitsPerTransaction), parameters);
+const quantityOf = (utxo, assetId) => utxo[1].value.assets?.get(assetId) ?? 0n;
+const byCoinsDescending = (a, b) => a[1].value.coins === b[1].value.coins ? 0 : a[1].value.coins > b[1].value.coins ? -1 : 1;
+/**
+* Large-First selection over fund UTxOs: first the UTxOs holding most of
+* each requested asset, then the largest by lovelace, with `reserves` after
+* every fund. When the UTxOs cannot cover the target, everything is
+* selected, `covers` is false and the build decides: the target holds only
+* an estimate of the fee.
+*/
+const selectFunds = (funds, target, reserves = []) => {
+	const remaining = [...[...funds].sort(byCoinsDescending), ...[...reserves].sort(byCoinsDescending)];
+	const selected = [];
+	const take = (utxo) => {
+		remaining.splice(remaining.indexOf(utxo), 1);
+		selected.push(utxo);
+	};
+	for (const [assetId, quantity] of target.assets ?? []) {
+		let covered = selected.reduce((sum, utxo) => sum + quantityOf(utxo, assetId), 0n);
+		while (covered < quantity) {
+			const richest = remaining.reduce((best, utxo) => !best || quantityOf(utxo, assetId) > quantityOf(best, assetId) ? utxo : best, void 0);
+			if (!richest || quantityOf(richest, assetId) === 0n) return {
+				selected: [...selected, ...remaining],
+				remaining: [],
+				covers: false
+			};
+			take(richest);
+			covered += quantityOf(richest, assetId);
+		}
+	}
+	let lovelace = selected.reduce((sum, [, output]) => sum + output.value.coins, 0n);
+	while (lovelace < target.coins && remaining.length > 0) {
+		const [next] = remaining;
+		take(next);
+		lovelace += next[1].value.coins;
+	}
+	return {
+		selected,
+		remaining,
+		covers: lovelace >= target.coins
+	};
+};
+/** The sum of outputs' values. */
+const totalValueOf = (outputs) => {
+	const assets = /* @__PURE__ */ new Map();
+	let coins = 0n;
+	for (const { value } of outputs) {
+		coins += value.coins;
+		for (const [assetId, quantity] of value.assets ?? []) assets.set(assetId, (assets.get(assetId) ?? 0n) + quantity);
+	}
+	return {
+		coins,
+		assets
+	};
+};
+/**
+* The funds can no longer pay for the transaction; one more fund UTxO may.
+* Once none is left, the build fails with `exhausted`, or with
+* `insufficient-funds` when it is absent.
+*/
+var FundShortfall = class extends Error {
+	constructor(message, exhausted) {
+		super(message);
+		this.exhausted = exhausted;
+		this.name = "FundShortfall";
+	}
+};
+/**
+* The evaluated transaction needs a larger fee than its plan balanced at:
+* the scripts measured above the execution estimate. Building again seeded
+* from `reseed` funds it.
+*/
+var ExecutionEstimateShortfall = class extends Error {
+	constructor(reseed) {
+		super("The scripts measure above the execution estimate");
+		this.reseed = reseed;
+		this.name = "ExecutionEstimateShortfall";
+	}
+};
+/**
+* The transaction needs a fee above the most it may be balanced at. `fee`
+* is the fee it needs, or, when even the fee of its body without execution
+* is above that most, that fee. `evaluatedRedeemers` holds the budgets the
+* fee was priced at when an evaluation priced it.
+*/
+var MaxBalancedFeeExceeded = class extends Error {
+	constructor(fee, evaluatedRedeemers = []) {
+		super(`The transaction needs a fee of ${fee} lovelace, above the most it may be balanced at`);
+		this.fee = fee;
+		this.evaluatedRedeemers = evaluatedRedeemers;
+		this.name = "MaxBalancedFeeExceeded";
+	}
+};
+/** The builder balanced a draft above the most fee allowed; nothing evaluated it. */
+var DraftFeeAboveMax = class extends Error {
+	constructor(fee) {
+		super(`The draft is balanced at ${fee} lovelace, above the most allowed`);
+		this.fee = fee;
+		this.name = "DraftFeeAboveMax";
+	}
+};
+/** Stops a draft balanced above `maxFee` before the provider evaluates it. */
+const withMaxDraftFee = (evaluator, maxFee) => ({ evaluate: async (tx, resolvedInputs) => {
+	if (tx.body.fee > maxFee) throw new DraftFeeAboveMax(tx.body.fee);
+	return evaluator.evaluate(tx, resolvedInputs);
+} });
+/**
+* `seed` scaled so that its execution costs at most `fee` at the protocol's
+* prices, which are linear in the units.
+*/
+const seedPricedAt = (seed, fee, parameters) => {
+	const seedFee = executionFeeOf(seed, parameters);
+	if (seedFee === 0n) return seed;
+	const scale = Number(fee) / Number(seedFee);
+	return {
+		memory: Math.floor(seed.memory * scale),
+		steps: Math.floor(seed.steps * scale)
+	};
+};
+/**
+* Seed changes that keep a draft within the most fee it may be balanced
+* at. A draft lands within a few bytes of the fee its seed aims at, so one
+* change usually suffices.
+*/
+const MAX_DRAFT_FEE_ROUNDS = 4;
+/**
+* The plain change output a collateral-mode build returns to the account:
+* the largest output at `address` after the planned ones, without a datum.
+* -1 when there is none.
+*/
+const changeIndexOf = (outputs, address, plannedCount) => {
+	let changeIndex = -1;
+	for (const [index, output] of outputs.entries()) if (index >= plannedCount && output.address === address && output.datum === void 0 && output.datumHash === void 0 && (changeIndex < 0 || output.value.coins > outputs[changeIndex].value.coins)) changeIndex = index;
+	return changeIndex;
+};
+const withBody = (transaction, fields) => {
+	const core = transaction.toCore();
+	return Transaction.fromCore({
+		...core,
+		body: {
+			...core.body,
+			...fields
+		}
+	});
+};
+const hasGrown = (rewritten, transaction) => rewritten.body().toCbor().length > transaction.body().toCbor().length;
+const grewBody = () => failCustodyBuild({
+	code: "build-failed",
+	message: "Moving lovelace between outputs grew the body"
+});
+/**
+* The transaction with `outputs` in place of its own. The fee was priced
+* for the body's size, so the body must not grow, as it would when a coin
+* crosses a CBOR width boundary. A smaller body keeps a fee that also pays
+* for the bytes it dropped.
+*/
+const withOutputs = (transaction, outputs) => {
+	const rewritten = withBody(transaction, { outputs });
+	return hasGrown(rewritten, transaction) ? grewBody() : rewritten;
+};
+/** `output` holding `coins` lovelace. */
+const withCoins = (output, coins) => ({
+	...output,
+	value: {
+		...output.value,
+		coins
+	}
+});
+/**
+* The transaction with `outputs` in place of its own and its fee raised by
+* `excess`. The declared collateral rises with the fee, taken from the
+* collateral return, which must keep its minimum ADA.
+*/
+const withExcessInFee = (transaction, { outputs, excess }, { collateralPercentage, coinsPerUtxoByte }) => {
+	const { fee, totalCollateral, collateralReturn } = transaction.body().toCore();
+	const raised = fee + excess;
+	const required = (raised * BigInt(collateralPercentage) + 99n) / 100n;
+	let collateral = {};
+	if (totalCollateral !== void 0 && totalCollateral < required) {
+		const returned = collateralReturn && withCoins(collateralReturn, collateralReturn.value.coins - (required - totalCollateral));
+		if (!returned || returned.value.coins < minAdaRequired(returned, BigInt(coinsPerUtxoByte))) return failCustodyBuild({
+			code: "collateral-insufficient",
+			message: `The collateral cannot cover a fee of ${raised} lovelace`
+		});
+		collateral = {
+			totalCollateral: required,
+			collateralReturn: returned
+		};
+	}
+	const rewritten = withBody(transaction, {
+		outputs,
+		fee: raised,
+		...collateral
+	});
+	return hasGrown(rewritten, transaction) ? grewBody() : rewritten;
+};
+/**
+* Moves the lovelace the builder's fee correction credited to a planned
+* output back to the change. The correction refunds the largest output at
+* the change address, and in collateral mode the planned account outputs
+* share that address: a control output would lock the lovelace for the
+* account's life, and a grant output must hold what was planned.
+*
+* The change takes it unless that grows the body the fee was priced for,
+* which happens only when its lovelace crosses 2^32; the fee then keeps
+* the saving instead.
+*
+* @throws `FundShortfall` when no change output exists to take it
+*/
+const restorePlannedOutputs = (transaction, plan, parameters) => {
+	const outputs = [...transaction.body().toCore().outputs];
+	let excess = 0n;
+	for (const [index, planned] of plan.outputs.entries()) {
+		const credited = outputs[index].value.coins - planned.value.coins;
+		if (credited > 0n) {
+			excess += credited;
+			outputs[index] = withCoins(outputs[index], planned.value.coins);
+		}
+	}
+	if (excess === 0n) return transaction;
+	const changeIndex = changeIndexOf(outputs, plan.changeAddress, plan.outputs.length);
+	if (changeIndex < 0) throw new FundShortfall("No change output to return the fee saving to");
+	const credited = [...outputs];
+	credited[changeIndex] = withCoins(outputs[changeIndex], outputs[changeIndex].value.coins + excess);
+	const rewritten = withBody(transaction, { outputs: credited });
+	return hasGrown(rewritten, transaction) ? withExcessInFee(transaction, {
+		outputs,
+		excess
+	}, parameters) : rewritten;
+};
+/**
+* The lovelace the first output of a plan whose first output pays the fee
+* must hold to balance at the fee the builder settled on.
+*/
+var FirstOutputCoinsMissed = class extends Error {
+	constructor(coins) {
+		super(`The first output must hold ${coins} lovelace to balance`);
+		this.coins = coins;
+		this.name = "FirstOutputCoinsMissed";
+	}
+};
+/**
+* Coin selection for a plan whose first output pays the fee: it spends
+* exactly the preselected inputs and returns no change. The balancer prices
+* each target and asks again until the fee settles; when the settled target
+* still misses the inputs, the build stops with the first output's lovelace
+* that meets it.
+*/
+const firstOutputPaysSelector = (firstOutputCoins) => {
+	let previousTarget;
+	return { select: ({ preSelectedUtxo = [], targetValue }) => {
+		const surplus = preSelectedUtxo.reduce((total, [, output]) => total + output.value.coins, 0n) - targetValue.coins;
+		if (surplus !== 0n && previousTarget === targetValue.coins) throw new FirstOutputCoinsMissed(firstOutputCoins + surplus);
+		previousTarget = targetValue.coins;
+		return {
+			selection: [...preSelectedUtxo],
+			remaining: [],
+			changeOutputs: []
+		};
+	} };
+};
+/**
+* Builds and balances one plan with the shared `TransactionBuilder`. Every
+* input is preselected, so balancing never adds an input without its
+* redeemer; the collateral is the sponsor's shared UTxO, returned to the
+* sponsor with total collateral set.
+*
+* @throws `FundShortfall` when the inputs cannot pay for the transaction
+* @throws `EvaluatedFeeShortfallError` when the scripts measure above `seed`
+*   by more than the balanced fee covers
+*/
+const buildPlan = async (plan, chain, { evaluator, coinSelector, seed }) => {
+	const parameters = chain.protocolParameters;
+	const referenceInputs = plan.referenceInputs ?? [];
+	const builder = new TransactionBuilder(chain.chainId.networkMagic, parameters).setChangeAddress(plan.changeAddress).useCoinSelector(coinSelector).setCollateralUtxos([plan.collateral.utxo]).setCollateralChangeAddress(plan.collateral.returnAddress).setPlutusContext({
+		costModels: parameters.costModels,
+		txEvaluator: evaluator,
+		inputResolver: createInputResolver([...plan.inputs.map(({ utxo }) => utxo), plan.collateral.utxo]),
+		executionUnitsEstimate: seed
+	}).setValidityInterval({
+		...plan.invalidBefore !== void 0 && { invalidBefore: plan.invalidBefore },
+		invalidHereafter: plan.invalidHereafter
+	}).addRequiredSigner(plan.requiredSigner);
+	for (const { utxo, redeemer } of plan.inputs) builder.addInput(utxo, redeemer ? { redeemer } : void 0);
+	for (const utxo of referenceInputs) builder.addReferenceInput(utxo);
+	for (const output of plan.outputs) builder.addOutput(output);
+	for (const script of plan.scripts) builder.attachScript(script);
+	if (plan.mint) builder.mintAssets(plan.mint.assets, plan.mint.redeemer);
+	if (plan.registration) {
+		const { stakeCredential, deposit, redeemer } = plan.registration;
+		builder.addNewStakeAddressCertificate(stakeCredential, deposit, { redeemer });
+	}
+	if (plan.delegation) {
+		const { poolId, stakeCredential, redeemer } = plan.delegation;
+		builder.addStakeDelegationCertificate(poolId, stakeCredential, { redeemer });
+	}
+	for (const { rewardAccount, quantity, redeemer } of plan.withdrawals ?? []) builder.addScriptWithdrawal(rewardAccount, quantity, redeemer);
+	for (const [label, metadatum] of plan.metadata ?? []) builder.setMetadata(label, metadatum);
+	try {
+		return await builder.build();
+	} catch (error) {
+		if (error instanceof InputSelectionError) throw new FundShortfall(error.message);
+		if (error instanceof InsufficientCollateralError) return failCustodyBuild({
+			code: "collateral-insufficient",
+			message: error.message
+		});
+		throw error;
+	}
+};
+/**
+* Rounds of a plan whose first output pays the fee. The first round finds
+* the fee the builder settles on, the second lands on it; a third covers a
+* coin that crossed a CBOR width between them.
+*/
+const MAX_FIRST_OUTPUT_ROUNDS = 3;
+/**
+* Builds a plan whose first output pays the fee. The builder balances at a
+* fee priced for the seed execution units, so the first output is set to
+* what the inputs hold beyond that fee and the other outputs; once
+* evaluation lowers the fee, the builder refunds the saving to it, the
+* largest output at the change address.
+*
+* @throws `FundShortfall` when the inputs cannot pay the fee the builder
+*   balances at
+*/
+const buildFeePaidByFirstOutput = async (plan, chain, { evaluator, seed }) => {
+	const [first, ...rest] = plan.outputs;
+	let coins = first.value.coins;
+	for (let round = 1;; round++) try {
+		return await buildPlan({
+			...plan,
+			outputs: [withCoins(first, coins), ...rest]
+		}, chain, {
+			evaluator,
+			coinSelector: firstOutputPaysSelector(coins),
+			seed
+		});
+	} catch (error) {
+		if (!(error instanceof FirstOutputCoinsMissed) || round >= MAX_FIRST_OUTPUT_ROUNDS) throw error;
+		if (error.coins < 0n) throw new FundShortfall("The first output cannot pay the fee the builder balances at");
+		coins = error.coins;
+	}
+};
+/** How many redeemers a plan's transaction carries. */
+const redeemerCountOf = (plan) => plan.inputs.filter(({ redeemer }) => redeemer !== void 0).length + [
+	plan.mint,
+	plan.registration,
+	plan.delegation
+].filter((part) => part !== void 0).length + (plan.withdrawals?.length ?? 0);
+/**
+* Builds a plan, adding the next fund UTxO each time the selected ones
+* cannot pay for it. Once none is left, it refuses with the shortfall's
+* reason, `insufficient-funds` by default. Planned outputs keep their
+* lovelace unless the first output pays the fee.
+*
+* With `maxBalancedFee`, a draft balanced above it gets a seed priced at
+* that much less, and an evaluated transaction that needs more than its
+* draft's fee gets a seed priced at what it needs, while that fits.
+*
+* @throws `ExecutionEstimateShortfall` when the scripts measure above the
+*   seed by more than the balanced fee covers
+* @throws `MaxBalancedFeeExceeded` when the transaction needs a fee above
+*   `maxBalancedFee`
+*/
+const assembleWithFunds = async ({ chain, funds, plan, evaluator, reseed, checkFunds, settle, maxBalancedFee }) => {
+	const parameters = chain.protocolParameters;
+	let { selected, remaining } = funds;
+	let seedFeeLimit;
+	let draftFeeRounds = 0;
+	for (;;) {
+		checkFunds?.(selected);
+		const planned = plan(selected);
+		const fullSeed = reseed ? reseededExecutionUnits(reseed, redeemerCountOf(planned)) : estimateWithinLimit(planned.executionEstimate, parameters.maxExecutionUnitsPerTransaction);
+		const seed = seedFeeLimit === void 0 ? fullSeed : seedPricedAt(fullSeed, seedFeeLimit, parameters);
+		const planEvaluator = maxBalancedFee === void 0 ? evaluator(selected) : withMaxDraftFee(evaluator(selected), maxBalancedFee);
+		try {
+			const built = planned.isFeePaidByFirstOutput ? await buildFeePaidByFirstOutput(planned, chain, {
+				evaluator: planEvaluator,
+				seed
+			}) : restorePlannedOutputs(await buildPlan(planned, chain, {
+				evaluator: planEvaluator,
+				coinSelector: new LargeFirstCoinSelector(),
+				seed
+			}), planned, parameters);
+			return {
+				transaction: settle ? settle(built) : built,
+				funds: {
+					selected,
+					remaining
+				}
+			};
+		} catch (error) {
+			if (error instanceof DraftFeeAboveMax && maxBalancedFee !== void 0) {
+				const seedFee = executionFeeOf(seed, parameters);
+				const limit = seedFee - (error.fee - maxBalancedFee);
+				if (limit < 0n) throw new MaxBalancedFeeExceeded(error.fee - seedFee);
+				if (++draftFeeRounds > MAX_DRAFT_FEE_ROUNDS) throw new MaxBalancedFeeExceeded(error.fee);
+				seedFeeLimit = limit;
+				continue;
+			}
+			if (error instanceof EvaluatedFeeShortfallError) {
+				if (maxBalancedFee !== void 0 && error.requiredFee > maxBalancedFee) throw new MaxBalancedFeeExceeded(error.requiredFee, error.evaluatedRedeemers);
+				if (seedFeeLimit !== void 0 && ++draftFeeRounds <= MAX_DRAFT_FEE_ROUNDS) {
+					seedFeeLimit = executionFeeOf(seed, parameters) + error.requiredFee - error.balancedFee;
+					continue;
+				}
+				throw new ExecutionEstimateShortfall(custodyReseedOf(error.evaluatedRedeemers.map(({ executionUnits }) => executionUnits), seed));
+			}
+			if (!(error instanceof FundShortfall)) throw error;
+			if (remaining.length === 0) return failCustodyBuild(error.exhausted ?? {
+				code: "insufficient-funds",
+				message: error.message
+			});
+			selected = [...selected, remaining[0]];
+			remaining = remaining.slice(1);
+		}
+	}
+};
+const EVALUATION_MARGIN_PERCENT = 10n;
+/**
+* Pads a measured budget. The fee correction after evaluation changes the
+* body the scripts see, so the final transaction is not the one measured.
+*/
+const withEvaluationMargin = ({ memory, steps }) => ({
+	memory: Number((BigInt(memory) * (100n + EVALUATION_MARGIN_PERCENT) + 99n) / 100n),
+	steps: Number((BigInt(steps) * (100n + EVALUATION_MARGIN_PERCENT) + 99n) / 100n)
+});
+const atLeast = (budget, floor) => floor ? {
+	memory: Math.max(budget.memory, floor.memory),
+	steps: Math.max(budget.steps, floor.steps)
+} : budget;
+const redeemerKey = ({ purpose, index }) => `${purpose}:${index}`;
+/** A redeemer the provider did not evaluate fails, as it does for the sponsor service. */
+const unmeasured = ({ purpose, index }) => failCustodyBuild({
+	code: "script-evaluation-failed",
+	message: `The provider did not evaluate redeemer ${purpose}#${index}`
+});
+/**
+* Every redeemer whose declared budget is below what the provider measures,
+* with the measurement.
+*/
+const findUnderDeclaredBudgets = (transaction, measured) => {
+	return (transaction.witnessSet().redeemers()?.toCore() ?? []).flatMap(({ purpose, index, executionUnits }) => {
+		const measurement = measured.find((entry) => entry.purpose === purpose && entry.index === index) ?? unmeasured({
+			purpose,
+			index
+		});
+		return measurement.budget.memory > executionUnits.memory || measurement.budget.steps > executionUnits.steps ? [measurement] : [];
+	});
+};
+/**
+* The outputs a transaction's inputs, reference inputs and collateral
+* resolve to, in that order, from the UTxOs the build chose them from.
+*/
+const resolvedInputsOf = (transaction, candidates) => {
+	const body = transaction.body().toCore();
+	const byOutpoint = new Map(candidates.map((utxo) => [outpointKey$1(utxo[0]), utxo]));
+	return [
+		...body.inputs,
+		...body.referenceInputs ?? [],
+		...body.collaterals ?? []
+	].map((input) => byOutpoint.get(outpointKey$1(input))).filter((utxo) => utxo !== void 0);
+};
+/** A lovelace amount whose CBOR width every change output reaches. */
+const CHANGE_COIN_WIDTH_PROBE = 1000000n;
+/** The minimum ADA of a lovelace-only change output at an address. */
+const changeReserveAt = (address, coinsPerUtxoByte) => minAdaRequired({
+	address,
+	value: { coins: CHANGE_COIN_WIDTH_PROBE }
+}, BigInt(coinsPerUtxoByte));
+const scriptCredentialOf = (hash) => ({
+	type: CredentialType.ScriptHash,
+	hash
+});
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/night-designation/unwrap-provider-result.ts
+/**
+* Take the single value a `CardanoProvider` call emits, turning a failed
+* `Result` into a thrown error so the designation side-effects can gather
+* their reads and catch every failure in one place. Transient failures are
+* retried first (ADR 15 tier-1).
+*
+* Observable rather than `Promise`: `retryBackoff`'s waits are only virtual
+* while they stay on a scheduler the `TestScheduler` can drive, and a promise
+* anywhere in a side-effect's pipeline forfeits marble testing for the whole
+* of it (docs/rxjs-guidelines.md). A promise-shaped caller wraps this in
+* `firstValueFrom`; a side-effect composes it.
+*
+* Takes a request FACTORY, not an observable: the provider builds its
+* observable over an already-in-flight promise, which replays its settled
+* value to every later subscriber — so a retry that re-subscribed would
+* replay the same failure instead of reaching the network. The factory is a
+* caller-side stand-in for a cold provider method; drop it, and take the
+* observable directly, once every method this calls mints its promise on
+* subscribe.
+*
+* A provider that rejects with a non-`Error` is wrapped rather than thrown
+* as-is, so the catch site can always read `.name` / `.message`.
+*/
+const unwrapProviderResult = (request) => defer(request).pipe(map((result) => {
+	if (!result.isOk()) throw result.error instanceof Error ? result.error : new Error(String(result.error));
+	return result.value;
+}), retryBackoff(PROVIDER_REQUEST_RETRY_CONFIG), first());
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-chain.ts
+/**
+* The slot clock of the era history. A time or slot before the first era
+* is read in the first era: custody transactions only name slots near the
+* present.
+*/
+const createSlotClock = (eraSummaries) => {
+	const eraOf = (isStarted) => eraSummaries.filter(isStarted).at(-1) ?? eraSummaries[0];
+	return {
+		slotAt: (posixMs) => {
+			const era = eraOf(({ start }) => start.time.getTime() <= posixMs);
+			return Slot(era.start.slot + Math.floor((posixMs - era.start.time.getTime()) / era.parameters.slotLength));
+		},
+		slotStart: (slot) => {
+			const era = eraOf(({ start }) => start.slot <= slot);
+			return era.start.time.getTime() + (slot - era.start.slot) * era.parameters.slotLength;
+		}
+	};
+};
+/**
+* One provider read, retried while transient. A failure stops the build as
+* `unavailable`, since nothing about the custody account is known yet.
+*/
+const readFromProvider = async (what, request) => {
+	try {
+		return await firstValueFrom(unwrapProviderResult(request));
+	} catch (error) {
+		return failCustodyBuild({
+			code: "unavailable",
+			message: `${what}: ${messageOf(error)}`
+		});
+	}
+};
+const loadCustodyChain = async ({ chainId, eraSummaries, provider, now }) => {
+	if (!chainId) return failCustodyBuild({
+		code: "unavailable",
+		message: "Cardano chain id not available"
+	});
+	if (!eraSummaries || eraSummaries.length === 0) return failCustodyBuild({
+		code: "unavailable",
+		message: "Cardano era summaries not available"
+	});
+	return {
+		chainId,
+		protocolParameters: await readFromProvider("Cardano protocol parameters", () => provider.getProtocolParameters({ chainId })),
+		clock: createSlotClock(eraSummaries),
+		now,
+		provider
+	};
+};
+/**
+* What the provider measures every redeemer of a transaction at. There is
+* no fallback budget: a script that fails is a build that fails, with the
+* provider's message. A transient failure, such as a rate limit or a
+* dropped connection, is retried like every other read and then reported
+* as `unavailable`, since it says nothing about the scripts.
+*/
+const evaluateCustodyTransaction = async (transaction, { provider, chainId }) => {
+	const tx = transaction.toCbor();
+	try {
+		return await firstValueFrom(unwrapProviderResult(() => provider.evaluateTx({ tx }, { chainId })));
+	} catch (error) {
+		return failCustodyBuild(isRetriableError(error) ? {
+			code: "unavailable",
+			message: `Transaction evaluation: ${messageOf(error)}`
+		} : {
+			code: "script-evaluation-failed",
+			message: messageOf(error)
+		});
+	}
+};
+/**
+* The first slot that starts strictly after `posixMs`. A sweep of a grant
+* dead by expiry alone sets it as the lower validity bound, because the
+* validator needs the start of that bound to be after the expiry.
+*/
+const firstSlotStartingAfter = (posixMs, { clock }) => Slot(clock.slotAt(Number(posixMs)) + 1);
+/**
+* The upper validity bound a funding window allows: the slot holding
+* `validUntil`, which starts no later than it. The window must leave a slot
+* after the current one.
+*/
+const validitySlotFor = (validUntil, { clock, now }) => {
+	const slot = Number.isFinite(validUntil) ? clock.slotAt(validUntil) : 0;
+	return slot > clock.slotAt(now) ? Slot(slot) : failCustodyBuild({
+		code: "validity-window",
+		validUntil
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-creator-index.ts
+/**
+* Reads what the chain holds at one creator index of one contract version:
+* whether the stake credential of the creator key is registered and, when
+* it is, whether the account address holds the state NFT. A registered
+* credential without the NFT was registered by someone else first, which
+* blocks creation at that index forever.
+*/
+const readCustodyCreatorIndex = async ({ contractVersion, deviceAccountPublicKey, creatorIndex }, chain) => {
+	const key = await deriveCustodyDeviceKey(deviceAccountPublicKey, creatorIndex);
+	if (!key.ok) return failCustodyBuild({
+		code: "invalid-operation",
+		reason: "invalid-device-key",
+		message: `Cannot derive custody device key ${creatorIndex}: ${key.error.code}`
+	});
+	const identity = deriveCustodyAccountIdentity({
+		contractVersion,
+		creatorKeyHash: key.value.keyHash,
+		chainId: chain.chainId
+	});
+	if (!identity.ok) return failCustodyBuild({
+		code: "unavailable",
+		message: `Cannot derive a custody account on this chain: ${identity.error.code}`
+	});
+	const { rewardAccount, address, stateNftAssetId } = identity.value;
+	const { isRegistered } = await readFromProvider("Custody reward account", () => chain.provider.getRewardAccountInfo({ rewardAccount: CardanoRewardAccount(rewardAccount) }, { chainId: chain.chainId }));
+	if (!isRegistered) return {
+		status: "unregistered",
+		key: key.value,
+		identity: identity.value
+	};
+	return (await readFromProvider("Custody account UTxOs", () => chain.provider.getUtxosAtAddress({ address: CardanoPaymentAddress(address) }, { chainId: chain.chainId }))).some(([, output]) => output.value.assets?.has(stateNftAssetId)) ? {
+		status: "account",
+		record: createCustodyAccountRecord(identity.value)
+	} : { status: "pre-registered" };
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-evaluation.ts
+/** Rebuilds allowed after the final transaction measures above its budgets. */
+const MAX_EVALUATION_ROUNDS = 3;
+/**
+* Prices every redeemer at what the provider measures on the draft, with a
+* margin, and at least at a floor an earlier round measured on final bytes.
+*/
+const createProviderEvaluator = (chain, floors) => ({ evaluate: async (tx) => {
+	const measured = await evaluateCustodyTransaction(Transaction.fromCore(tx), chain);
+	return (tx.witness.redeemers ?? []).map(({ purpose, index }) => {
+		const measurement = measured.find((entry) => entry.purpose === purpose && entry.index === index);
+		if (!measurement) return unmeasured({
+			purpose,
+			index
+		});
+		return {
+			purpose,
+			index,
+			budget: atLeast(withEvaluationMargin(measurement.budget), floors.get(redeemerKey({
+				purpose,
+				index
+			})))
+		};
+	});
+} });
+/**
+* Builds a transaction whose budgets come from provider evaluation, then
+* evaluates the final bytes. Every redeemer must declare at least what the
+* final transaction measures, which is what the sponsor service checks
+* before it signs; a shortfall raises the budget and rebuilds.
+*
+* Balancing prices the fee at the plan's execution estimate, so the funds,
+* or the control output that pays, need to cover little more than the real
+* fee. When the scripts measure above the estimate by more than the
+* balanced fee covers, the plan is built once more, seeded at the
+* measurement plus a margin: a second selection round, which may add fund
+* UTxOs.
+*
+* @throws `MaxBalancedFeeExceeded` when `maxBalancedFee` is set and the
+*   transaction needs a fee above it
+*/
+const buildWithEvaluatedBudgets = async (params) => {
+	let floors = /* @__PURE__ */ new Map();
+	let funds = params.funds;
+	let reseed;
+	for (let round = 1;;) {
+		let built;
+		try {
+			built = await assembleWithFunds({
+				...params,
+				funds,
+				reseed,
+				evaluator: () => createProviderEvaluator(params.chain, floors)
+			});
+		} catch (error) {
+			if (!(error instanceof ExecutionEstimateShortfall)) throw error;
+			if (reseed) return failCustodyBuild({
+				code: "script-evaluation-failed",
+				message: "The scripts measure above the execution estimate after a reseed"
+			});
+			reseed = error.reseed;
+			continue;
+		}
+		funds = built.funds;
+		const underDeclared = findUnderDeclaredBudgets(built.transaction, await evaluateCustodyTransaction(built.transaction, params.chain));
+		if (underDeclared.length === 0) return built.transaction;
+		if (round >= MAX_EVALUATION_ROUNDS) return failCustodyBuild({
+			code: "script-evaluation-failed",
+			message: `Declared budgets stay below the measured ones after ${round} rounds`
+		});
+		round++;
+		floors = new Map([...floors, ...underDeclared.map((entry) => [redeemerKey(entry), withEvaluationMargin(entry.budget)])]);
+	}
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-scripts.ts
+const scriptHashOf = (script) => Script.fromCore(script).hash();
+/**
+* The catalogue pins each parked UTxO's address and lovelace with its
+* outref, so the builder prices its script without a chain lookup; the
+* provider's evaluation of every build resolves the outref on chain, so a
+* UTxO the chain no longer holds fails the build before anyone signs.
+*/
+const custodyScriptWitnesses = (version, { chainId }, scripts) => {
+	const parked = new Map(custodyReferenceScriptUtxos(version, chainId.networkMagic).map((utxo) => [scriptHashOf(utxo[1].scriptReference), utxo]));
+	const attached = [];
+	const referenced = [];
+	for (const script of scripts) {
+		const reference = parked.get(scriptHashOf(script));
+		if (reference) referenced.push(reference);
+		else attached.push(script);
+	}
+	return {
+		attached,
+		referenced
+	};
+};
+const LOGIC_RUN_REDEEMER = encodeCustodyLogicRedeemer();
+/**
+* Reads the logic's reward account once per transaction, so every build
+* round of it draws the same amount. A credential that is not registered
+* fails the build as `logic-not-registered`: the ledger would refuse the
+* withdrawal only at submission, after the sponsor and the device signed.
+* Registration is read, not delegation: the logic delegates to no pool.
+*/
+const readCustodyLogicRun = async (logic, { chainId, provider }) => {
+	const rewardAccount = RewardAccount.fromCredential({
+		type: CredentialType.ScriptHash,
+		hash: logic.hash
+	}, chainId.networkId);
+	const { isRegistered, withdrawableAmount } = await readFromProvider("Custody logic reward account", () => provider.getRewardAccountInfo({ rewardAccount: CardanoRewardAccount(rewardAccount) }, { chainId }));
+	if (!isRegistered) return failCustodyBuild({
+		code: "logic-not-registered",
+		rewardAccount
+	});
+	return {
+		logic,
+		withdrawal: {
+			rewardAccount,
+			quantity: BigNumber.valueOf(withdrawableAmount),
+			redeemer: LOGIC_RUN_REDEEMER
+		}
+	};
+};
+/**
+* The logic the account's control datum names. Lace operates no account
+* under a logic outside its contract version's catalogue, whose rules it
+* has not reviewed.
+*/
+const accountLogicOf = ({ identity, state }) => {
+	const logic = findCustodyLogic(identity.contractVersion, state.logic);
+	return logic.ok ? logic.value : failCustodyBuild({
+		code: "account-not-live",
+		status: "invalid"
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-validation.ts
+const cborOf$1 = (data) => PlutusData.fromCore(data).toCbor();
+/**
+* What the sponsor service checks the transaction against, from the funding
+* it leased, the contract version of the account the transaction operates
+* and the chain.
+*/
+const sponsorRuleContextOf = (funding, contractVersion, { chainId, clock, now, protocolParameters }) => ({
+	mode: funding.mode === "fee" ? {
+		kind: "fee",
+		feeUtxo: funding.feeUtxo,
+		maxSponsoredLovelace: funding.maxSponsoredLovelace
+	} : { kind: "collateral" },
+	sponsorAddress: funding.sponsorAddress,
+	collateralUtxo: funding.collateralUtxo,
+	contractVersion,
+	networkMagic: chainId.networkMagic,
+	latestValiditySlot: clock.slotAt(funding.validUntil),
+	currentSlot: clock.slotAt(now),
+	collateralPercentage: protocolParameters.collateralPercentage,
+	costModels: protocolParameters.costModels
+});
+/**
+* The largest fee the sponsor's shared collateral UTxO covers, or undefined
+* without a collateral percentage. The ledger needs collateral of the fee
+* times the percentage, and the sponsor needs the rest of the UTxO back in
+* a return output that holds its minimum ADA. For the service's 5 ADA UTxO,
+* a percentage of 150 and a base return address on Preprod, that is
+* 2,686,833 lovelace, below the 3,333,333 the UTxO covers without a return.
+*/
+const collateralFeeCeilingOf = ({ collateralUtxo: [, collateral], sponsorAddress }, { collateralPercentage, coinsPerUtxoByte }) => {
+	if (collateralPercentage <= 0) return void 0;
+	const returned = minAdaRequired({
+		address: sponsorAddress,
+		value: { coins: collateral.value.coins }
+	}, BigInt(coinsPerUtxoByte));
+	const available = collateral.value.coins - returned;
+	return available > 0n ? available * 100n / BigInt(collateralPercentage) : 0n;
+};
+const unexpected = (what) => failCustodyBuild({
+	code: "build-failed",
+	message: `The built transaction ${what}`
+});
+const isSameGrant = (a, b) => cborOf$1(encodeCustodyGrant(a)) === cborOf$1(encodeCustodyGrant(b));
+/** Checks the control output and the grant UTxOs the transaction writes. */
+const checkAccountOutputs = ({ controlOutput, issuedGrants, sweptGrants, grantSpend }, expectation) => {
+	const { control } = expectation;
+	if (!control) {
+		if (controlOutput) unexpected("rewrites the control state");
+	} else if (!controlOutput || cborOf$1(encodeCustodyAccountState(controlOutput.state)) !== cborOf$1(encodeCustodyAccountState(control.state))) unexpected("does not carry the intended account state");
+	else if (controlOutput.lovelace !== control.lovelace) unexpected("does not lock the intended control lovelace");
+	const planned = expectation.issuedGrants ?? [];
+	if (!(issuedGrants.length === planned.length && issuedGrants.every(({ grant, lovelace }, index) => isSameGrant(grant, planned[index].grant) && lovelace === planned[index].lovelace))) unexpected("does not issue the intended grants");
+	const plannedSwept = new Set(expectation.sweptSlots ?? []);
+	if (!(sweptGrants.length === plannedSwept.size && sweptGrants.every(({ grant }) => plannedSwept.has(grant.slot)))) unexpected("does not sweep the intended grants");
+	const plannedSpend = expectation.grantSpend;
+	if (!(!plannedSpend || grantSpend?.grant.slot === plannedSpend.slot && isSameGrant(grantSpend.after, plannedSpend.after))) unexpected("does not spend the intended grant");
+};
+/** Checks the value leaving the account, its own tokens aside. */
+const checkOutflow = ({ netOutflow }, fee, expectation) => {
+	if (!expectation.outflow) return;
+	const { requested, withdrawal } = expectation.outflow;
+	const assets = requested.assets ?? /* @__PURE__ */ new Map();
+	const accountPolicy = expectation.record.accountValidatorHash;
+	const leaving = [...netOutflow.assets].filter(([assetId]) => AssetId.getPolicyId(assetId) !== accountPolicy);
+	if (!(netOutflow.lovelace === requested.coins + fee - withdrawal && leaving.length === assets.size && [...assets].every(([assetId, quantity]) => netOutflow.assets.get(assetId.toLowerCase()) === quantity))) unexpected("pays out more than requested");
+};
+/**
+* Checks the final, balanced transaction before anyone is asked to sign it:
+* the shared custody inspection (the hosted signer's consent rules), the
+* intended control output, issued grants, sweeps and grant spend, the
+* account's net
+* outflow, the signer, the fee the sponsor's collateral covers, the fee
+* sponsor service's policy and the protocol limits. Any failure refuses
+* the build.
+*
+* `resolvedInputs` resolves every input, reference input and collateral
+* input.
+*/
+const finalizeCustodyBuild = ({ transaction, resolvedInputs }, chain, expectation) => {
+	const inspection = inspectCustodyTransaction(transaction, resolvedInputs, {
+		chainId: chain.chainId,
+		now: chain.now,
+		slotToPosixMs: chain.clock.slotStart,
+		accountRecord: expectation.record,
+		allowGrantSpend: expectation.grantSpend !== void 0,
+		...expectation.deviceKeyHash && { deviceKeyHash: expectation.deviceKeyHash }
+	});
+	if (!inspection.ok) return failCustodyBuild({
+		code: "inspection-refused",
+		refusals: [...inspection.error.refusals]
+	});
+	const { accounts, requiredSigners, fee, validity } = inspection.value;
+	const [account] = accounts;
+	checkAccountOutputs(account, expectation);
+	checkOutflow(account, fee, expectation);
+	if (requiredSigners.length !== 1 || requiredSigners[0] !== expectation.signer) return unexpected("does not name exactly the intended signer");
+	const { funding } = expectation;
+	const maxFee = funding.mode === "collateral" ? collateralFeeCeilingOf(funding, chain.protocolParameters) : void 0;
+	if (maxFee !== void 0 && fee > maxFee) return failCustodyBuild({
+		code: "collateral-fee-ceiling",
+		fee,
+		maxFee
+	});
+	const sponsorViolations = findCustodySponsorRuleViolations(transaction, resolvedInputs, sponsorRuleContextOf(funding, account.contractVersion, chain));
+	if (sponsorViolations.length > 0) return failCustodyBuild({
+		code: "sponsor-rules",
+		violations: sponsorViolations
+	});
+	try {
+		assertWithinTransactionLimits(transaction, resolvedInputs, chain.protocolParameters);
+	} catch (error) {
+		if (!(error instanceof TransactionLimitsExceededError)) throw error;
+		return failCustodyBuild({
+			code: "transaction-limits",
+			usage: error.usage,
+			exceeded: error.exceeded
+		});
+	}
+	return {
+		transaction: transaction.toCbor(),
+		bodyHash: transaction.getId(),
+		resolvedInputs,
+		accountRecord: expectation.record,
+		fee,
+		invalidHereafter: validity.invalidHereafter.slot
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/create-custody-account.ts
+/**
+* Lovelace a creation leaves unused below the sponsor's per-transaction
+* limit. It absorbs a fee that comes out slightly higher on the round that
+* settles the control lovelace, so that round still fits the limit.
+*/
+const CUSTODY_CREATION_SPONSOR_MARGIN = 100000n;
+/**
+* Builds of one creation before the control lovelace settles. The first
+* build prices the largest fee its execution estimate allows, so it fits
+* any fee within that estimate; the second claims the headroom the real fee
+* leaves; the third covers a fee that then moved by more than the margin.
+*/
+const MAX_HEADROOM_ROUNDS = 3;
+/**
+* The first creator index from `startIndex` whose stake credential is not
+* registered. A registered credential whose address holds the state NFT is
+* an existing account the caller should reopen; one without it was
+* registered by someone else first, which blocks creation there forever,
+* so the scan moves past it.
+*/
+const findCreatorIndex = async ({ deviceAccountPublicKey, startIndex = 0 }, chain) => {
+	for (let index = startIndex; index < startIndex + 100; index++) {
+		const found = await readCustodyCreatorIndex({
+			contractVersion: CURRENT_CUSTODY_CONTRACT_VERSION,
+			deviceAccountPublicKey,
+			creatorIndex: index
+		}, chain);
+		if (found.status === "unregistered") return {
+			index,
+			key: found.key,
+			identity: found.identity
+		};
+		if (found.status === "account") return failCustodyBuild({
+			code: "account-exists",
+			creatorIndex: index,
+			record: found.record
+		});
+	}
+	return failCustodyBuild({
+		code: "index-exhausted",
+		startIndex,
+		scanned: 100
+	});
+};
+const smaller = (a, b) => a < b ? a : b;
+/**
+* The control lovelace a creation aims for once its fee is known: what the
+* sponsor's limit leaves after the fee, the stake deposit and the margin,
+* within what the fee UTxO can fund, but never less than the initial
+* state's minimum.
+*/
+const headroomControlLovelace = ({ maxSponsoredLovelace, deposit, fundable, minimum }, fee) => {
+	const target = smaller(maxSponsoredLovelace - deposit - fee - CUSTODY_CREATION_SPONSOR_MARGIN, fundable);
+	return target > minimum ? target : minimum;
+};
+/**
+* Builds the creation of a custody account in the sponsor's fee mode: the
+* leased fee UTxO pays the fee, the stake deposit and the control output,
+* and its change returns to the sponsor in one output. The state NFT is
+* minted with `CreateAccount`, the stake credential is registered in the
+* same transaction with a Conway registration certificate, which carries
+* the `Operate` witness the mint looks for, and the logic the state names
+* runs through its withdrawal, which validates the new state. The creator
+* key is the only device and the only required signer, and the state
+* starts under the current logic at generation 0 with no slot issued, none
+* revoked and none outstanding.
+*
+* The proxy and the logic are read from their parked UTxOs on a network
+* that has them, and attached elsewhere; the stake script, applied to the
+* creator key, is always attached. Whatever the logic run draws joins the
+* control output, so the sponsor pays the same.
+*/
+const buildCustodyCreation = async (operation, funding, chain) => {
+	const startIndex = operation.startIndex ?? 0;
+	if (!Number.isSafeInteger(startIndex) || startIndex < 0 || startIndex + 100 > 2147483648) return failCustodyBuild({
+		code: "invalid-operation",
+		reason: "invalid-start-index",
+		message: `Invalid creator start index ${startIndex}`
+	});
+	const contractVersion = CURRENT_CUSTODY_CONTRACT_VERSION;
+	const currentLogic = findCustodyLogic(contractVersion, contractVersion.currentLogicHash);
+	if (!currentLogic.ok) throw new Error(`The contract version has no logic ${contractVersion.currentLogicHash}`);
+	const logicRun = await readCustodyLogicRun(currentLogic.value, chain);
+	const { index, key, identity } = await findCreatorIndex(operation, chain);
+	const { protocolParameters: parameters } = chain;
+	const state = transitioned(createInitialCustodyAccountState(key.keyHash, logicRun.logic.hash));
+	const witnesses = custodyScriptWitnesses(contractVersion, chain, [contractVersion.accountValidator, logicRun.logic.script]);
+	const drawn = logicRun.withdrawal.quantity;
+	const deposit = BigInt(parameters.stakeKeyDeposit);
+	const invalidHereafter = validitySlotFor(funding.validUntil, chain);
+	const executionEstimate = custodyExecutionEstimate({
+		createAccount: 1,
+		operate: 1,
+		logic: "arrival"
+	});
+	const largestFee = preEvaluationFeeBound(parameters, estimateWithinLimit(executionEstimate, parameters.maxExecutionUnitsPerTransaction));
+	const bounds = {
+		maxSponsoredLovelace: funding.maxSponsoredLovelace,
+		deposit,
+		fundable: funding.feeUtxo[1].value.coins - changeReserveAt(funding.sponsorAddress, parameters.coinsPerUtxoByte) - deposit - largestFee,
+		minimum: controlLovelaceFor({
+			identity,
+			state,
+			floor: 0n
+		}, parameters.coinsPerUtxoByte)
+	};
+	const buildWith = async (controlLovelace) => buildWithEvaluatedBudgets({
+		chain,
+		funds: {
+			selected: [],
+			remaining: []
+		},
+		plan: () => ({
+			inputs: [{ utxo: funding.feeUtxo }],
+			referenceInputs: witnesses.referenced,
+			outputs: [controlOutputOf(identity, state, controlLovelace + drawn)],
+			changeAddress: funding.sponsorAddress,
+			scripts: [...witnesses.attached, identity.stakeScript],
+			executionEstimate,
+			requiredSigner: key.keyHash,
+			invalidHereafter,
+			collateral: {
+				utxo: funding.collateralUtxo,
+				returnAddress: funding.sponsorAddress
+			},
+			mint: {
+				assets: new Map([[identity.stateNftAssetId, 1n]]),
+				redeemer: encodeCustodyMintRedeemer({ kind: "createAccount" })
+			},
+			registration: {
+				stakeCredential: scriptCredentialOf(identity.stakeScriptHash),
+				deposit,
+				redeemer: encodeCustodyStakeRedeemer()
+			},
+			withdrawals: [logicRun.withdrawal]
+		})
+	});
+	let controlLovelace = headroomControlLovelace(bounds, largestFee);
+	let transaction;
+	for (let round = 1;; round++) {
+		transaction = await buildWith(controlLovelace);
+		const fee = transaction.body().fee();
+		const sponsoredLovelace = fee + deposit + controlLovelace;
+		const isWithinLimit = sponsoredLovelace <= funding.maxSponsoredLovelace;
+		const settled = headroomControlLovelace(bounds, fee);
+		const isLastRound = round >= MAX_HEADROOM_ROUNDS || settled === controlLovelace;
+		if (isWithinLimit && (settled < controlLovelace || isLastRound)) break;
+		if (!isWithinLimit && isLastRound) return failCustodyBuild({
+			code: "sponsor-limit",
+			sponsoredLovelace,
+			maxSponsoredLovelace: funding.maxSponsoredLovelace
+		});
+		controlLovelace = settled;
+	}
+	const record = createCustodyAccountRecord(identity);
+	return {
+		...finalizeCustodyBuild({
+			transaction,
+			resolvedInputs: resolvedInputsOf(transaction, [
+				funding.feeUtxo,
+				...witnesses.referenced,
+				funding.collateralUtxo
+			])
+		}, chain, {
+			record,
+			control: {
+				state,
+				lovelace: controlLovelace + drawn
+			},
+			signer: key.keyHash,
+			deviceKeyHash: key.keyHash,
+			funding
+		}),
+		creation: {
+			creatorIndex: index,
+			identity: {
+				chainId: chain.chainId,
+				accountValidatorHash: contractVersion.accountValidatorHash,
+				creatorKeyHash: identity.creatorKeyHash,
+				stakeScriptHash: identity.stakeScriptHash,
+				address: identity.address,
+				rewardAccount: identity.rewardAccount
+			}
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-account.ts
+/** Every UTxO the classification of a live account holds. */
+const utxosOf = (state) => [
+	state.controlUtxo,
+	...state.funds,
+	...state.reserves.own,
+	...state.reserves.foreign,
+	...state.grants.map(({ utxo }) => utxo),
+	...state.stranded,
+	...state.anomalies.map(({ utxo }) => utxo)
+];
+/**
+* Resolves the account an operation runs on. The synced view must show it
+* live with a confirmed control UTxO, and the chain, read again now, must
+* hold that same control UTxO. Funds, reserves and grants come from that
+* fresh read, so a UTxO already spent on chain or still unconfirmed is never
+* selected; funds and reserves an unsettled transaction of this wallet
+* spends are left out too, so concurrent builds pick disjoint ones.
+*
+* Owner operations are never chained: while the synced control UTxO is the
+* output of a submitted transaction that has not settled, the build is
+* refused.
+*/
+const resolveCustodyAccount = async (accountId, snapshot, chain) => {
+	const { account, accountState, settledUtxos } = snapshot;
+	if (!account || account.blockchainSpecific.chainId.networkMagic !== chain.chainId.networkMagic) return failCustodyBuild({ code: "unknown-account" });
+	const identity = verifyCardanoCustodyAccountIdentity(account.blockchainSpecific);
+	if (!identity.ok) return failCustodyBuild({ code: "unknown-account" });
+	if (accountState?.status !== "live") return failCustodyBuild({
+		code: "account-not-live",
+		status: accountState?.status ?? "unsynced"
+	});
+	const controlKey = utxoKey(accountState.controlUtxo);
+	if (!settledUtxos.some((utxo) => utxoKey(utxo) === controlKey)) return failCustodyBuild({ code: "operation-in-progress" });
+	const onChain = classifyCardanoCustodyAccount({
+		account: account.blockchainSpecific,
+		utxos: await readFromProvider("Custody account UTxOs", () => chain.provider.getUtxosAtAddress({
+			address: CardanoPaymentAddress(identity.value.address),
+			withReferenceScripts: true
+		}, { chainId: chain.chainId })),
+		withdrawableRewards: 0n,
+		protocolParameters: chain.protocolParameters
+	});
+	if (onChain.status !== "live" || utxoKey(onChain.controlUtxo) !== controlKey) return failCustodyBuild({ code: "stale-control" });
+	const inFlight = new Set(utxosOf(accountState).map(utxoKey));
+	const spentInFlight = new Set(settledUtxos.map(utxoKey).filter((key) => !inFlight.has(key)));
+	const isUnspent = (utxo) => !spentInFlight.has(utxoKey(utxo));
+	return {
+		accountId,
+		identity: identity.value,
+		record: createCustodyAccountRecord(identity.value),
+		device: account.blockchainSpecific.device,
+		control: onChain.controlUtxo,
+		state: onChain.state,
+		funds: onChain.funds.filter(isUnspent),
+		reserves: onChain.reserves.own.filter(isUnspent),
+		grants: onChain.grants,
+		spentInFlight
+	};
+};
+/**
+* The device key that signs an owner operation: the bound device, listed in
+* the current state. An observer holds no device and no owner authority.
+*/
+const requireListedDevice = ({ device, state }) => {
+	if (!device) return failCustodyBuild({ code: "observer-account" });
+	const keyHash = device.keyHash.toLowerCase();
+	return state.devices.some((listed) => listed.toLowerCase() === keyHash) ? device.keyHash : failCustodyBuild({
+		code: "device-not-listed",
+		keyHash: device.keyHash
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-requests.ts
+const outputProblem = (output, identity, coinsPerUtxoByte) => {
+	const address = Address.fromString(output.address);
+	if (address?.getNetworkId() !== identity.chainId.networkId) return "is not an address on the account network";
+	if (address.getType() === AddressType.Byron) return "is a Byron address, which a Plutus transaction cannot pay";
+	if (address.toBech32() === identity.address) return "pays the account itself";
+	const accountPolicy = identity.contractVersion.accountValidatorHash;
+	if ([...output.value.assets?.keys() ?? []].some((assetId) => AssetId.getPolicyId(assetId) === accountPolicy)) return "carries a custody account token";
+	return output.value.coins < minAdaRequired(output, BigInt(coinsPerUtxoByte)) ? "holds less than its minimum ADA" : void 0;
+};
+/**
+* Checks the outputs an owner or a grantee asks the account to pay. Each
+* goes to a Shelley address on the account's network other than the
+* account itself, carries no token of a custody account and holds its
+* minimum ADA: the build never tops a requested amount up from account
+* funds.
+*/
+const checkRequestedOutputs = (outputs, identity, coinsPerUtxoByte) => {
+	for (const [outputIndex, output] of outputs.entries()) {
+		const problem = outputProblem(output, identity, coinsPerUtxoByte);
+		if (problem) failCustodyBuild({
+			code: "invalid-operation",
+			reason: "invalid-output",
+			message: `Output ${outputIndex} ${problem}`
+		});
+	}
+};
+const invalidMetadata = (message) => failCustodyBuild({
+	code: "invalid-operation",
+	reason: "invalid-metadata",
+	message
+});
+/** The largest metadata label the ledger encodes: a 64-bit unsigned integer. */
+const MAX_METADATA_LABEL = 2n ** 64n - 1n;
+/**
+* The metadata an owner asks the transaction to carry: a map of labels to
+* metadata the ledger accepts, which its serialization checks: text and
+* bytes hold at most 64 bytes each. An empty map carries nothing.
+*/
+const checkRequestedMetadata = (metadata) => {
+	if (metadata === void 0) return void 0;
+	if (!(metadata instanceof Map)) return invalidMetadata("The metadata must be a map of labels to metadata");
+	if (metadata.size === 0) return void 0;
+	for (const label of metadata.keys()) if (typeof label !== "bigint" || label < 0n || label > MAX_METADATA_LABEL) return invalidMetadata(`Metadata label ${String(label)} is not a 64-bit unsigned integer`);
+	try {
+		AuxiliaryData.fromCore({ blob: metadata });
+	} catch (error) {
+		return invalidMetadata(`The metadata cannot be encoded: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return metadata;
+};
+const invalidScope = (message) => failCustodyBuild({
+	code: "invalid-operation",
+	reason: "grant-scope",
+	message
+});
+/**
+* The grant a scope request asks to issue in `slot`. The request goes
+* through the library's strict requested-scope parser, the one the signer
+* applies to `requestedScopes`, so Lace refuses a scope the signer would
+* refuse as malformed; its recipients, which must be on the account's
+* network, become Plutus addresses.
+*/
+const grantRequestOf = ({ scope: request, slot }, { chainId }, now) => {
+	let serialized;
+	try {
+		serialized = serializeCustodyRequestedGrantScope({
+			...request,
+			slot
+		});
+	} catch {
+		return invalidScope("scope: not a grant scope");
+	}
+	const parsed = parseCustodyRequestedGrantScope(serialized);
+	if (!parsed.ok) return invalidScope([parsed.error.field, parsed.error.reason].filter(Boolean).join(": "));
+	const { grantee, recipients, ...scope } = parsed.value;
+	return {
+		grantee,
+		now,
+		scope: {
+			asset: scope.asset,
+			perCallCap: scope.perCallCap,
+			cap: scope.cap,
+			lovelacePerCallCap: scope.lovelacePerCallCap,
+			lovelaceCap: scope.lovelaceCap,
+			expiresAt: scope.expiresAt,
+			recipients: recipients.map((text) => {
+				const address = Address.fromBech32(text);
+				const recipient = custodyRecipientFromAddress(address);
+				return recipient.ok && address.getNetworkId() === chainId.networkId ? recipient.value : invalidScope(`recipients: ${text} is not on the account network`);
+			})
+		}
+	};
+};
+/** A bech32 stake pool id, refused as an invalid operation when malformed. */
+const poolIdOf = (poolId) => {
+	try {
+		return PoolId(poolId);
+	} catch {
+		return failCustodyBuild({
+			code: "invalid-operation",
+			reason: "invalid-pool-id",
+			message: `Invalid stake pool id ${poolId}`
+		});
+	}
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-grant-spend.ts
+/**
+* The most fund UTxOs one grant spend spends, upstream's `MAX_FUND_INPUTS`.
+* Every input adds a proxy run that decodes the whole transaction, and the
+* logic checks each one: a spend over twelve deposits measured 4.28M
+* memory units on upstream's devnet, a quarter of Preprod's limit.
+*/
+const MAX_GRANT_SPEND_FUND_INPUTS = 12;
+/**
+* What the second build adds to the first build's fee when it lowers the
+* caps: room for a fee that moves when the caps' encoding or the measured
+* budgets change between the two builds.
+*/
+const GRANT_CAP_FEE_MARGIN = 10000n;
+const SPEND_WITH_GRANT_REDEEMER = encodeCustodyAccountRedeemer({ kind: "spendWithGrant" });
+const FUND_REDEEMER$1 = encodeCustodyAccountRedeemer({ kind: "fund" });
+const cborOf = (data) => PlutusData.fromCore(data).toCbor();
+const FUND_REDEEMER_CBOR = cborOf(FUND_REDEEMER$1);
+const SPEND_WITH_GRANT_REDEEMER_CBOR = cborOf(SPEND_WITH_GRANT_REDEEMER);
+const deltaOf = (value, fee = 0n) => ({
+	lovelace: value.coins + fee,
+	assets: new Map([...value.assets].map(([assetId, quantity]) => [assetId.toLowerCase(), quantity]))
+});
+/**
+* Metadata is an owner's to attach: the operation type leaves it out, and a
+* caller that names it anyway is refused rather than built without it.
+*/
+const refuseMetadata = (operation) => {
+	if (operation.metadata !== void 0) failCustodyBuild({
+		code: "invalid-operation",
+		reason: "invalid-metadata",
+		message: "A grant spend carries no metadata"
+	});
+};
+/** The fee bound the operation names, or the default when it names none. */
+const feeBoundOf = ({ feeBound }) => {
+	if (feeBound === void 0) return CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND;
+	return typeof feeBound === "bigint" && feeBound > 0n ? feeBound : failCustodyBuild({
+		code: "invalid-operation",
+		reason: "invalid-fee-bound",
+		message: "The fee bound must be a positive number of lovelace"
+	});
+};
+/**
+* The grant UTxO a grant spend spends: the grantee's grant in the named
+* slot, or its single current, unexpired grant. The grant must be current
+* against the control state, and no unsettled transaction of this wallet
+* may already spend its UTxO.
+*/
+const selectGrant = ({ grantee, slot }, { grants, state, spentInFlight }, { now }) => {
+	const granteeHex = grantee.toLowerCase();
+	const held = grants.filter(({ grant }) => grant.grantee.toLowerCase() === granteeHex);
+	const livenessOf = ({ grant }) => custodyGrantLiveness(grant, state, now);
+	let selected;
+	if (slot === void 0) {
+		const current = held.filter((found) => livenessOf(found) === "current");
+		if (current.length > 1) return failCustodyBuild({
+			code: "grant-spend",
+			reason: "ambiguous-grant",
+			grantee,
+			slots: current.map(({ grant }) => grant.slot)
+		});
+		selected = current[0] ?? held.at(-1);
+	} else selected = held.find(({ grant }) => grant.slot === slot);
+	if (!selected) return failCustodyBuild({
+		code: "grant-spend",
+		reason: "unknown-grant",
+		grantee,
+		...slot !== void 0 && { slot }
+	});
+	const liveness = livenessOf(selected);
+	if (liveness !== "current") return failCustodyBuild({
+		code: "grant-spend",
+		reason: "dead-grant",
+		slot: selected.grant.slot,
+		liveness
+	});
+	return spentInFlight.has(outpointKey$1(selected.utxo[0])) ? failCustodyBuild({ code: "operation-in-progress" }) : selected;
+};
+/** Refuses an output the grant's recipient list does not name, on the account's network. */
+const checkRecipients = (grant, outputs, networkId) => {
+	const { recipients } = grant.scope;
+	if (recipients.length === 0) return;
+	const allowed = new Set(recipients.flatMap((recipient) => {
+		const address = custodyRecipientToAddress(recipient, networkId);
+		return address.ok ? [address.value.toBech32()] : [];
+	}));
+	for (const [outputIndex, output] of outputs.entries()) {
+		const address = Address.fromString(output.address).toBech32();
+		if (!allowed.has(address)) failCustodyBuild({
+			code: "grant-spend",
+			reason: "recipient-not-allowed",
+			outputIndex
+		});
+	}
+};
+/**
+* Refuses an outflow the grant's scope does not allow. `fee`, when known,
+* is the part of the lovelace outflow that pays the transaction fee; each
+* refusal reports it, so a caller can size a grant for the payment and the
+* fee.
+*/
+const refuseScope = (grant, leaving, fee) => {
+	const violations = findCustodyScopeViolations(grant.scope, leaving, fee);
+	if (violations.length > 0) failCustodyBuild({
+		code: "grant-spend",
+		reason: "scope",
+		violations
+	});
+};
+/**
+* The upper validity bound of a grant spend: the earlier of the funding
+* window and the slot holding the grant's expiry, whose start the contract
+* compares with the expiry. A grant that expires within the current slot
+* leaves no such slot.
+*/
+const grantSpendValiditySlot = (grant, funding, chain) => {
+	const windowSlot = validitySlotFor(funding.validUntil, chain);
+	const { expiresAt } = grant.scope;
+	if (expiresAt >= BigInt(chain.clock.slotStart(windowSlot))) return windowSlot;
+	const expirySlot = chain.clock.slotAt(Number(expiresAt));
+	return expirySlot > chain.clock.slotAt(chain.now) ? expirySlot : failCustodyBuild({
+		code: "grant-spend",
+		reason: "dead-grant",
+		slot: grant.slot,
+		liveness: "expired"
+	});
+};
+/**
+* Refuses a spend the fund UTxOs cannot pay however they are combined:
+* they hold less of a requested asset, or less lovelace, with whatever the
+* logic run draws, than the outputs and the least fee. It runs before the
+* fund input cap, because consolidation cannot help an account that is
+* short of funds.
+*/
+const refuseShortFunds = (candidates, requested, { leastFee, drawn }) => {
+	const available = totalValueOf(candidates.map(([, output]) => output));
+	if (available.coins + drawn < requested.coins + leastFee || [...requested.assets].some(([assetId, quantity]) => (available.assets.get(assetId) ?? 0n) < quantity)) failCustodyBuild({
+		code: "insufficient-funds",
+		message: "The fund UTxOs hold less than the requested outputs and the least fee"
+	});
+};
+const refuseFundInputCount = (funds) => {
+	if (funds.length > MAX_GRANT_SPEND_FUND_INPUTS) failCustodyBuild({
+		code: "grant-spend",
+		reason: "fund-input-cap",
+		maxFundInputs: MAX_GRANT_SPEND_FUND_INPUTS,
+		requiredFundInputs: funds.length
+	});
+};
+/**
+* Refuses a spend whose budgets exceed the per-transaction execution limit,
+* as a fund input count above what one spend fits: the grant's run is
+* fixed, so only fewer, larger fund UTxOs help. The count that fits follows
+* from the grant's and the logic's budgets and the dearest fund budget; the
+* logic's budget already counts every fund it checked, so the count errs
+* low.
+*/
+const refuseOverBudget = (redeemers, { maxExecutionUnitsPerTransaction: limit }) => {
+	const total = redeemers.reduce((sum, { executionUnits }) => ({
+		memory: sum.memory + executionUnits.memory,
+		steps: sum.steps + executionUnits.steps
+	}), {
+		memory: 0,
+		steps: 0
+	});
+	if (total.memory <= limit.memory && total.steps <= limit.steps) return;
+	const fixed = redeemers.filter(({ purpose, data }) => purpose === RedeemerPurpose.withdrawal || cborOf(data) === SPEND_WITH_GRANT_REDEEMER_CBOR).reduce((sum, { executionUnits }) => ({
+		memory: sum.memory + executionUnits.memory,
+		steps: sum.steps + executionUnits.steps
+	}), {
+		memory: 0,
+		steps: 0
+	});
+	const fundBudgets = redeemers.filter(({ data }) => cborOf(data) === FUND_REDEEMER_CBOR).map(({ executionUnits }) => executionUnits);
+	const fundMemory = Math.max(1, ...fundBudgets.map(({ memory }) => memory));
+	const fundSteps = Math.max(1, ...fundBudgets.map(({ steps }) => steps));
+	const fitting = Math.floor(Math.min((limit.memory - fixed.memory) / fundMemory, (limit.steps - fixed.steps) / fundSteps));
+	failCustodyBuild({
+		code: "grant-spend",
+		reason: "fund-input-cap",
+		maxFundInputs: Math.max(0, Math.min(MAX_GRANT_SPEND_FUND_INPUTS, fitting)),
+		requiredFundInputs: fundBudgets.length
+	});
+};
+/**
+* The grant the recreated grant UTxO carries: the caps `grant_after_spend`
+* allows for the requested outputs and `fee`, and no lower than zero. The
+* logic accepts any cap from zero to the value for the fee of the
+* transaction it checks, so a `fee` no lower than that one writes valid
+* caps.
+*/
+const grantAfter = (grant, requested, fee) => {
+	const { scope } = custodyGrantAfterSpend(grant, deltaOf(requested, fee));
+	return {
+		...grant,
+		scope: {
+			...scope,
+			cap: scope.cap > 0n ? scope.cap : 0n,
+			lovelaceCap: scope.lovelaceCap > 0n ? scope.lovelaceCap : 0n
+		}
+	};
+};
+/**
+* The most fee the outflow carries before it breaks a lovelace cap of the
+* scope: the lower of a lovelace grant's caps, or of a token grant's
+* lovelace caps, less the requested lovelace.
+*/
+const feeRoomOf = ({ scope }, requested) => {
+	const [perCallCap, cap] = isCustodyLovelaceAsset(scope.asset) ? [scope.perCallCap, scope.cap] : [scope.lovelacePerCallCap, scope.lovelaceCap];
+	return (perCallCap < cap ? perCallCap : cap) - requested.coins;
+};
+/**
+* Builds a grant spend for the grantee to sign. It references the
+* account's control UTxO, spends the grant UTxO with `SpendWithGrant` and
+* plain fund UTxOs with `Fund`, largest first, never a reserve, one
+* carrying a reference script, or one in `excludedInputs`, and runs the
+* logic the control names through its withdrawal. The grant UTxO is
+* recreated with the same value and the caps lowered by the outflow, the
+* requested outputs are paid, and the change, with whatever the logic run
+* draws, returns to the account as a plain output. The account pays the
+* fee, which counts against the grant's caps; the sponsor contributes only
+* its collateral. The proxy and the logic are read from their parked UTxOs
+* on a network that has them, and attached elsewhere.
+*
+* The caps go into the datum before the fee is known, and the logic counts
+* the fee in the outflow it checks against them, both on the final
+* transaction and on the balanced draft the provider evaluates. So every
+* draft is balanced at no more than the fee the caps were lowered by, nor
+* the fee that keeps the outflow within the caps, and two builds run with
+* evaluated budgets. The first lowers the caps by the fee bound, and a fee
+* above the bound or the caps is refused. The second lowers them by the
+* first fee and a small margin, and stands when its fee fits that; the
+* first build stands whenever the second cannot be built.
+*/
+const buildCustodyGrantSpend = async ({ operation, funding }, context, chain) => {
+	const { identity, control } = context;
+	const { protocolParameters: parameters } = chain;
+	refuseMetadata(operation);
+	const feeBound = feeBoundOf(operation);
+	const spent = selectGrant(operation, context, chain);
+	const { grant } = spent;
+	checkRequestedOutputs(operation.outputs, identity, parameters.coinsPerUtxoByte);
+	checkRecipients(grant, operation.outputs, identity.chainId.networkId);
+	const requested = totalValueOf(operation.outputs);
+	refuseScope(grant, deltaOf(requested));
+	const invalidHereafter = grantSpendValiditySlot(grant, funding, chain);
+	const grantee = grant.grantee;
+	const logicRun = await readCustodyLogicRun(accountLogicOf(context), chain);
+	const drawn = logicRun.withdrawal.quantity;
+	const { contractVersion } = identity;
+	const witnesses = custodyScriptWitnesses(contractVersion, chain, [contractVersion.accountValidator, logicRun.logic.script]);
+	const excluded = new Set((operation.excludedInputs ?? []).map(outpointKey$1));
+	const candidates = context.funds.filter(([input, output]) => output.scriptReference === void 0 && !excluded.has(outpointKey$1(input)));
+	const planOf = (after) => (funds) => ({
+		inputs: [{
+			utxo: spent.utxo,
+			redeemer: SPEND_WITH_GRANT_REDEEMER
+		}, ...funds.map((utxo) => ({
+			utxo,
+			redeemer: FUND_REDEEMER$1
+		}))],
+		referenceInputs: [control, ...witnesses.referenced],
+		outputs: [grantOutputOf(identity, after, spent.utxo[1].value.coins), ...operation.outputs],
+		changeAddress: identity.address,
+		scripts: witnesses.attached,
+		executionEstimate: custodyExecutionEstimate({
+			spendWithGrant: 1,
+			fund: funds.length,
+			logic: "agent"
+		}),
+		requiredSigner: grantee,
+		invalidHereafter,
+		collateral: {
+			utxo: funding.collateralUtxo,
+			returnAddress: funding.sponsorAddress
+		},
+		withdrawals: [logicRun.withdrawal]
+	});
+	const needed = requested.coins + plannedFeeOf(planOf(grant)([]), parameters) + changeReserveAt(identity.address, parameters.coinsPerUtxoByte) - drawn;
+	const selection = selectFunds(candidates, {
+		coins: needed > 0n ? needed : 0n,
+		assets: requested.assets
+	});
+	if (!selection.covers) refuseShortFunds(candidates, requested, {
+		leastFee: leastFeeOf(planOf(grant)([]), parameters),
+		drawn
+	});
+	const feeRoom = feeRoomOf(grant, requested);
+	/** A build whose caps are lowered by `lowering` and whose drafts fit them. */
+	const build = async (lowering, funds) => {
+		const after = grantAfter(grant, requested, lowering);
+		const transaction = await buildWithEvaluatedBudgets({
+			chain,
+			funds,
+			checkFunds: refuseFundInputCount,
+			plan: planOf(after),
+			maxBalancedFee: lowering < feeRoom ? lowering : feeRoom
+		});
+		return {
+			transaction,
+			after,
+			fee: transaction.body().fee()
+		};
+	};
+	/** Refuses a fee above the bound, or one that takes the outflow over a cap. */
+	const refuseFee = (fee) => fee > feeBound ? failCustodyBuild({
+		code: "grant-spend",
+		reason: "fee-above-bound",
+		fee,
+		feeBound
+	}) : failCustodyBuild({
+		code: "grant-spend",
+		reason: "scope",
+		violations: findCustodyScopeViolations(grant.scope, deltaOf(requested, fee), fee)
+	});
+	const first = await build(feeBound, selection).catch((error) => {
+		if (!(error instanceof MaxBalancedFeeExceeded)) throw error;
+		refuseOverBudget(error.evaluatedRedeemers, parameters);
+		return refuseFee(error.fee);
+	});
+	refuseOverBudget(first.transaction.witnessSet().redeemers()?.toCore() ?? [], parameters);
+	const firstFunds = resolvedInputsOf(first.transaction, candidates);
+	let chosen = first;
+	const tightFee = first.fee + GRANT_CAP_FEE_MARGIN;
+	const { scope: tight } = grantAfter(grant, requested, tightFee);
+	if (tight.cap > first.after.scope.cap || tight.lovelaceCap > first.after.scope.lovelaceCap) {
+		const used = new Set(firstFunds.map(([input]) => outpointKey$1(input)));
+		try {
+			chosen = await build(tightFee, {
+				selected: firstFunds,
+				remaining: candidates.filter(([input]) => !used.has(outpointKey$1(input)))
+			});
+		} catch (error) {
+			if (!(error instanceof MaxBalancedFeeExceeded) && !(error instanceof CustodyBuildFailure)) throw error;
+		}
+	}
+	const { transaction, after } = chosen;
+	return finalizeCustodyBuild({
+		transaction,
+		resolvedInputs: resolvedInputsOf(transaction, [
+			spent.utxo,
+			control,
+			...witnesses.referenced,
+			...candidates,
+			funding.collateralUtxo
+		])
+	}, chain, {
+		record: context.record,
+		grantSpend: {
+			slot: grant.slot,
+			after
+		},
+		signer: grantee,
+		outflow: {
+			requested,
+			withdrawal: drawn
+		},
+		funding
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-owner-operations.ts
+/**
+* The control output headroom, its lovelace above the state's minimum, that
+* an issue or a replace tops up to. The headroom is the owner's fee reserve:
+* an owner operation the plain funds cannot pay takes its fee from it, so an
+* owner can still revoke a grant after its agent drains the plain funds.
+* It pays two revokes. Where the proxy and the logic are attached, as on
+* Mainnet, a revoke carries about 12.7 KB, 11,871 bytes of them the two
+* scripts, at 44 lovelace per byte. At Preprod's prices and the 1.6M to 1.8M
+* memory units upstream's devnet measured over the largest state, the
+* control pays a fee of about 0.84 ADA. Before evaluation balancing prices
+* a revoke at its execution estimate, about 0.99 ADA, which the draft the
+* provider evaluates must find in the headroom. The first revoke's fee, the
+* second's draft, the state's growth and the growth margin come to about
+* 2.04 ADA. On Preprod, where the scripts are referenced at 15 lovelace per
+* byte, a revoke costs about 0.5 ADA and its draft about 0.64 ADA.
+*/
+const CUSTODY_OWNER_FEE_RESERVE_TARGET = 2100000n;
+/**
+* The control datum bytes the control output keeps lovelace for beyond its
+* minimum after paying a fee. The largest growth one owner operation makes
+* is a device key: 30 bytes, its 28 bytes and their header. A revoked slot
+* adds at most 6, and a counter crossing a CBOR width at most 2. The next
+* operation's growth is then covered, whoever pays its fee.
+*/
+const CUSTODY_CONTROL_GROWTH_MARGIN_BYTES = 32;
+const DEVICE_REDEEMER = encodeCustodyAccountRedeemer({ kind: "device" });
+const FUND_REDEEMER = encodeCustodyAccountRedeemer({ kind: "fund" });
+const SWEEP_REDEEMER = encodeCustodyAccountRedeemer({ kind: "sweepGrant" });
+const ISSUE_REDEEMER = encodeCustodyMintRedeemer({ kind: "issueGrants" });
+const BURN_REDEEMER = encodeCustodyMintRedeemer({ kind: "burnGrants" });
+/**
+* Refuses a grant whose per-call caps cannot pay the smallest spend: one
+* output at its minimum ADA and the default grant fee bound. Its agent could
+* never spend it.
+*/
+const spendableGrant = ({ grant }, { identity }, { protocolParameters }) => isCardanoCustodyGrantExhausted(grant.scope, {
+	protocolParameters,
+	networkId: identity.chainId.networkId
+}) ? failCustodyBuild({
+	code: "invalid-operation",
+	reason: "grant-scope",
+	message: "The caps cannot pay the smallest spend: one output at its minimum ADA and the grant fee bound"
+}) : grant;
+/** What an issue or a replace writes: the state and the grant it issues. */
+const issueEffectOf = (result, context, chain) => {
+	const issued = transitioned(result);
+	return {
+		state: issued.state,
+		outputs: [],
+		issued: spendableGrant(issued, context, chain)
+	};
+};
+/**
+* The sweep of the dead grants in `slots`. Each must be dead against the
+* state before the sweep. The validity interval starts no earlier than the
+* current slot, so a grant dead by expiry alone must expire before the
+* current slot starts; the interval then starts in the first slot after
+* the latest such expiry.
+*/
+const sweepEffectOf = (slots, { state, grants, spentInFlight }, chain) => {
+	const swept = slots.map((slot) => {
+		const found = grants.find(({ grant }) => grant.slot === slot);
+		if (!found) return failCustodyBuild({
+			code: "invalid-operation",
+			reason: "state-transition",
+			error: {
+				code: "grant-not-found",
+				slot
+			}
+		});
+		return spentInFlight.has(outpointKey$1(found.utxo[0])) ? failCustodyBuild({ code: "operation-in-progress" }) : found;
+	});
+	const currentSlotStart = chain.clock.slotStart(chain.clock.slotAt(chain.now));
+	const { state: next, startsAfter } = transitioned(sweepCustodyGrants(state, swept.map(({ grant }) => grant), currentSlotStart));
+	return {
+		state: next,
+		outputs: [],
+		swept: {
+			grants: swept,
+			...startsAfter !== void 0 && { invalidBefore: firstSlotStartingAfter(startsAfter, chain) }
+		}
+	};
+};
+/**
+* The metadata an operation carries. Only an owner spend carries any: the
+* other operation types leave it out, and a caller that names it on one
+* anyway is refused rather than built without it, as a grant spend is.
+*/
+const metadataOf = (operation) => {
+	const { metadata } = operation;
+	if (metadata !== void 0 && operation.type !== "owner-spend") return failCustodyBuild({
+		code: "invalid-operation",
+		reason: "invalid-metadata",
+		message: `A ${operation.type} carries no metadata`
+	});
+	return checkRequestedMetadata(metadata);
+};
+/**
+* The state an owner operation writes and what else it does. State changes
+* go through the library's transitions, which refuse what the account could
+* not use afterwards; withdrawal reads the reward balance now, because the
+* ledger accepts only the exact balance.
+*/
+const ownerEffectOf = async (operation, context, chain) => {
+	const { identity, state } = context;
+	const metadata = metadataOf(operation);
+	const grants = context.grants.map(({ grant }) => grant);
+	const requestOf = (scope) => grantRequestOf({
+		scope,
+		slot: state.nextSlot
+	}, identity, chain.now);
+	switch (operation.type) {
+		case "issue-grant": return issueEffectOf(issueCustodyGrant(state, requestOf(operation.scope), grants), context, chain);
+		case "replace-grant": return issueEffectOf(replaceCustodyGrant(state, {
+			...requestOf(operation.scope),
+			slot: operation.slot
+		}, grants), context, chain);
+		case "revoke-grant": return {
+			state: transitioned(revokeCustodyGrant(state, operation.slot, grants)),
+			outputs: []
+		};
+		case "revoke-all-grants": return {
+			state: revokeAllCustodyGrants(state),
+			outputs: []
+		};
+		case "sweep-grants": return sweepEffectOf(operation.slots, context, chain);
+		case "add-device": return {
+			state: transitioned(addCustodyDevice(state, operation.keyHash, grants)),
+			outputs: []
+		};
+		case "remove-device": return {
+			state: transitioned(removeCustodyDevice(state, operation.keyHash)),
+			outputs: []
+		};
+		case "owner-spend": return {
+			state,
+			outputs: operation.outputs,
+			...metadata && { metadata }
+		};
+		case "delegate": return {
+			state,
+			outputs: [],
+			poolId: poolIdOf(operation.poolId)
+		};
+		case "withdraw-rewards": {
+			const { withdrawableAmount } = await readFromProvider("Custody reward account", () => chain.provider.getRewardAccountInfo({ rewardAccount: CardanoRewardAccount(identity.rewardAccount) }, { chainId: chain.chainId }));
+			const withdrawal = BigNumber.valueOf(withdrawableAmount);
+			return withdrawal > 0n ? {
+				state,
+				outputs: [],
+				withdrawal
+			} : failCustodyBuild({
+				code: "invalid-operation",
+				reason: "no-rewards",
+				message: "The custody account has no rewards to withdraw"
+			});
+		}
+	}
+};
+const sweptGrantsOf = ({ effect }) => effect.swept?.grants ?? [];
+/**
+* The lovelace the withdrawals add to the transaction: the rewards an
+* operation withdraws and whatever the logic run draws. The change or the
+* control output keeps it at the account address.
+*/
+const withdrawnOf = ({ effect, logicRun }) => (effect.withdrawal ?? 0n) + logicRun.withdrawal.quantity;
+/** The transaction's plan with `funds` paying and the control output at `controlLovelace`. */
+const planOf = (build, funds, controlLovelace) => {
+	const { context, chain, effect, signer, funding, issued, witnesses } = build;
+	const { identity, control } = context;
+	const swept = sweptGrantsOf(build);
+	const isStakeOperation = effect.poolId !== void 0 || effect.withdrawal !== void 0;
+	const mint = issued ? {
+		assets: new Map([[custodyGrantAssetId(context.record, issued.grant.slot), 1n]]),
+		redeemer: ISSUE_REDEEMER
+	} : swept.length > 0 ? {
+		assets: new Map(swept.map(({ token }) => [token, -1n])),
+		redeemer: BURN_REDEEMER
+	} : void 0;
+	return {
+		inputs: [
+			{
+				utxo: control,
+				redeemer: DEVICE_REDEEMER
+			},
+			...swept.map(({ utxo }) => ({
+				utxo,
+				redeemer: SWEEP_REDEEMER
+			})),
+			...funds.map((utxo) => ({
+				utxo,
+				redeemer: FUND_REDEEMER
+			}))
+		],
+		outputs: [
+			controlOutputOf(identity, effect.state, controlLovelace),
+			...issued ? [issued.output] : [],
+			...effect.outputs
+		],
+		referenceInputs: witnesses.referenced,
+		changeAddress: identity.address,
+		scripts: [...witnesses.attached, ...isStakeOperation ? [identity.stakeScript] : []],
+		executionEstimate: custodyExecutionEstimate({
+			device: 1,
+			sweepGrant: swept.length,
+			fund: funds.length,
+			issueGrants: issued ? 1 : 0,
+			burnGrants: swept.length > 0 ? 1 : 0,
+			operate: isStakeOperation ? 1 : 0,
+			logic: "owner"
+		}),
+		requiredSigner: signer,
+		...effect.swept?.invalidBefore !== void 0 && { invalidBefore: effect.swept.invalidBefore },
+		invalidHereafter: validitySlotFor(funding.validUntil, chain),
+		collateral: {
+			utxo: funding.collateralUtxo,
+			returnAddress: funding.sponsorAddress
+		},
+		...mint && { mint },
+		...effect.poolId && { delegation: {
+			stakeCredential: scriptCredentialOf(identity.stakeScriptHash),
+			poolId: effect.poolId,
+			redeemer: encodeCustodyStakeRedeemer()
+		} },
+		withdrawals: [build.logicRun.withdrawal, ...effect.withdrawal ? [{
+			rewardAccount: identity.rewardAccount,
+			quantity: effect.withdrawal,
+			redeemer: encodeCustodyStakeRedeemer()
+		}] : []],
+		...effect.metadata && { metadata: effect.metadata }
+	};
+};
+/**
+* Moves `amount` lovelace from the change into the control output once the
+* fee is final. A change left below its minimum ADA joins the control
+* output whole, when it holds no token.
+*
+* @throws `FundShortfall` when the change cannot spare `amount`; once no
+*   fund is left the build fails with `owner-reserve-required`, or with
+*   `insufficient-funds` when there is no change at all
+*/
+const topUpControl = (transaction, { context, chain, effect, issued }, amount) => {
+	const outputs = [...transaction.body().toCore().outputs];
+	const [control] = outputs;
+	const changeIndex = changeIndexOf(outputs, context.identity.address, 1 + (issued ? 1 : 0) + effect.outputs.length);
+	if (changeIndex < 0) throw new FundShortfall("No change output to top the reserve up from");
+	const change = outputs[changeIndex];
+	const left = change.value.coins - amount;
+	const kept = minAdaRequired(change, BigInt(chain.protocolParameters.coinsPerUtxoByte));
+	const hasTokens = (change.value.assets?.size ?? 0) > 0;
+	if (left >= kept) {
+		outputs[0] = withCoins(control, control.value.coins + amount);
+		outputs[changeIndex] = withCoins(change, left);
+	} else if (!hasTokens && left >= 0n) {
+		outputs[0] = withCoins(control, control.value.coins + change.value.coins);
+		outputs.splice(changeIndex, 1);
+	} else throw new FundShortfall("The change cannot top the owner fee reserve up", {
+		code: "owner-reserve-required",
+		target: CUSTODY_OWNER_FEE_RESERVE_TARGET,
+		shortfall: amount - (hasTokens ? change.value.coins - kept : change.value.coins)
+	});
+	return {
+		transaction: withOutputs(transaction, outputs),
+		controlLovelace: outputs[0].value.coins
+	};
+};
+/**
+* Plain funds, then reserves, largest first, pay the requested outputs, the
+* issued grant's lovelace, any growth of the control output and the fee, and
+* the change, rewards included, returns to the account without a datum. A
+* reserve's remainder becomes plain change. Swept grant lovelace goes to the
+* control output, and an issue tops the control headroom up to the owner fee
+* reserve target from the change.
+*
+* A fund carrying a reference script is never spent. Anyone can send one to
+* the account. Where the proxy and the logic are attached, such a fund
+* holding one of them would make the ledger refuse every owner operation
+* for providing the script twice, instead of falling back to the control
+* headroom; anywhere, its script would add to the fee and, for the fee
+* sponsor, to the languages of the script data hash.
+*/
+const buildPaidByFunds = async (build) => {
+	const { context, chain, effect, issued, minimum } = build;
+	const { identity } = context;
+	const spendable = context.funds.filter(([, output]) => output.scriptReference === void 0);
+	const { protocolParameters: parameters } = chain;
+	const swept = sweptGrantsOf(build);
+	const controlLovelace = build.spentAccountLovelace > minimum ? build.spentAccountLovelace : minimum;
+	const reserveTarget = minimum + CUSTODY_OWNER_FEE_RESERVE_TARGET;
+	const topUp = issued && reserveTarget > controlLovelace ? reserveTarget - controlLovelace : 0n;
+	const requested = totalValueOf(effect.outputs);
+	const needed = requested.coins + (issued?.output.value.coins ?? 0n) + (controlLovelace - build.spentAccountLovelace) + topUp + plannedFeeOf(planOf(build, [], controlLovelace), parameters) + changeReserveAt(identity.address, parameters.coinsPerUtxoByte) - withdrawnOf(build);
+	let settledLovelace = controlLovelace;
+	return {
+		transaction: await buildWithEvaluatedBudgets({
+			chain,
+			funds: selectFunds(spendable, {
+				coins: needed > 0n ? needed : 0n,
+				assets: requested.assets
+			}, context.reserves),
+			plan: (funds) => planOf(build, funds, controlLovelace),
+			...topUp > 0n && { settle: (built) => {
+				const settled = topUpControl(built, build, topUp);
+				settledLovelace = settled.controlLovelace;
+				return settled.transaction;
+			} }
+		}),
+		controlLovelace: settledLovelace,
+		candidates: [
+			...spendable,
+			...context.reserves,
+			...swept.map(({ utxo }) => utxo)
+		]
+	};
+};
+const headroomShortfall = () => failCustodyBuild({
+	code: "insufficient-funds",
+	message: "The plain funds and reserves cannot pay the fee, and the control output headroom cannot either"
+});
+/**
+* The control output pays the fee from its headroom: the transaction spends
+* only the control UTxO and any swept grant UTxOs, and the control output
+* takes everything they hold and whatever the withdrawals add, less the
+* fee. It must keep the new state's minimum and the growth margin, which a
+* headroom below the least fee never keeps, so such a build is refused
+* before any evaluation.
+*/
+const buildPaidByControl = async (build) => {
+	const { chain, minimum, spentAccountLovelace } = build;
+	const held = spentAccountLovelace + withdrawnOf(build);
+	const plan = {
+		...planOf(build, [], held),
+		isFeePaidByFirstOutput: true
+	};
+	const floor = minimum + BigInt(CUSTODY_CONTROL_GROWTH_MARGIN_BYTES) * BigInt(chain.protocolParameters.coinsPerUtxoByte);
+	if (held - leastFeeOf(plan, chain.protocolParameters) < floor) return headroomShortfall();
+	const transaction = await buildWithEvaluatedBudgets({
+		chain,
+		funds: {
+			selected: [],
+			remaining: []
+		},
+		plan: () => plan
+	});
+	const controlLovelace = held - transaction.body().fee();
+	if (controlLovelace < floor) return headroomShortfall();
+	return {
+		transaction,
+		controlLovelace,
+		candidates: sweptGrantsOf(build).map(({ utxo }) => utxo)
+	};
+};
+const isInsufficientFunds = (error) => error instanceof CustodyBuildFailure && error.reason.code === "insufficient-funds";
+/**
+* Builds an owner operation in the sponsor's collateral mode: the account
+* pays and the sponsor contributes only its shared collateral. The control
+* UTxO is spent with `Device` and recreated from the resulting state, the
+* logic its state names runs through its withdrawal, and the bound device
+* key is the only required signer. The proxy and the logic are read from
+* their parked UTxOs on a network that has them, and attached elsewhere; a
+* stake operation attaches the stake script.
+*
+* Plain funds and reserves pay first. When they cannot, an operation that
+* pays nothing out and issues no grant takes its fee from the control
+* output's headroom instead.
+*/
+const buildCustodyOwnerOperation = async ({ operation, funding }, context, chain) => {
+	const signer = requireListedDevice(context);
+	const { identity, control } = context;
+	const { coinsPerUtxoByte } = chain.protocolParameters;
+	const effect = await ownerEffectOf(operation, context, chain);
+	checkRequestedOutputs(effect.outputs, identity, coinsPerUtxoByte);
+	const logicRun = await readCustodyLogicRun(accountLogicOf(context), chain);
+	const { contractVersion } = identity;
+	const swept = effect.swept?.grants ?? [];
+	const { issued: grant } = effect;
+	const issued = grant && {
+		grant,
+		output: grantOutputOf(identity, grant, outputLovelaceFor((lovelace) => grantOutputOf(identity, grant, lovelace), 0n, coinsPerUtxoByte))
+	};
+	const build = {
+		context,
+		chain,
+		effect,
+		signer,
+		funding,
+		...issued && { issued },
+		minimum: controlLovelaceFor({
+			identity,
+			state: effect.state,
+			floor: 0n
+		}, coinsPerUtxoByte),
+		spentAccountLovelace: swept.reduce((total, { utxo: [, output] }) => total + output.value.coins, control[1].value.coins),
+		logicRun,
+		witnesses: custodyScriptWitnesses(contractVersion, chain, [contractVersion.accountValidator, logicRun.logic.script])
+	};
+	const isControlPayable = effect.outputs.length === 0 && !issued;
+	let paid;
+	try {
+		paid = await buildPaidByFunds(build);
+	} catch (error) {
+		if (!isControlPayable || !isInsufficientFunds(error)) throw error;
+		paid = await buildPaidByControl(build);
+	}
+	const { transaction } = paid;
+	return finalizeCustodyBuild({
+		transaction,
+		resolvedInputs: resolvedInputsOf(transaction, [
+			control,
+			...paid.candidates,
+			...build.witnesses.referenced,
+			funding.collateralUtxo
+		])
+	}, chain, {
+		record: context.record,
+		control: {
+			state: effect.state,
+			lovelace: paid.controlLovelace
+		},
+		issuedGrants: issued ? [{
+			grant: issued.grant,
+			lovelace: issued.output.value.coins
+		}] : [],
+		sweptSlots: swept.map(({ grant }) => grant.slot),
+		signer,
+		deviceKeyHash: signer,
+		outflow: {
+			requested: totalValueOf(effect.outputs),
+			withdrawal: withdrawnOf(build)
+		},
+		funding
+	});
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/build-custody-transaction.ts
+const ACCOUNT_OPERATION_TYPES = new Set([
+	"add-device",
+	"delegate",
+	"grant-spend",
+	"issue-grant",
+	"owner-spend",
+	"remove-device",
+	"replace-grant",
+	"revoke-all-grants",
+	"revoke-grant",
+	"sweep-grants",
+	"withdraw-rewards"
+]);
+const refuseOperation = (type) => failCustodyBuild({
+	code: "invalid-operation",
+	reason: "unknown-operation",
+	message: `Unknown custody operation ${type} for this request`
+});
+const refuseFundingMode = (mode) => failCustodyBuild({
+	code: "invalid-operation",
+	reason: "funding-mode",
+	message: `Funding mode ${mode} does not fit the operation`
+});
+/**
+* Builds the custody transaction a request asks for. Creation runs in the
+* sponsor's fee mode on the current network. Every operation on an
+* existing account runs in collateral mode, with the account paying: the
+* sponsor's fee mode serves creation only.
+*/
+const buildCustodyTransaction = async (request, sources) => {
+	const chain = await loadCustodyChain(sources);
+	if (!("accountId" in request)) {
+		const { operation, funding } = request;
+		if (operation.type !== "create") return refuseOperation(operation.type);
+		if (funding.mode !== "fee") return refuseFundingMode(funding.mode);
+		return buildCustodyCreation(operation, funding, chain);
+	}
+	const { accountId, operation, funding } = request;
+	if (!ACCOUNT_OPERATION_TYPES.has(operation.type)) return refuseOperation(operation.type);
+	if (funding.mode !== "collateral") return refuseFundingMode(funding.mode);
+	const context = await resolveCustodyAccount(accountId, await sources.snapshot(accountId), chain);
+	return operation.type === "grant-spend" ? buildCustodyGrantSpend({
+		operation,
+		funding
+	}, context, chain) : buildCustodyOwnerOperation({
+		operation,
+		funding
+	}, context, chain);
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/creator-index-probe-side-effect.ts
+const isSoftIndex = (index) => Number.isSafeInteger(index) && index >= 0 && index < 2147483648;
+const probeErrorOf = (reason) => {
+	if (reason.code === "unavailable" || reason.code === "build-failed") return reason;
+	if (reason.code === "invalid-operation" && reason.reason === "invalid-device-key") return {
+		...reason,
+		reason: reason.reason
+	};
+	return {
+		code: "build-failed",
+		message: `Unexpected creator index probe failure: ${reason.code}`
+	};
+};
+const resultOf = ({ accountValidatorHash, creatorIndex }, state) => {
+	const probed = {
+		accountValidatorHash,
+		creatorIndex
+	};
+	return state.status === "account" ? {
+		...probed,
+		status: "account",
+		record: state.record
+	} : {
+		...probed,
+		status: state.status
+	};
+};
+const probe = async (request, { chainId, provider, logger }) => {
+	const contractVersion = findCustodyContractVersion(request.accountValidatorHash);
+	if (!contractVersion.ok) return {
+		ok: false,
+		error: contractVersion.error
+	};
+	if (!isSoftIndex(request.creatorIndex)) return {
+		ok: false,
+		error: {
+			code: "invalid-operation",
+			reason: "invalid-start-index",
+			message: `Invalid creator index ${request.creatorIndex}`
+		}
+	};
+	if (!chainId) return {
+		ok: false,
+		error: {
+			code: "unavailable",
+			message: "Cardano chain id not available"
+		}
+	};
+	try {
+		return {
+			ok: true,
+			result: resultOf(request, await readCustodyCreatorIndex({
+				contractVersion: contractVersion.value,
+				deviceAccountPublicKey: request.deviceAccountPublicKey,
+				creatorIndex: request.creatorIndex
+			}, {
+				chainId,
+				provider
+			}))
+		};
+	} catch (error) {
+		if (error instanceof CustodyBuildFailure) return {
+			ok: false,
+			error: probeErrorOf(error.reason)
+		};
+		logger.error("Custody creator index probe failed unexpectedly", error);
+		return {
+			ok: false,
+			error: {
+				code: "build-failed",
+				message: messageOf(error)
+			}
+		};
+	}
+};
+const makeCustodyCreatorIndexProbing = () => ({ cardanoContext: { probeCustodyCreatorIndex$ } }, { cardanoContext }, { cardanoProvider, actions, logger }) => {
+	const answer = async (request) => probe(request, {
+		chainId: await firstValueFrom(cardanoContext.selectChainId$),
+		provider: cardanoProvider,
+		logger
+	});
+	return probeCustodyCreatorIndex$.pipe(mergeMap(({ payload: request }) => from(answer(request)).pipe(map((outcome) => outcome.ok ? actions.cardanoContext.probeCustodyCreatorIndexCompleted({
+		requestId: request.requestId,
+		result: outcome.result
+	}) : actions.cardanoContext.probeCustodyCreatorIndexFailed({
+		requestId: request.requestId,
+		error: outcome.error
+	})))));
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/custody/build-side-effect.ts
+const failureOf = (error, logger) => {
+	if (error instanceof CustodyBuildFailure) return error.reason;
+	logger.error("Custody transaction build failed unexpectedly", error);
+	return {
+		code: "build-failed",
+		message: messageOf(error)
+	};
+};
+const makeCustodyTransactionBuilding = () => ({ cardanoContext: { buildCustodyTransaction$ } }, { cardanoContext, wallets }, { cardanoProvider, actions, logger }) => {
+	const snapshot = async (accountId) => {
+		const [allWallets, accountStateOf, settledUtxos] = await Promise.all([
+			firstValueFrom(wallets.selectAll$),
+			firstValueFrom(cardanoContext.selectCardanoCustodyAccountState$),
+			firstValueFrom(cardanoContext.selectAccountUtxos$)
+		]);
+		return {
+			account: allWallets.flatMap((wallet) => wallet.accounts).filter(isCardanoCustodyAccount).find((account) => account.accountId === accountId),
+			accountState: accountStateOf(accountId),
+			settledUtxos: settledUtxos[accountId] ?? []
+		};
+	};
+	const build = async (request) => {
+		try {
+			const [chainId, eraSummaries] = await Promise.all([firstValueFrom(cardanoContext.selectChainId$), firstValueFrom(cardanoContext.selectEraSummaries$)]);
+			return {
+				ok: true,
+				result: await buildCustodyTransaction(Serializable.from(request), {
+					chainId,
+					eraSummaries,
+					snapshot,
+					provider: cardanoProvider,
+					now: Date.now()
+				})
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: failureOf(error, logger)
+			};
+		}
+	};
+	return buildCustodyTransaction$.pipe(mergeMap(({ payload: { requestId, request } }) => from(build(request)).pipe(map((outcome) => outcome.ok ? actions.cardanoContext.buildCustodyTransactionCompleted({
+		requestId,
+		result: outcome.result
+	}) : actions.cardanoContext.buildCustodyTransactionFailed({
+		requestId,
+		error: outcome.error
+	})))));
+};
+const custodyTransactionSideEffects = [makeCustodyTransactionBuilding(), makeCustodyCreatorIndexProbing()];
+//#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 = PolicyId("d2dbff622e509dda256fedbd31ef6e9fd98ed49ad91d5c0e07f68af1");
+const TESTNET_CNIGHT_ASSET_NAME = AssetName("");
+const MAINNET_CNIGHT_POLICY_ID = PolicyId("0691b2fecca1ac4f53cb6dfb00b7013e561d1f34403b957cbb5af1fa");
+/** "NIGHT" in hex — the mainnet cNIGHT token is named NIGHT. */
+const MAINNET_CNIGHT_ASSET_NAME = 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 AssetId.fromParts(policyId, assetName);
+};
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/scripts/mainnet.ts
+const CNIGHT_GENERATES_DUST_MAINNET_CBOR = "590c8401010029800aba4aba2aba1aba0aab9faab9eaab9dab9cab9a488888888a60022a6600492119657870656374205b782c202e2e726573745d203d206c69737400168a9980124929657870656374205b506169722822222c2031295d203d20746f6b656e73207c3e20746f5f706169727300168a9980124936657870656374206275696c74696e2e6c656e6774685f6f665f62797465617272617928647573745f6164647265737329203c3d20333300168a998012495365787065637420447573744d617070696e67446174756d207b20635f77616c6c65742c20647573745f61646472657373207d203d0a2020202020202020202020202020202020206f75747075745f646174756d00168a998012493065787065637420447573744d617070696e67446174756d207b20635f77616c6c65742c202e2e207d203d20646174756d00164888896600330013009375401f2300d300e001911919800800801912cc00400629422b3001300330100018a518998010011808800a0144039370e90004dc3a40052232330010010032259800800c026264b300130040018800c4cc00c00cc04800900b1808000a01c9b874801122222229800980a003cc040dd51809803c88966002600e60246ea800e264646600200200844b30010018a508acc004cdc79bae30190010038a51899801001180d000a026405c6eb8c058c04cdd5001c4cc0200048cdd798098008022020911192cc004c020006264b3001001801c4c966002003004802401200913259800980d801c01a00a80c0dd7000a0363018001405860286ea80122b300130070018992cc00400600713259800800c01200900480244c9660026036007006802a030375c00280d8c060005016180a1baa0048012022404460246ea800d22223322323298009bab301b0019bac301b301c301c0019bac301b007980b9baa0039bac301b0049bab301b0024888889660026024007133225980099baf30230104c103d87980008acc00401a2a6603c9211b657870656374205b696e7075742c202e2e5d203d20696e7075747300168992cc0040062b300130153020375400313259800800c06e264b30010018992cc00400603b13259800800c07a03d01e80f44c966002605400719800802456600266e24dc6800a408519800802403601c80a2040811a03e809a03e8138dd7000a05430270014094604e00501c80e40720388140c09400502318109baa00180d203c80d406a03501a409864b300132330010010082259800800c528456600266ebcc098c08cdd51813000801c528c4cc008008c09c00502020488992cc00400603b13259800981380144c96600266e3d220100375c6046005159800980b800c4c8c96600264b30010018a99812a48130657870656374205b5f2c202e2e6e66745d203d2076616c7565207c3e20746f5f64696374207c3e20746f5f70616972730016899baf374c60560026e98cc0a4cdd81ba9009374c6605266ec13010140004c010101004bd6f7b63025eb7bdb1810281bab30290018992cc004c060c098dd5000c4c0a8c09cdd5000c54cc09524012165787065637420496e6c696e65446174756d28646174756d29203d20646174756d001640906052605400315330244901266578706563742069735f73696e676c65746f6e2876616c75652c20706f6c6963792c202222290016408c6052604a6ea8cc05c0248cdd7981498131baa30293026375400200466e95200233026375200c97ae080fa04280fa042375a604600301e4090604a0028118dd5981099801002119b8f375c6042002009153301f49016b6578706563740a202020206c6973742e616e79280a202020202020696e707574732c0a202020202020666e28696e7075743a20496e70757429207b20696e7075742e6f75747075745f7265666572656e6365203d3d206f6e655f73686f745f726566207d2c0a202020202900164078604660406ea8c08c01902144c96600266ebcdd31981199bb04c10140003750653001001804520004004444b30010028800c660020073028002acc004cdd7981398121baa302730243754603460486ea8c09c008012266e0000520018800a042400c81292f5bded8c0604266004008466e3cdd71810800802456600330013371e0069111c0691b2fecca1ac4f53cb6dfb00b7013e561d1f34403b957cbb5af1fa00a50a5140791980099b8f003489076d61696e6e657400a50a51407914a080f2294101e19ba548008cc088dd480125eb8101d1bae3021301e375401244646600200200644b300100180f44c96600260080031001899801801981380120403025001408d1598009807801c4c9660026024603c6ea800626464944ca6002003007802a002222598008014400633001003981380156600266ebcc098c08cdd5181318119baa301930233754604c00400b159800800c54cc0852413f657870656374205b4f7574707574207b20616464726573732c2076616c75652c20646174756d2c202e2e207d2c202e2e726573745d203d206f757470757473001689919912cc004cdd7981498131baa30290030088992cc0040062a6604a920133657870656374205b5f2c202e2e6e66745f69645d203d2076616c7565207c3e20746f5f64696374207c3e20746f5f706169727300168acc004cdd79ba6302b0010088992cc004c064c09cdd5000c4c966002003159800980e98141baa0018992cc00400604713259800800c4c9660020030258992cc00400604d026813409a264b300130320038cc0040122b3001337126e3400520428acc006600200901580b20388804c54cc0b12413b65787065637420636865636b5f6175746828635f77616c6c65742c2065787472615f7369676e61746f726965732c207769746864726177616c7329001640ad02840ad027406d02740bc6eb80050321817800a05a302f002812409204902440c0605a0028158c0a4dd5000c089026408a045022811205c302b3028375400315330264912865787065637420496e6c696e65446174756d286f75747075745f646174756d29203d20646174756d001640946054605600715330254901266578706563742061735f64617461286e66745f696429203d3d2065787065637465645f6e6674001640908140dd59814801454cc09124012d65787065637420616464726573732e7061796d656e745f63726564656e7469616c203d3d206f776e5f637265640016408c6050002605000460466ea8c09800502444005020200640906e98cc084cdd81811180f9baa0014c0103a14001004bd6f7b630454cc07524012265787065637420536372697074286f776e5f6861736829203d206f776e5f63726564001640706042603c6ea80262b3001301100389919912cc004c054c080dd5000c4c966002003159800980b18109baa0018992cc00400603713259800800c4c96600200301d8992cc00400603d01e80f407a264b3001302b0038cc004012264b3001301b3027375400313259800cc00401a021011405d15980099b880014800229462b30013301e01123375e60520020071301d0018a5040988132294102619192cc004c074c0a4dd5000c5200089bad302d302a37540028138c966002603a60526ea80062980103d87a8000899198008009bab302e302b375400444b30010018a6103d87a8000899192cc004cdc8a45000018acc004cdc7a44100001899ba548000cc0c0c0b80092f5c114c0103d87a800040ad133004004303200340ac6eb8c0b0004c0bc00502d204e323300100100d2259800800c5300103d87a8000899192cc004cdc8802800c56600266e3c014006266e9520003302f302d0024bd7045300103d87a800040a9133004004303100340a86eb8c0ac004c0b800502c1bae302b3028375400315330264919165787065637420536372697074286f776e5f686173682920617320736372697074203d0a202020202020202020206d7573745f66696e6428696e707574732c20666e28696e70757429207b20696e7075742e6f75747075745f7265666572656e6365203d3d206f7574707574207d292e6f75747075742e616464726573732e7061796d656e745f63726564656e7469616c001640946054604e6ea8c0a8c09cdd5180e98139baa3301900d23375e605660506ea800402603e80a203e8140dd7000a05630280014098605000501c80e40720388148c09800502418111baa00180d203e80d406a03501a409c604860426ea80062a6603e9211a65787065637420536f6d6528646174756d29203d20646174756d00164078604400260446046002603c6ea80262b30013370e9003001c5660026024603a6ea8c084c088c078dd5004c528c5901b45901b2036406c80d8603660360026034603400460306030006602e603000845268a99803a491856616c696461746f722072657475726e65642066616c7365001365640181";
+//#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) => HexBlob(cborWrapHexBytes(network === CardanoDustNetwork.mainnet ? CNIGHT_GENERATES_DUST_MAINNET_CBOR : CNIGHT_GENERATES_DUST_TESTNET_CBOR));
+const getDustGeneratorPlutusV3Script = (network) => PlutusV3Script.fromCbor(getDustGeneratorScriptCbor(network));
+//#endregion
+//#region ../../packages/lib/cnight-dust-designation/src/plutus/datum.ts
+const encodeCWallet = (cWallet) => {
+	const fields = new PlutusList();
+	const hashBytes = cWallet.kind === "verificationKey" ? cWallet.stakeKeyHash : cWallet.scriptHash;
+	fields.add(PlutusData.newBytes(hashBytes));
+	const alternative = cWallet.kind === "verificationKey" ? 0n : 1n;
+	return PlutusData.newConstrPlutusData(new ConstrPlutusData(alternative, fields));
+};
+const encodeDustMappingDatum = (value) => {
+	const fields = new PlutusList();
+	fields.add(encodeCWallet(value.cWallet));
+	fields.add(PlutusData.newBytes(value.dustAddress));
+	return PlutusData.newConstrPlutusData(new 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 = PlutusData.fromCbor(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) => PlutusData.newConstrPlutusData(new ConstrPlutusData(alternative, new 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: CredentialType.ScriptHash,
+		hash: scriptHash
+	};
+	return EnterpriseAddress.fromCredentials(networkId, credential).toAddress().toBech32();
+};
+const getDustGeneratorRewardAccount = (network) => {
+	const scriptHash = getDustGeneratorScriptHash(network);
+	const networkId = CardanoDustNetwork.toNetworkId(network);
+	const credential = {
+		type: CredentialType.ScriptHash,
+		hash: scriptHash
+	};
+	return RewardAddress.fromCredentials(networkId, credential).toAddress().toBech32();
+};
+const getDustMappingNftPolicyId = (network) => 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) => AssetId.fromParts(getDustMappingNftPolicyId(network), 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 = AssetName("");
+const computeScriptOutputLovelace = ({ scriptAddress, nftAsset, datumCbor, coinsPerUtxoByte }) => {
+	const datum = PlutusData.fromCbor(datumCbor).toCore();
+	const representativeOutput = {
+		address: scriptAddress,
+		value: {
+			coins: LOVELACE_FOR_REGISTRATION,
+			assets: new Map([[nftAsset, 1n]])
+		},
+		datum
+	};
+	const minCoin = 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 = Address.fromString(primary.address)?.asBase();
+	if (!baseAddress) throw new Error("Account address is not a base (payment+stake) address");
+	return {
+		primaryAddress: 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) => 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 TransactionBuilder(dependencies.networkMagic, params.protocolParameters);
+	builder.setChangeAddress(params.changeAddress).setUnspentOutputs(dependencies.coverUtxos).setCollateralUtxos(dependencies.coverUtxos).setCollateralChangeAddress(params.changeAddress).setPlutusContext({
+		costModels: params.protocolParameters.costModels,
+		txEvaluator: dependencies.txEvaluator,
+		inputResolver: dependencies.inputResolver
+	});
+	builder.attachScript({
+		__type: ScriptType.Plutus,
+		version: PlutusLanguageVersion.V3,
+		bytes: 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 = 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 firstValueFrom(cardanoProvider.evaluateTx({ tx: 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(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 firstValueFrom(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 firstValueFrom(unwrapProviderResult(() => dependencies.cardanoProvider.getRewardAccountInfo({ rewardAccount: 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: 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([
+			firstValueFrom(cardano.cardanoChainId$),
+			firstValueFrom(cardano.cardanoAccountUtxos$),
+			firstValueFrom(cardano.cardanoAccountUnspendableUtxos$),
+			firstValueFrom(cardano.cardanoAddresses$)
+		]);
+		if (!chainId) throw new Error("Cardano chain id not available");
+		refuseExtensionAccount(accountId, cardanoAddresses);
+		const [protocolParameters, tip] = await Promise.all([firstValueFrom(unwrapProviderResult(() => dependencies.cardanoProvider.getProtocolParameters({ chainId }))), firstValueFrom(unwrapProviderResult(() => dependencies.cardanoProvider.getTip({ chainId })))]);
+		const network = CardanoDustNetwork.fromNetworkMagic(chainId.networkMagic);
+		const { primaryAddress, paymentKeyHash, stakeKeyHash } = resolveAccountKeyHashes(cardanoAddresses, accountId);
+		const spendable = filterSpendableUtxos(allAccountUtxos[accountId] ?? [], unspendableUtxos[accountId] ?? []);
+		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 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 collateral"), "no-cardano-utxos");
+		const result = await buildNightDesignationTx({
+			network,
+			action,
+			cnightUtxos,
+			paymentKeyHash,
+			stakeKeyHash,
+			changeAddress: primaryAddress,
+			ttlSlot: Slot(Number(tip.slot) + TTL_BUFFER_SLOTS),
+			protocolParameters
+		}, {
+			networkMagic: chainId.networkMagic,
+			coverUtxos,
+			txEvaluator: createProviderExUnitsEvaluator({
+				cardanoProvider: dependencies.cardanoProvider,
+				chainId,
+				logger: dependencies.logger
+			}),
+			inputResolver: 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: LOVELACE_TOKEN_ID,
+				amount: BigNumber(result.value.fee)
+			}]
+		};
+	} catch (error) {
+		const code = error instanceof InputSelectionError ? "no-cardano-utxos" : error.code;
+		return failure(error instanceof Error ? error : new Error(String(error)), code);
+	}
+};
+const makeNightDesignationBuilding = () => (_, stateObservables, dependencies) => firstStateOfStatus(stateObservables.nightDesignationFlow.selectState$, "Building").pipe(switchMap((state) => stateObservables.activities.selectPendingActivitiesByAccount$.pipe(map((byAccount) => byAccount[state.accountId] ?? NO_PENDING_ACTIVITIES), take(1), timeout({
+	first: PENDING_READ_TIMEOUT_MS,
+	with: () => of(NO_PENDING_ACTIVITIES)
+}), switchMap((pendingActivities) => from(buildDesignation(state, dependencies, pendingActivities)).pipe(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) => combineLatest([cardano.cardanoChainId$, cardano.cardanoAddresses$]).pipe(filter((inputs) => {
+	const [chainId, cardanoAddresses] = inputs;
+	return chainId !== void 0 && cardanoAddresses.some((address) => address.accountId === accountId && isCardanoAddressOfSupportedNetwork(address, chainId));
+}), take(1), timeout({
+	first: inputsTimeoutMs,
+	with: () => 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 forkJoin([unwrapProviderResult(() => dependencies.cardanoProvider.getUtxosAtAddress({ address: getDustGeneratorPaymentAddress(network) }, { chainId })), unwrapProviderResult(() => dependencies.cardanoProvider.getRewardAccountInfo({ rewardAccount: CardanoRewardAccount(getDustGeneratorRewardAccount(network)) }, { chainId })).pipe(map((info) => info.isRegistered), catchError(() => of(void 0)))]).pipe(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(groupBy(({ payload }) => payload.accountId), mergeMap((perAccount$) => perAccount$.pipe(exhaustMap(({ payload: { accountId } }) => scanInputs$(accountId, dependencies.txExecutorCardano, inputsTimeoutMs).pipe(switchMap(([chainId, cardanoAddresses]) => readSnapshot$({
+	accountId,
+	chainId,
+	cardanoAddresses,
+	dependencies
+})), map((snapshot) => dependencies.actions.nightDesignationIndex.refreshCompleted({
+	accountId,
+	snapshot
+})), catchError(() => 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 }) => firstStateOfStatus(stateObservables.nightDesignationFlow.selectState$, "Success").pipe(mergeMap(({ accountId, txId }) => concat(of(actions.nightDesignationIndex.settlingStarted({
+	accountId,
+	txId
+})), merge(stateObservables.activities.selectAllMap$.pipe(filter((byAccount) => (byAccount[accountId] ?? []).some((activity) => activity.activityId === txId && activity.type !== ActivityType.Pending))), timer(settlingTimeoutMs)).pipe(take(1), mergeMap(() => 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()
+], ...custodyTransactionSideEffects];
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/side-effects.ts
+const mainnetMagic = Number(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: 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(filter((options) => !options?.Cardano), 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
+export { redux as default };