@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/fees-6C2uEWFK.js

@@ -0,0 +1,653 @@
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { Bt as AssetName, Ft as BaseAddress, Mt as CborWriter, S as TransactionOutput, Vt as PolicyId, a as CertIndex, at as isPlutusBigInt, c as EnterpriseAddress, ft as Script, it as isConstrPlutusData, n as AddressType, ot as isPlutusBoundedBytes, p as Transaction, r as CredentialType, s as TxIndex, st as isPlutusList, t as Address, zt as AssetId } from "./Address-_c_-9hLC.js";
+import { t as BigIntMath } from "./BigIntMath-X3EniYDo.js";
+import { t as isNotNil } from "./isNotNil-Be7gCY0m.js";
+import { d as fail, f as ok, i as isLowerCaseHex, n as hexToBytes, r as isHash28Hex, t as bytesToHex } from "./hex-CGYJPK_Z.js";
+//#region ../../node_modules/@cardano-sdk/core/dist/esm/Asset/util/coalesceTokenMaps.js
+const coalesceTokenMaps = (totals) => {
+	const result = /* @__PURE__ */ new Map();
+	for (const assetTotals of totals.filter(isNotNil)) for (const [assetId, assetQuantity] of assetTotals.entries()) {
+		const sum = result.get(assetId) || 0n;
+		result.set(assetId, sum + assetQuantity);
+	}
+	if (result.size === 0) return;
+	return result;
+};
+//#endregion
+//#region ../../node_modules/@cardano-sdk/core/dist/esm/util/coalesceValueQuantities.js
+const coalesceValueQuantities = (quantities) => ({
+	assets: coalesceTokenMaps(quantities.map(({ assets }) => assets)),
+	coins: BigIntMath.sum(quantities.map(({ coins }) => coins))
+});
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/codecs/plutus-data.ts
+/** Raised inside the decoders only; `decodeResult` turns it into a result. */
+var MalformedData = class extends Error {
+	constructor(path, expected) {
+		super(`Expected ${expected} at ${path || "the root"}`);
+		this.path = path;
+		this.expected = expected;
+	}
+};
+/** Runs a throwing decoder and reports a shape mismatch as a typed failure. */
+const decodeResult = (decode) => {
+	try {
+		return ok(decode());
+	} catch (error) {
+		if (error instanceof MalformedData) return fail({
+			code: "malformed-data",
+			path: error.path,
+			expected: error.expected
+		});
+		throw error;
+	}
+};
+const fieldPath = (path, field) => `${path}.${field}`;
+const itemPath = (path, index) => `${path}[${index}]`;
+/**
+* A fresh constructor value. Encoders always build new data, never reuse
+* decoded data: the `cbor` cache on decoded values wins over any edit.
+*/
+const constr = (index, fields = []) => ({
+	constructor: BigInt(index),
+	fields: { items: fields }
+});
+const list = (items) => ({ items });
+const bytes = (hex) => hexToBytes(hex);
+/** The constructor index of a value that must be a constructor. */
+const expectConstrIndex = (data, path, what) => {
+	if (!isConstrPlutusData(data)) throw new MalformedData(path, `${what} as a constructor`);
+	return data.constructor;
+};
+/** The fields of a constructor with exactly the given index and arity. */
+const expectConstr = (data, { index, arity }, { path, what }) => {
+	if (!isConstrPlutusData(data) || data.constructor !== BigInt(index) || data.fields.items.length !== arity) throw new MalformedData(path, `${what} as constructor ${index} with ${arity} fields`);
+	return data.fields.items;
+};
+/**
+* The fields of a constructor with the given index and at least `minArity`
+* fields, for a reader that relies only on a stable leading prefix.
+*/
+const expectConstrPrefix = (data, { index, minArity }, { path, what }) => {
+	if (!isConstrPlutusData(data) || data.constructor !== BigInt(index) || data.fields.items.length < minArity) throw new MalformedData(path, `${what} as constructor ${index} with at least ${minArity} fields`);
+	return data.fields.items;
+};
+const expectBytes = (data, path, what) => {
+	if (!isPlutusBoundedBytes(data)) throw new MalformedData(path, `${what} as bytes`);
+	return bytesToHex(data);
+};
+const expectInt = (data, path, what) => {
+	if (!isPlutusBigInt(data)) throw new MalformedData(path, `${what} as an integer`);
+	return data;
+};
+const expectList = (data, path, what) => {
+	if (!isPlutusList(data)) throw new MalformedData(path, `${what} as a list`);
+	return data.items;
+};
+/** Refuses a constructor index no alternative of a union claims. */
+const unknownAlternative = (path, what, index) => {
+	throw new MalformedData(path, `${what}, not constructor ${index}`);
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/codecs/recipient.ts
+const credentialFrom = (credential) => ({
+	type: credential.type,
+	hash: credential.hash
+});
+/**
+* The recipient form of a Shelley payment address. Base, enterprise and
+* pointer addresses have one; reward and Byron addresses do not.
+*/
+const custodyRecipientFromAddress = (address) => {
+	const base = address.asBase();
+	if (base) return ok({
+		paymentCredential: credentialFrom(base.getPaymentCredential()),
+		stakeCredential: {
+			kind: "inline",
+			credential: credentialFrom(base.getStakeCredential())
+		}
+	});
+	const enterprise = address.asEnterprise();
+	if (enterprise) return ok({ paymentCredential: credentialFrom(enterprise.getPaymentCredential()) });
+	const pointer = address.asPointer();
+	if (pointer) {
+		const { slot, txIndex, certIndex } = pointer.getStakePointer();
+		return ok({
+			paymentCredential: credentialFrom(pointer.getPaymentCredential()),
+			stakeCredential: {
+				kind: "pointer",
+				slot,
+				transactionIndex: BigInt(txIndex),
+				certificateIndex: BigInt(certIndex)
+			}
+		});
+	}
+	return fail({
+		code: "unsupported-recipient-address",
+		addressType: address.getType()
+	});
+};
+const isPointerIndex = (value) => value >= 0n && value <= BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* Whether a recipient names an address Cardano can encode: 28-byte credential
+* hashes and, for a pointer, non-negative indices that fit a pointer address.
+*/
+const isRepresentableRecipient = (recipient) => {
+	if (!isHash28Hex(recipient.paymentCredential.hash)) return false;
+	const stake = recipient.stakeCredential;
+	if (!stake) return true;
+	if (stake.kind === "inline") return isHash28Hex(stake.credential.hash);
+	return stake.slot >= 0n && isPointerIndex(stake.transactionIndex) && isPointerIndex(stake.certificateIndex);
+};
+const toCardanoCredential = (credential) => ({
+	type: credential.type,
+	hash: credential.hash
+});
+/** The address of a recipient the caller has checked is representable. */
+const addressOfRepresentableRecipient = (recipient, networkId) => {
+	const payment = toCardanoCredential(recipient.paymentCredential);
+	const stake = recipient.stakeCredential;
+	if (!stake) return EnterpriseAddress.fromCredentials(networkId, payment).toAddress();
+	if (stake.kind === "inline") return BaseAddress.fromCredentials(networkId, payment, toCardanoCredential(stake.credential)).toAddress();
+	return new Address({
+		type: payment.type === CredentialType.ScriptHash ? AddressType.PointerScript : AddressType.PointerKey,
+		networkId,
+		paymentPart: payment,
+		pointer: {
+			slot: stake.slot,
+			txIndex: TxIndex(Number(stake.transactionIndex)),
+			certIndex: CertIndex(Number(stake.certificateIndex))
+		}
+	});
+};
+/** The address a recipient stands for on the given network. */
+const custodyRecipientToAddress = (recipient, networkId) => isRepresentableRecipient(recipient) ? ok(addressOfRepresentableRecipient(recipient, networkId)) : fail({
+	code: "unrepresentable-recipient",
+	recipient
+});
+/** A value two recipients share exactly when their Plutus data is equal. */
+const recipientKey = (recipient) => {
+	const credentialKey = ({ type, hash }) => `${type}:${hash}`;
+	const stake = recipient.stakeCredential;
+	const stakeKey = !stake ? "none" : stake.kind === "inline" ? `inline:${credentialKey(stake.credential)}` : `pointer:${stake.slot}:${stake.transactionIndex}:${stake.certificateIndex}`;
+	return `${credentialKey(recipient.paymentCredential)}/${stakeKey}`;
+};
+const CREDENTIAL_CONSTRUCTOR = {
+	[CredentialType.KeyHash]: 0,
+	[CredentialType.ScriptHash]: 1
+};
+const encodeCredential = (credential) => constr(CREDENTIAL_CONSTRUCTOR[credential.type], [bytes(credential.hash)]);
+const decodeCredential = (data, path) => {
+	const index = expectConstrIndex(data, path, "a credential");
+	const type = index === 0n ? CredentialType.KeyHash : index === 1n ? CredentialType.ScriptHash : unknownAlternative(path, "a key or script credential", index);
+	const [hash] = expectConstr(data, {
+		index: Number(index),
+		arity: 1
+	}, {
+		path,
+		what: "a credential"
+	});
+	return {
+		type,
+		hash: expectBytes(hash, fieldPath(path, "hash"), "a hash")
+	};
+};
+const encodeStakeCredential = (stake) => stake.kind === "inline" ? constr(0, [encodeCredential(stake.credential)]) : constr(1, [
+	stake.slot,
+	stake.transactionIndex,
+	stake.certificateIndex
+]);
+const decodeStakeCredential = (data, path) => {
+	const index = expectConstrIndex(data, path, "a stake credential");
+	if (index === 0n) {
+		const [credential] = expectConstr(data, {
+			index: 0,
+			arity: 1
+		}, {
+			path,
+			what: "an inline stake credential"
+		});
+		return {
+			kind: "inline",
+			credential: decodeCredential(credential, fieldPath(path, "credential"))
+		};
+	}
+	if (index !== 1n) return unknownAlternative(path, "an inline or pointer stake credential", index);
+	const [slot, transactionIndex, certificateIndex] = expectConstr(data, {
+		index: 1,
+		arity: 3
+	}, {
+		path,
+		what: "a stake pointer"
+	});
+	return {
+		kind: "pointer",
+		slot: expectInt(slot, fieldPath(path, "slot"), "a slot"),
+		transactionIndex: expectInt(transactionIndex, fieldPath(path, "transactionIndex"), "a transaction index"),
+		certificateIndex: expectInt(certificateIndex, fieldPath(path, "certificateIndex"), "a certificate index")
+	};
+};
+/** `Address { payment_credential, stake_credential: Option<StakeCredential> }`. */
+const encodeRecipient = (recipient) => constr(0, [encodeCredential(recipient.paymentCredential), recipient.stakeCredential ? constr(0, [encodeStakeCredential(recipient.stakeCredential)]) : constr(1)]);
+const decodeRecipient = (data, path) => {
+	const [payment, optionalStake] = expectConstr(data, {
+		index: 0,
+		arity: 2
+	}, {
+		path,
+		what: "an address"
+	});
+	const paymentCredential = decodeCredential(payment, fieldPath(path, "paymentCredential"));
+	const stakePath = fieldPath(path, "stakeCredential");
+	const option = expectConstrIndex(optionalStake, stakePath, "an option");
+	if (option === 1n) {
+		expectConstr(optionalStake, {
+			index: 1,
+			arity: 0
+		}, {
+			path: stakePath,
+			what: "None"
+		});
+		return { paymentCredential };
+	}
+	if (option !== 0n) return unknownAlternative(stakePath, "Some or None", option);
+	const [stake] = expectConstr(optionalStake, {
+		index: 0,
+		arity: 1
+	}, {
+		path: stakePath,
+		what: "Some"
+	});
+	return {
+		paymentCredential,
+		stakeCredential: decodeStakeCredential(stake, stakePath)
+	};
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/codecs/account-state.ts
+const encodeAsset = (asset) => constr(0, [bytes(asset.policyId), bytes(asset.assetName)]);
+const decodeAsset = (data, path) => {
+	const [policyId, assetName] = expectConstr(data, {
+		index: 0,
+		arity: 2
+	}, {
+		path,
+		what: "an asset"
+	});
+	return {
+		policyId: expectBytes(policyId, fieldPath(path, "policyId"), "a policy id"),
+		assetName: expectBytes(assetName, fieldPath(path, "assetName"), "an asset name")
+	};
+};
+/** Fields in declaration order: the lovelace per call cap precedes the lovelace cap. */
+const encodeScope = (scope) => constr(0, [
+	encodeAsset(scope.asset),
+	scope.perCallCap,
+	scope.cap,
+	scope.lovelacePerCallCap,
+	scope.lovelaceCap,
+	scope.expiresAt,
+	list(scope.recipients.map(encodeRecipient))
+]);
+const decodeScope = (data, path) => {
+	const [asset, perCallCap, cap, lovelacePerCallCap, lovelaceCap, expiresAt, recipients] = expectConstr(data, {
+		index: 0,
+		arity: 7
+	}, {
+		path,
+		what: "a scope"
+	});
+	const recipientsPath = fieldPath(path, "recipients");
+	return {
+		asset: decodeAsset(asset, fieldPath(path, "asset")),
+		perCallCap: expectInt(perCallCap, fieldPath(path, "perCallCap"), "a per call cap"),
+		cap: expectInt(cap, fieldPath(path, "cap"), "a cap"),
+		lovelacePerCallCap: expectInt(lovelacePerCallCap, fieldPath(path, "lovelacePerCallCap"), "a lovelace per call cap"),
+		lovelaceCap: expectInt(lovelaceCap, fieldPath(path, "lovelaceCap"), "a lovelace cap"),
+		expiresAt: expectInt(expiresAt, fieldPath(path, "expiresAt"), "an expiry"),
+		recipients: expectList(recipients, recipientsPath, "recipients").map((recipient, index) => decodeRecipient(recipient, itemPath(recipientsPath, index)))
+	};
+};
+/**
+* The inline datum of a grant UTxO. Always fresh Plutus data, like the state
+* encoder. Throws `InvalidStringError` for a key hash, asset or credential
+* hash that is not hex of whole bytes.
+*/
+const encodeCustodyGrant = (grant) => constr(0, [
+	grant.slot,
+	bytes(grant.grantee),
+	grant.generation,
+	encodeScope(grant.scope)
+]);
+/**
+* The grant a grant UTxO datum carries. Accepts exactly the shapes the
+* logic's soft cast accepts and applies no authoring rule;
+* `findCustodyGrantViolations` marks what Lace would not author.
+*/
+const decodeCustodyGrant = (data) => decodeResult(() => {
+	const [slot, grantee, generation, scope] = expectConstr(data, {
+		index: 0,
+		arity: 4
+	}, {
+		path: "",
+		what: "a grant"
+	});
+	return {
+		slot: expectInt(slot, "slot", "a slot"),
+		grantee: expectBytes(grantee, "grantee", "a grantee key hash"),
+		generation: expectInt(generation, "generation", "a generation"),
+		scope: decodeScope(scope, "scope")
+	};
+});
+/**
+* The control UTxO datum for a state. Always fresh Plutus data, so edits made
+* to a decoded state are never masked by the original encoding.
+*
+* Throws `InvalidStringError` for a logic or device key hash that is not hex
+* of whole bytes, instead of writing other bytes than the state holds. A
+* decoded state, and a state `findCustodyStateViolations` accepts, always
+* encode.
+*/
+const encodeCustodyAccountState = (state) => constr(0, [
+	bytes(state.logic),
+	list(state.devices.map((device) => bytes(device))),
+	state.grantGeneration,
+	state.nextSlot,
+	list([...state.revoked]),
+	state.outstanding
+]);
+const decodeLogic = (data) => expectBytes(data, "logic", "a logic hash");
+const decodeDevices = (data) => expectList(data, "devices", "devices").map((device, index) => expectBytes(device, itemPath("devices", index), "a device key hash"));
+/**
+* The state a control UTxO datum carries. Accepts exactly the shapes the
+* logic's soft cast accepts: canonical constructor indices and exact
+* field counts. It applies no authoring rule, so an on-chain device with an
+* ill-sized hash still decodes; `findCustodyStateViolations` marks it.
+*/
+const decodeCustodyAccountState = (data) => decodeResult(() => {
+	const [logic, devices, grantGeneration, nextSlot, revoked, outstanding] = expectConstr(data, {
+		index: 0,
+		arity: 6
+	}, {
+		path: "",
+		what: "an account state"
+	});
+	return {
+		logic: decodeLogic(logic),
+		devices: decodeDevices(devices),
+		grantGeneration: expectInt(grantGeneration, "grantGeneration", "a grant generation"),
+		nextSlot: expectInt(nextSlot, "nextSlot", "a next slot"),
+		revoked: expectList(revoked, "revoked", "revoked slots").map((slot, index) => expectInt(slot, itemPath("revoked", index), "a revoked slot")),
+		outstanding: expectInt(outstanding, "outstanding", "an outstanding count")
+	};
+});
+/**
+* The logic hash a control UTxO datum names in its first field, whatever the
+* field count, as the proxy reads it.
+*/
+const decodeCustodyStateLogic = (data) => decodeResult(() => {
+	const [logic] = expectConstrPrefix(data, {
+		index: 0,
+		minArity: 1
+	}, {
+		path: "",
+		what: "an account state"
+	});
+	return decodeLogic(logic);
+});
+/**
+* The device key hashes of a control UTxO datum, read from its second field
+* whatever the field count, as the stake script reads them. The devices are
+* only as trustworthy as the logic that admitted them, so a reader first
+* checks the logic `decodeCustodyStateLogic` names.
+*/
+const decodeCustodyStateDevices = (data) => decodeResult(() => {
+	const [, devices] = expectConstrPrefix(data, {
+		index: 0,
+		minArity: 2
+	}, {
+		path: "",
+		what: "an account state"
+	});
+	return decodeDevices(devices);
+});
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/tokens.ts
+/** Bytes of the big-endian slot a grant token name appends to the stake script hash. */
+const SLOT_BYTES = 4;
+const SLOT_HEX_LENGTH = SLOT_BYTES * 2;
+const STAKE_SCRIPT_HASH_HEX_LENGTH = 56;
+/** The first slot a grant token name cannot carry. */
+const CUSTODY_SLOT_LIMIT = 1n << BigInt(SLOT_BYTES * 8);
+/**
+* The name of an account's grant token for `slot`: the stake script hash
+* followed by the slot as four big-endian bytes. Throws `RangeError` for a
+* slot outside 0 to 2^32 - 1, which no grant token can carry.
+*
+* @param stakeScriptHash - lower-case hex of exactly 28 bytes, checked by the caller
+*/
+const custodyGrantTokenName = (stakeScriptHash, slot) => {
+	if (slot < 0n || slot >= CUSTODY_SLOT_LIMIT) throw new RangeError(`Slot ${slot} does not fit a grant token name`);
+	return AssetName(`${stakeScriptHash}${slot.toString(16).padStart(SLOT_HEX_LENGTH, "0")}`);
+};
+/**
+* The asset id of an account's grant token for `slot`, under the account
+* validator's policy. Throws like `custodyGrantTokenName`.
+*/
+const custodyGrantAssetId = ({ accountValidatorHash, stakeScriptHash }, slot) => AssetId.fromParts(PolicyId(accountValidatorHash), custodyGrantTokenName(stakeScriptHash, slot));
+/**
+* What a token name under the account policy names, or undefined when it
+* has neither contract shape. The policy is the caller's to check.
+*/
+const parseCustodyAccountTokenName = (name) => {
+	if (!isLowerCaseHex(name)) return void 0;
+	const stakeScriptHash = name.slice(0, STAKE_SCRIPT_HASH_HEX_LENGTH);
+	if (name.length === STAKE_SCRIPT_HASH_HEX_LENGTH) return {
+		kind: "state-nft",
+		stakeScriptHash
+	};
+	if (name.length === STAKE_SCRIPT_HASH_HEX_LENGTH + SLOT_HEX_LENGTH) return {
+		kind: "grant",
+		stakeScriptHash,
+		slot: BigInt(`0x${name.slice(STAKE_SCRIPT_HASH_HEX_LENGTH)}`)
+	};
+};
+const MAX_ASSET_NAME_BYTES = 32;
+const POLICY_ID_BYTES = 28;
+const CUSTODY_LOVELACE_ASSET = {
+	policyId: "",
+	assetName: ""
+};
+const isCustodyLovelaceAsset = (asset) => asset.policyId === "" && asset.assetName === "";
+const isPolicyIdWellFormed = (policyId) => policyId === "" || isLowerCaseHex(policyId, POLICY_ID_BYTES);
+const isAssetNameWellFormed = ({ policyId, assetName }) => isLowerCaseHex(assetName) && assetName.length <= MAX_ASSET_NAME_BYTES * 2 && (policyId !== "" || assetName === "");
+const CAP_FIELDS = [
+	"perCallCap",
+	"cap",
+	"lovelacePerCallCap",
+	"lovelaceCap"
+];
+/** Every rule a grant breaks, in field order; empty for an authorable grant. */
+const findCustodyGrantViolations = (grant) => {
+	const { slot, scope } = grant;
+	const violations = [];
+	if (slot < 0n || slot >= CUSTODY_SLOT_LIMIT) violations.push({
+		code: "slot-out-of-range",
+		slot
+	});
+	if (!isHash28Hex(grant.grantee)) violations.push({
+		code: "invalid-grantee-key-hash",
+		slot
+	});
+	if (grant.generation < 0n) violations.push({
+		code: "negative-generation",
+		slot
+	});
+	if (!isPolicyIdWellFormed(scope.asset.policyId)) violations.push({
+		code: "invalid-policy-id",
+		slot
+	});
+	if (!isAssetNameWellFormed(scope.asset)) violations.push({
+		code: "invalid-asset-name",
+		slot
+	});
+	for (const field of CAP_FIELDS) if (scope[field] < 0n) violations.push({
+		code: "negative-cap",
+		field,
+		slot
+	});
+	if (isCustodyLovelaceAsset(scope.asset) && (scope.lovelacePerCallCap !== 0n || scope.lovelaceCap !== 0n)) violations.push({
+		code: "lovelace-grant-lovelace-caps",
+		slot
+	});
+	if (scope.expiresAt <= 0n) violations.push({
+		code: "non-positive-expiry",
+		slot
+	});
+	if (scope.recipients.length > 8) violations.push({
+		code: "recipient-count",
+		count: scope.recipients.length,
+		slot
+	});
+	const seenRecipients = /* @__PURE__ */ new Set();
+	for (const [recipientIndex, recipient] of scope.recipients.entries()) {
+		if (!isRepresentableRecipient(recipient)) violations.push({
+			code: "unrepresentable-recipient",
+			recipientIndex,
+			slot
+		});
+		const key = recipientKey(recipient);
+		if (seenRecipients.has(key)) violations.push({
+			code: "duplicate-recipient",
+			recipientIndex,
+			slot
+		});
+		seenRecipients.add(key);
+	}
+	return violations;
+};
+/**
+* Every rule a control state breaks: the contract's well-formedness bounds
+* plus a 28-byte logic hash and 28-byte device key hashes. Apply it to every
+* state Lace builds or approves. An on-chain state may hold an ill-sized
+* device, which can never sign; its violation names it so a device can
+* remove it.
+*/
+const findCustodyStateViolations = (state) => {
+	const violations = [];
+	if (!isHash28Hex(state.logic)) violations.push({
+		code: "invalid-logic-hash",
+		logic: state.logic
+	});
+	const deviceCount = state.devices.length;
+	if (deviceCount < 1 || deviceCount > 8) violations.push({
+		code: "device-count",
+		count: deviceCount
+	});
+	const seenDevices = /* @__PURE__ */ new Set();
+	for (const [deviceIndex, device] of state.devices.entries()) {
+		if (!isHash28Hex(device)) violations.push({
+			code: "invalid-device-key-hash",
+			device,
+			deviceIndex
+		});
+		if (seenDevices.has(device)) violations.push({
+			code: "duplicate-device",
+			device,
+			deviceIndex
+		});
+		seenDevices.add(device);
+	}
+	if (state.grantGeneration < 0n) violations.push({ code: "negative-grant-generation" });
+	if (state.nextSlot < 0n) violations.push({ code: "negative-next-slot" });
+	if (state.outstanding < 0n) violations.push({ code: "negative-outstanding" });
+	if (state.outstanding > BigInt(16)) violations.push({
+		code: "outstanding-count",
+		count: state.outstanding
+	});
+	if (state.revoked.length > 32) violations.push({
+		code: "revoked-count",
+		count: state.revoked.length
+	});
+	return violations;
+};
+/**
+* Whether a grant can no longer be used at `now` (POSIX milliseconds): a
+* spend's upper validity bound must not pass `expiresAt`, so a grant is
+* expired from the instant it names. A non-finite `now` is a broken clock,
+* which can never show a grant as usable, so it counts as expired.
+*/
+const isCustodyGrantExpired = (grant, now) => !Number.isFinite(now) || grant.scope.expiresAt <= BigInt(Math.floor(now));
+/**
+* Whether a grant is current against a control state, as the contract
+* judges a spend: issued under the state's generation and not revoked by
+* slot. Expiry is the validity range's business.
+*/
+const isCustodyGrantCurrent = (grant, state) => grant.generation === state.grantGeneration && !state.revoked.includes(grant.slot);
+//#endregion
+//#region ../../node_modules/@cardano-sdk/tx-construction/dist/esm/fees/fees.js
+init__polyfill_buffer_patch();
+const MIN_ADA_CONSTANT_OVERHEAD = 160;
+const serializeBigInt = (bigInt) => {
+	const writer = new CborWriter();
+	writer.writeInt(BigInt(bigInt));
+	return writer.encode();
+};
+const serializeTxOutputSize = (output) => TransactionOutput.fromCore(output).toCbor().length / 2;
+const serializeTx = (tx) => import_buffer.Buffer.from(Transaction.fromCore(tx).toCbor(), "hex");
+const getTotalExUnits = (redeemers) => {
+	const totalExUnits = {
+		memory: 0,
+		steps: 0
+	};
+	for (const redeemer of redeemers) {
+		totalExUnits.memory += redeemer.executionUnits.memory;
+		totalExUnits.steps += redeemer.executionUnits.steps;
+	}
+	return totalExUnits;
+};
+const minRefScriptFee = (tx, resolvedInputs, coinsPerRefScriptByte) => {
+	if (coinsPerRefScriptByte === 0) return BigInt(0);
+	let base = coinsPerRefScriptByte;
+	const range = 25600;
+	const multiplier = 1.2;
+	let totalRefScriptsSize = 0;
+	const totalInputs = [...tx.body.inputs, ...tx.body.referenceInputs ?? []];
+	for (const output of totalInputs) {
+		const resolvedInput = resolvedInputs.find((input) => input[0].txId === output.txId && input[0].index === output.index);
+		if (resolvedInput && resolvedInput[1].scriptReference) totalRefScriptsSize += Script.fromCore(resolvedInput[1].scriptReference).toCbor().length / 2;
+	}
+	let scriptRefFee = 0;
+	while (totalRefScriptsSize > 0) {
+		scriptRefFee += Math.ceil(Math.min(range, totalRefScriptsSize) * base);
+		totalRefScriptsSize = Math.max(totalRefScriptsSize - range, 0);
+		base *= multiplier;
+	}
+	return BigInt(scriptRefFee);
+};
+const minScriptFee = (tx, exUnitsPrice, resolvedInputs, coinsPerRefScriptByte) => {
+	const scriptRefFee = minRefScriptFee(tx, resolvedInputs, coinsPerRefScriptByte);
+	if (!tx.witness.redeemers) return BigInt(scriptRefFee);
+	const totalExUnits = getTotalExUnits(tx.witness.redeemers);
+	return BigInt(Math.ceil(totalExUnits.steps * exUnitsPrice.steps + totalExUnits.memory * exUnitsPrice.memory)) + scriptRefFee;
+};
+const minNoScriptFee = (tx, minFeeConstant, minFeeCoefficient) => {
+	const txSize = serializeTx(tx).length;
+	return BigInt(Math.ceil(txSize * minFeeCoefficient + minFeeConstant));
+};
+const minAdaRequired = (output, coinsPerUtxoByte) => {
+	const oldCoinSize = serializeBigInt(output.value.coins.toString()).length;
+	let latestSize = oldCoinSize;
+	let isDone = false;
+	while (!isDone) {
+		const sizeDiff = latestSize - oldCoinSize;
+		const newCoinSize = serializeBigInt((BigInt(serializeTxOutputSize(output) + MIN_ADA_CONSTANT_OVERHEAD + sizeDiff) * coinsPerUtxoByte).toString()).length;
+		isDone = latestSize === newCoinSize;
+		latestSize = newCoinSize;
+	}
+	const sizeChange = latestSize - oldCoinSize;
+	return BigInt(serializeTxOutputSize(output) + MIN_ADA_CONSTANT_OVERHEAD + sizeChange) * coinsPerUtxoByte;
+};
+const minFee = (tx, resolvedInputs, pparams) => minNoScriptFee(tx, pparams.minFeeConstant, pparams.minFeeCoefficient) + minScriptFee(tx, pparams.prices, resolvedInputs, pparams.minFeeRefScriptCostPerByte ? Number(pparams.minFeeRefScriptCostPerByte) : 0);
+//#endregion
+export { decodeResult as C, coalesceValueQuantities as D, unknownAlternative as E, coalesceTokenMaps as O, constr as S, expectConstrIndex as T, encodeCustodyGrant as _, findCustodyStateViolations as a, custodyRecipientToAddress as b, isCustodyLovelaceAsset as c, parseCustodyAccountTokenName as d, decodeCustodyAccountState as f, encodeCustodyAccountState as g, decodeCustodyStateLogic as h, findCustodyGrantViolations as i, CUSTODY_SLOT_LIMIT as l, decodeCustodyStateDevices as m, minFee as n, isCustodyGrantCurrent as o, decodeCustodyGrant as p, CUSTODY_LOVELACE_ASSET as r, isCustodyGrantExpired as s, minAdaRequired as t, custodyGrantAssetId as u, addressOfRepresentableRecipient as v, expectConstr as w, recipientKey as x, custodyRecipientFromAddress as y };