@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/grant-status-CDmZpx32.js

@@ -0,0 +1,296 @@
+import { Bt as AssetName, Vt as PolicyId, Zt as Hash28ByteBase16, c as EnterpriseAddress, nt as PlutusData, r as CredentialType, zt as AssetId } from "./Address-_c_-9hLC.js";
+import { b as custodyRecipientToAddress, c as isCustodyLovelaceAsset, d as parseCustodyAccountTokenName, f as decodeCustodyAccountState, h as decodeCustodyStateLogic, o as isCustodyGrantCurrent, p as decodeCustodyGrant, s as isCustodyGrantExpired, t as minAdaRequired } from "./fees-6C2uEWFK.js";
+import { l as findCustodyContractVersion, u as findCustodyLogic } from "./hex-CGYJPK_Z.js";
+//#region ../../packages/lib/cardano-custody/src/codecs/reserve.ts
+/** The datum the upstream library writes on a reserve: constructor 0 with no fields. */
+const RESERVE_DATUM_CBOR = "d87980";
+/**
+* Whether an inline datum is, byte for byte, the reserve datum `d87980`.
+* Any datum makes a deposit an owner-only reserve; only this one has a known
+* size, so a builder can spend such a reserve without a surprise in fee or
+* minimum lovelace.
+*/
+const isCustodyReserveDatum = (datum) => PlutusData.fromCore(datum).toCbor() === RESERVE_DATUM_CBOR;
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/classify.ts
+/** The tokens of a value under a policy. */
+const tokensUnder = (value, policyId) => [...value.assets?.entries() ?? []].filter(([assetId, quantity]) => quantity !== 0n && AssetId.getPolicyId(assetId) === policyId).map(([assetId]) => assetId);
+/** Reads a UTxO that holds exactly one grant token of the account, in quantity one. */
+const classifyGrant = (utxo, token, slot) => {
+	const [, output] = utxo;
+	if (output.value.assets?.size !== 1) return { anomaly: {
+		code: "grant-value-not-strict",
+		utxo,
+		slot
+	} };
+	if (output.datum === void 0) return { anomaly: {
+		code: "grant-datum-not-inline",
+		utxo,
+		slot
+	} };
+	const decoded = decodeCustodyGrant(output.datum);
+	if (!decoded.ok) return { anomaly: {
+		code: "grant-datum-malformed",
+		utxo,
+		slot,
+		error: decoded.error
+	} };
+	if (decoded.value.slot !== slot) return { anomaly: {
+		code: "grant-slot-mismatch",
+		utxo,
+		slot,
+		datumSlot: decoded.value.slot
+	} };
+	return { grant: {
+		utxo,
+		grant: decoded.value,
+		token
+	} };
+};
+/** The grant token and its slot, when the tokens are exactly one own grant token held once. */
+const ownGrantToken = (account, value, tokens) => {
+	const [token] = tokens;
+	if (tokens.length !== 1 || value.assets?.get(token) !== 1n) return void 0;
+	const name = parseCustodyAccountTokenName(AssetId.getAssetName(token));
+	return name?.kind === "grant" && name.stakeScriptHash === account.stakeScriptHash ? {
+		token,
+		slot: name.slot
+	} : void 0;
+};
+/**
+* Sorts an account's UTxOs by kind. UTxOs not at the exact account address
+* are ignored. It never throws: a UTxO that holds an account token in a
+* shape the contract rules out is listed in `anomalies`.
+*/
+const classifyCustodyAccountUtxos = (account, utxos) => {
+	const policyId = PolicyId(account.accountValidatorHash);
+	const stateNft = AssetId.fromParts(policyId, AssetName(account.stakeScriptHash));
+	const controls = [];
+	const grants = [];
+	const own = [];
+	const foreign = [];
+	const funds = [];
+	const stranded = [];
+	const anomalies = [];
+	for (const utxo of utxos) {
+		const [, output] = utxo;
+		if (output.address !== account.address) continue;
+		const tokens = tokensUnder(output.value, policyId);
+		if (tokens.includes(stateNft)) controls.push(utxo);
+		else if (tokens.length > 0) {
+			const grantToken = ownGrantToken(account, output.value, tokens);
+			if (!grantToken) {
+				anomalies.push({
+					code: "unexpected-account-tokens",
+					utxo,
+					assetIds: tokens
+				});
+				continue;
+			}
+			const classified = classifyGrant(utxo, grantToken.token, grantToken.slot);
+			if ("grant" in classified) grants.push(classified.grant);
+			else anomalies.push(classified.anomaly);
+		} else if (output.datum !== void 0) (output.scriptReference === void 0 && isCustodyReserveDatum(output.datum) ? own : foreign).push(utxo);
+		else if (output.datumHash === void 0) funds.push(utxo);
+		else stranded.push(utxo);
+	}
+	grants.sort((a, b) => a.grant.slot < b.grant.slot ? -1 : a.grant.slot > b.grant.slot ? 1 : 0);
+	return {
+		controls,
+		grants,
+		reserves: {
+			own,
+			foreign
+		},
+		funds,
+		stranded,
+		anomalies
+	};
+};
+/**
+* The liveness of a grant against a control state at `now`. A grant dead for
+* several reasons takes the first of superseded, revoked and expired, so
+* `expired` alone means a sweep needs a validity interval that starts after
+* the expiry.
+*
+* @param now - POSIX milliseconds; a non-finite value counts as past every expiry
+*/
+const custodyGrantLiveness = (grant, state, now) => {
+	if (grant.generation < state.grantGeneration) return "superseded";
+	if (grant.generation > state.grantGeneration) return "future-generation";
+	if (!isCustodyGrantCurrent(grant, state)) return "revoked";
+	return isCustodyGrantExpired(grant, now) ? "expired" : "current";
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/account-state.ts
+/** Whether the account's contract version lists the logic in its catalogue. */
+const isKnownLogic = (accountValidatorHash, logic) => {
+	const version = findCustodyContractVersion(accountValidatorHash);
+	return version.ok && findCustodyLogic(version.value, logic).ok;
+};
+/**
+* Classifies a custody account's UTxOs by the rules of the custody contract
+* and reads the control state.
+*/
+const classifyCardanoCustodyAccount = ({ account, utxos, withdrawableRewards, protocolParameters }) => {
+	const { controls, grants, reserves, funds, stranded, anomalies } = classifyCustodyAccountUtxos(account, utxos);
+	const holdings = {
+		funds,
+		reserves,
+		grants,
+		grantLockedLovelace: grants.reduce((total, { utxo: [, output] }) => total + output.value.coins, 0n),
+		stranded,
+		anomalies,
+		withdrawableRewards
+	};
+	if (controls.length === 0) return {
+		...holdings,
+		status: "notCreated"
+	};
+	const invalid = (reason) => ({
+		...holdings,
+		status: "invalid",
+		reason,
+		controlUtxos: controls
+	});
+	if (controls.length > 1) return invalid({ code: "multiple-control-utxos" });
+	const [controlUtxo] = controls;
+	const [, controlOutput] = controlUtxo;
+	if (controlOutput.datum === void 0) return invalid({ code: "missing-inline-datum" });
+	const logic = decodeCustodyStateLogic(controlOutput.datum);
+	if (!logic.ok) return invalid({
+		code: "undecodable-state",
+		error: logic.error
+	});
+	if (!isKnownLogic(account.accountValidatorHash, logic.value)) return invalid({
+		code: "unknown-logic",
+		logic: logic.value
+	});
+	const decoded = decodeCustodyAccountState(controlOutput.datum);
+	if (!decoded.ok) return invalid({
+		code: "undecodable-state",
+		error: decoded.error
+	});
+	const controlMinimumLovelace = minAdaRequired(controlOutput, BigInt(protocolParameters.coinsPerUtxoByte));
+	const controlLovelace = controlOutput.value.coins;
+	const deviceKeyHash = account.device?.keyHash;
+	return {
+		...holdings,
+		status: "live",
+		controlUtxo,
+		state: decoded.value,
+		controlMinimumLovelace,
+		controlHeadroomLovelace: controlLovelace > controlMinimumLovelace ? controlLovelace - controlMinimumLovelace : 0n,
+		...deviceKeyHash !== void 0 && { currentDeviceListed: decoded.value.devices.some((device) => device.toLowerCase() === deviceKeyHash.toLowerCase()) }
+	};
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/build-transaction.ts
+/**
+* The most lovelace a grant spend's fee may take when the operation names
+* no `feeBound`: 1,500,000 lovelace. The spend lowers the grant's remaining caps by its outputs
+* and fee before the fee is final, so the bound is what the caps must leave
+* room for.
+*/
+const CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND = 1500000n;
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/grant-status.ts
+/**
+* Any key hash: an unrestricted grant pays out to any address, and an
+* enterprise key address makes the smallest output.
+*/
+const ANY_KEY_HASH = Hash28ByteBase16("00".repeat(28));
+/** The addresses a grant may pay out to, or one standing for any address. */
+const payoutAddressesOf = ({ recipients }, networkId) => {
+	if (recipients.length === 0) return [EnterpriseAddress.fromCredentials(networkId, {
+		type: CredentialType.KeyHash,
+		hash: ANY_KEY_HASH
+	}).toAddress().toBech32()];
+	return recipients.flatMap((recipient) => {
+		const address = custodyRecipientToAddress(recipient, networkId);
+		return address.ok ? [address.value.toBech32()] : [];
+	});
+};
+/** The scope's token, or undefined when its policy id or name is malformed. */
+const tokenOf = ({ asset }) => {
+	try {
+		return AssetId.fromParts(PolicyId(asset.policyId), AssetName(asset.assetName));
+	} catch {
+		return;
+	}
+};
+const smallerOf = (a, b) => a < b ? a : b;
+/**
+* Whether a grant scope can no longer pay the smallest spend. That spend
+* is one output to the cheapest address the grant allows, holding the
+* ledger minimum lovelace, plus the fee bound. A lovelace grant draws both
+* from its lovelace caps (`cap`, `perCallCap`). A token grant draws one
+* token from its token caps and the lovelace from `lovelaceCap` and
+* `lovelacePerCallCap`. A grant with no address it can pay is exhausted.
+*/
+const isCardanoCustodyGrantExhausted = (scope, { protocolParameters, networkId, feeBound = CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND }) => {
+	const isLovelace = isCustodyLovelaceAsset(scope.asset);
+	const token = isLovelace ? void 0 : tokenOf(scope);
+	if (!isLovelace && !token) return true;
+	const addresses = payoutAddressesOf(scope, networkId);
+	if (addresses.length === 0) return true;
+	const coinsPerUtxoByte = BigInt(protocolParameters.coinsPerUtxoByte);
+	const smallestLovelaceSpend = addresses.map((address) => minAdaRequired({
+		address,
+		value: {
+			coins: 0n,
+			...token && { assets: new Map([[token, 1n]]) }
+		}
+	}, coinsPerUtxoByte)).reduce(smallerOf) + feeBound;
+	if (isLovelace) return smallerOf(scope.cap, scope.perCallCap) < smallestLovelaceSpend;
+	return smallerOf(scope.cap, scope.perCallCap) < 1n || smallerOf(scope.lovelaceCap, scope.lovelacePerCallCap) < smallestLovelaceSpend;
+};
+const bySlot = ({ grant: a }, { grant: b }) => a.slot < b.slot ? -1 : a.slot > b.slot ? 1 : 0;
+/**
+* The status of a grant the confirmed view holds and the in-flight view
+* keeps. `grant` is its in-flight version: an unsettled grant spend lowers
+* its caps and changes nothing else.
+*/
+const confirmedGrantStatus = (grant, { confirmed, inFlight, now, ...pricing }) => {
+	const liveness = custodyGrantLiveness(grant, confirmed, now);
+	if (liveness === "revoked" || liveness === "superseded") return liveness;
+	if (liveness === "future-generation") return "pending";
+	const next = custodyGrantLiveness(grant, inFlight, now);
+	if (next === "revoked" || next === "superseded") return "revoking";
+	if (liveness === "expired") return "expired";
+	return isCardanoCustodyGrantExhausted(grant.scope, pricing) ? "exhausted" : "live";
+};
+/**
+* The status of every grant UTxO of a custody account, in slot order.
+* `inFlight` is the account after the submitted operations that have not
+* settled; `confirmed` is the account on chain, absent while it has no
+* confirmed control state. A grant is known by its slot, which no grant
+* ever reuses. `now` is POSIX milliseconds: the time of the chain tip.
+*
+* A grant only the in-flight view holds is `pending`, and one only the
+* confirmed view holds is `sweeping`. A grant both hold is judged against
+* the confirmed state, and is `revoking` when the in-flight state kills it.
+* Its listed version is the in-flight one, so an unsettled grant spend
+* shows its lowered caps at once.
+*/
+const classifyCardanoCustodyGrants = ({ confirmed, inFlight, now, protocolParameters, networkId }) => {
+	const confirmedSlots = new Set(confirmed?.grants.map(({ grant }) => grant.slot));
+	const inFlightSlots = new Set(inFlight.grants.map(({ grant }) => grant.slot));
+	const kept = inFlight.grants.map((grantUtxo) => ({
+		...grantUtxo,
+		status: confirmed && confirmedSlots.has(grantUtxo.grant.slot) ? confirmedGrantStatus(grantUtxo.grant, {
+			confirmed: confirmed.state,
+			inFlight: inFlight.state,
+			now,
+			protocolParameters,
+			networkId
+		}) : "pending"
+	}));
+	const swept = (confirmed?.grants ?? []).filter(({ grant }) => !inFlightSlots.has(grant.slot)).map((grantUtxo) => ({
+		...grantUtxo,
+		status: "sweeping"
+	}));
+	return [...kept, ...swept].sort(bySlot);
+};
+//#endregion
+export { classifyCustodyAccountUtxos as a, classifyCardanoCustodyAccount as i, isCardanoCustodyGrantExhausted as n, custodyGrantLiveness as o, CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND as r, isCustodyReserveDatum as s, classifyCardanoCustodyGrants as t };

package/dist/grant-status-CQtwjLsA.cjs

@@ -0,0 +1,337 @@
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_fees = require("./fees-DtC71fOx.cjs");
+const require_hex = require("./hex-BVtOKJki.cjs");
+//#region ../../packages/lib/cardano-custody/src/codecs/reserve.ts
+/** The datum the upstream library writes on a reserve: constructor 0 with no fields. */
+const RESERVE_DATUM_CBOR = "d87980";
+/**
+* Whether an inline datum is, byte for byte, the reserve datum `d87980`.
+* Any datum makes a deposit an owner-only reserve; only this one has a known
+* size, so a builder can spend such a reserve without a surprise in fee or
+* minimum lovelace.
+*/
+const isCustodyReserveDatum = (datum) => require_Address.PlutusData.fromCore(datum).toCbor() === RESERVE_DATUM_CBOR;
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/classify.ts
+/** The tokens of a value under a policy. */
+const tokensUnder = (value, policyId) => [...value.assets?.entries() ?? []].filter(([assetId, quantity]) => quantity !== 0n && require_Address.AssetId.getPolicyId(assetId) === policyId).map(([assetId]) => assetId);
+/** Reads a UTxO that holds exactly one grant token of the account, in quantity one. */
+const classifyGrant = (utxo, token, slot) => {
+	const [, output] = utxo;
+	if (output.value.assets?.size !== 1) return { anomaly: {
+		code: "grant-value-not-strict",
+		utxo,
+		slot
+	} };
+	if (output.datum === void 0) return { anomaly: {
+		code: "grant-datum-not-inline",
+		utxo,
+		slot
+	} };
+	const decoded = require_fees.decodeCustodyGrant(output.datum);
+	if (!decoded.ok) return { anomaly: {
+		code: "grant-datum-malformed",
+		utxo,
+		slot,
+		error: decoded.error
+	} };
+	if (decoded.value.slot !== slot) return { anomaly: {
+		code: "grant-slot-mismatch",
+		utxo,
+		slot,
+		datumSlot: decoded.value.slot
+	} };
+	return { grant: {
+		utxo,
+		grant: decoded.value,
+		token
+	} };
+};
+/** The grant token and its slot, when the tokens are exactly one own grant token held once. */
+const ownGrantToken = (account, value, tokens) => {
+	const [token] = tokens;
+	if (tokens.length !== 1 || value.assets?.get(token) !== 1n) return void 0;
+	const name = require_fees.parseCustodyAccountTokenName(require_Address.AssetId.getAssetName(token));
+	return name?.kind === "grant" && name.stakeScriptHash === account.stakeScriptHash ? {
+		token,
+		slot: name.slot
+	} : void 0;
+};
+/**
+* Sorts an account's UTxOs by kind. UTxOs not at the exact account address
+* are ignored. It never throws: a UTxO that holds an account token in a
+* shape the contract rules out is listed in `anomalies`.
+*/
+const classifyCustodyAccountUtxos = (account, utxos) => {
+	const policyId = require_Address.PolicyId(account.accountValidatorHash);
+	const stateNft = require_Address.AssetId.fromParts(policyId, require_Address.AssetName(account.stakeScriptHash));
+	const controls = [];
+	const grants = [];
+	const own = [];
+	const foreign = [];
+	const funds = [];
+	const stranded = [];
+	const anomalies = [];
+	for (const utxo of utxos) {
+		const [, output] = utxo;
+		if (output.address !== account.address) continue;
+		const tokens = tokensUnder(output.value, policyId);
+		if (tokens.includes(stateNft)) controls.push(utxo);
+		else if (tokens.length > 0) {
+			const grantToken = ownGrantToken(account, output.value, tokens);
+			if (!grantToken) {
+				anomalies.push({
+					code: "unexpected-account-tokens",
+					utxo,
+					assetIds: tokens
+				});
+				continue;
+			}
+			const classified = classifyGrant(utxo, grantToken.token, grantToken.slot);
+			if ("grant" in classified) grants.push(classified.grant);
+			else anomalies.push(classified.anomaly);
+		} else if (output.datum !== void 0) (output.scriptReference === void 0 && isCustodyReserveDatum(output.datum) ? own : foreign).push(utxo);
+		else if (output.datumHash === void 0) funds.push(utxo);
+		else stranded.push(utxo);
+	}
+	grants.sort((a, b) => a.grant.slot < b.grant.slot ? -1 : a.grant.slot > b.grant.slot ? 1 : 0);
+	return {
+		controls,
+		grants,
+		reserves: {
+			own,
+			foreign
+		},
+		funds,
+		stranded,
+		anomalies
+	};
+};
+/**
+* The liveness of a grant against a control state at `now`. A grant dead for
+* several reasons takes the first of superseded, revoked and expired, so
+* `expired` alone means a sweep needs a validity interval that starts after
+* the expiry.
+*
+* @param now - POSIX milliseconds; a non-finite value counts as past every expiry
+*/
+const custodyGrantLiveness = (grant, state, now) => {
+	if (grant.generation < state.grantGeneration) return "superseded";
+	if (grant.generation > state.grantGeneration) return "future-generation";
+	if (!require_fees.isCustodyGrantCurrent(grant, state)) return "revoked";
+	return require_fees.isCustodyGrantExpired(grant, now) ? "expired" : "current";
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/account-state.ts
+/** Whether the account's contract version lists the logic in its catalogue. */
+const isKnownLogic = (accountValidatorHash, logic) => {
+	const version = require_hex.findCustodyContractVersion(accountValidatorHash);
+	return version.ok && require_hex.findCustodyLogic(version.value, logic).ok;
+};
+/**
+* Classifies a custody account's UTxOs by the rules of the custody contract
+* and reads the control state.
+*/
+const classifyCardanoCustodyAccount = ({ account, utxos, withdrawableRewards, protocolParameters }) => {
+	const { controls, grants, reserves, funds, stranded, anomalies } = classifyCustodyAccountUtxos(account, utxos);
+	const holdings = {
+		funds,
+		reserves,
+		grants,
+		grantLockedLovelace: grants.reduce((total, { utxo: [, output] }) => total + output.value.coins, 0n),
+		stranded,
+		anomalies,
+		withdrawableRewards
+	};
+	if (controls.length === 0) return {
+		...holdings,
+		status: "notCreated"
+	};
+	const invalid = (reason) => ({
+		...holdings,
+		status: "invalid",
+		reason,
+		controlUtxos: controls
+	});
+	if (controls.length > 1) return invalid({ code: "multiple-control-utxos" });
+	const [controlUtxo] = controls;
+	const [, controlOutput] = controlUtxo;
+	if (controlOutput.datum === void 0) return invalid({ code: "missing-inline-datum" });
+	const logic = require_fees.decodeCustodyStateLogic(controlOutput.datum);
+	if (!logic.ok) return invalid({
+		code: "undecodable-state",
+		error: logic.error
+	});
+	if (!isKnownLogic(account.accountValidatorHash, logic.value)) return invalid({
+		code: "unknown-logic",
+		logic: logic.value
+	});
+	const decoded = require_fees.decodeCustodyAccountState(controlOutput.datum);
+	if (!decoded.ok) return invalid({
+		code: "undecodable-state",
+		error: decoded.error
+	});
+	const controlMinimumLovelace = require_fees.minAdaRequired(controlOutput, BigInt(protocolParameters.coinsPerUtxoByte));
+	const controlLovelace = controlOutput.value.coins;
+	const deviceKeyHash = account.device?.keyHash;
+	return {
+		...holdings,
+		status: "live",
+		controlUtxo,
+		state: decoded.value,
+		controlMinimumLovelace,
+		controlHeadroomLovelace: controlLovelace > controlMinimumLovelace ? controlLovelace - controlMinimumLovelace : 0n,
+		...deviceKeyHash !== void 0 && { currentDeviceListed: decoded.value.devices.some((device) => device.toLowerCase() === deviceKeyHash.toLowerCase()) }
+	};
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/build-transaction.ts
+/**
+* The most lovelace a grant spend's fee may take when the operation names
+* no `feeBound`: 1,500,000 lovelace. The spend lowers the grant's remaining caps by its outputs
+* and fee before the fee is final, so the bound is what the caps must leave
+* room for.
+*/
+const CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND = 1500000n;
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/grant-status.ts
+/**
+* Any key hash: an unrestricted grant pays out to any address, and an
+* enterprise key address makes the smallest output.
+*/
+const ANY_KEY_HASH = require_Address.Hash28ByteBase16("00".repeat(28));
+/** The addresses a grant may pay out to, or one standing for any address. */
+const payoutAddressesOf = ({ recipients }, networkId) => {
+	if (recipients.length === 0) return [require_Address.EnterpriseAddress.fromCredentials(networkId, {
+		type: require_Address.CredentialType.KeyHash,
+		hash: ANY_KEY_HASH
+	}).toAddress().toBech32()];
+	return recipients.flatMap((recipient) => {
+		const address = require_fees.custodyRecipientToAddress(recipient, networkId);
+		return address.ok ? [address.value.toBech32()] : [];
+	});
+};
+/** The scope's token, or undefined when its policy id or name is malformed. */
+const tokenOf = ({ asset }) => {
+	try {
+		return require_Address.AssetId.fromParts(require_Address.PolicyId(asset.policyId), require_Address.AssetName(asset.assetName));
+	} catch {
+		return;
+	}
+};
+const smallerOf = (a, b) => a < b ? a : b;
+/**
+* Whether a grant scope can no longer pay the smallest spend. That spend
+* is one output to the cheapest address the grant allows, holding the
+* ledger minimum lovelace, plus the fee bound. A lovelace grant draws both
+* from its lovelace caps (`cap`, `perCallCap`). A token grant draws one
+* token from its token caps and the lovelace from `lovelaceCap` and
+* `lovelacePerCallCap`. A grant with no address it can pay is exhausted.
+*/
+const isCardanoCustodyGrantExhausted = (scope, { protocolParameters, networkId, feeBound = CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND }) => {
+	const isLovelace = require_fees.isCustodyLovelaceAsset(scope.asset);
+	const token = isLovelace ? void 0 : tokenOf(scope);
+	if (!isLovelace && !token) return true;
+	const addresses = payoutAddressesOf(scope, networkId);
+	if (addresses.length === 0) return true;
+	const coinsPerUtxoByte = BigInt(protocolParameters.coinsPerUtxoByte);
+	const smallestLovelaceSpend = addresses.map((address) => require_fees.minAdaRequired({
+		address,
+		value: {
+			coins: 0n,
+			...token && { assets: new Map([[token, 1n]]) }
+		}
+	}, coinsPerUtxoByte)).reduce(smallerOf) + feeBound;
+	if (isLovelace) return smallerOf(scope.cap, scope.perCallCap) < smallestLovelaceSpend;
+	return smallerOf(scope.cap, scope.perCallCap) < 1n || smallerOf(scope.lovelaceCap, scope.lovelacePerCallCap) < smallestLovelaceSpend;
+};
+const bySlot = ({ grant: a }, { grant: b }) => a.slot < b.slot ? -1 : a.slot > b.slot ? 1 : 0;
+/**
+* The status of a grant the confirmed view holds and the in-flight view
+* keeps. `grant` is its in-flight version: an unsettled grant spend lowers
+* its caps and changes nothing else.
+*/
+const confirmedGrantStatus = (grant, { confirmed, inFlight, now, ...pricing }) => {
+	const liveness = custodyGrantLiveness(grant, confirmed, now);
+	if (liveness === "revoked" || liveness === "superseded") return liveness;
+	if (liveness === "future-generation") return "pending";
+	const next = custodyGrantLiveness(grant, inFlight, now);
+	if (next === "revoked" || next === "superseded") return "revoking";
+	if (liveness === "expired") return "expired";
+	return isCardanoCustodyGrantExhausted(grant.scope, pricing) ? "exhausted" : "live";
+};
+/**
+* The status of every grant UTxO of a custody account, in slot order.
+* `inFlight` is the account after the submitted operations that have not
+* settled; `confirmed` is the account on chain, absent while it has no
+* confirmed control state. A grant is known by its slot, which no grant
+* ever reuses. `now` is POSIX milliseconds: the time of the chain tip.
+*
+* A grant only the in-flight view holds is `pending`, and one only the
+* confirmed view holds is `sweeping`. A grant both hold is judged against
+* the confirmed state, and is `revoking` when the in-flight state kills it.
+* Its listed version is the in-flight one, so an unsettled grant spend
+* shows its lowered caps at once.
+*/
+const classifyCardanoCustodyGrants = ({ confirmed, inFlight, now, protocolParameters, networkId }) => {
+	const confirmedSlots = new Set(confirmed?.grants.map(({ grant }) => grant.slot));
+	const inFlightSlots = new Set(inFlight.grants.map(({ grant }) => grant.slot));
+	const kept = inFlight.grants.map((grantUtxo) => ({
+		...grantUtxo,
+		status: confirmed && confirmedSlots.has(grantUtxo.grant.slot) ? confirmedGrantStatus(grantUtxo.grant, {
+			confirmed: confirmed.state,
+			inFlight: inFlight.state,
+			now,
+			protocolParameters,
+			networkId
+		}) : "pending"
+	}));
+	const swept = (confirmed?.grants ?? []).filter(({ grant }) => !inFlightSlots.has(grant.slot)).map((grantUtxo) => ({
+		...grantUtxo,
+		status: "sweeping"
+	}));
+	return [...kept, ...swept].sort(bySlot);
+};
+//#endregion
+Object.defineProperty(exports, "CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND", {
+	enumerable: true,
+	get: function() {
+		return CARDANO_CUSTODY_DEFAULT_GRANT_FEE_BOUND;
+	}
+});
+Object.defineProperty(exports, "classifyCardanoCustodyAccount", {
+	enumerable: true,
+	get: function() {
+		return classifyCardanoCustodyAccount;
+	}
+});
+Object.defineProperty(exports, "classifyCardanoCustodyGrants", {
+	enumerable: true,
+	get: function() {
+		return classifyCardanoCustodyGrants;
+	}
+});
+Object.defineProperty(exports, "classifyCustodyAccountUtxos", {
+	enumerable: true,
+	get: function() {
+		return classifyCustodyAccountUtxos;
+	}
+});
+Object.defineProperty(exports, "custodyGrantLiveness", {
+	enumerable: true,
+	get: function() {
+		return custodyGrantLiveness;
+	}
+});
+Object.defineProperty(exports, "isCardanoCustodyGrantExhausted", {
+	enumerable: true,
+	get: function() {
+		return isCardanoCustodyGrantExhausted;
+	}
+});
+Object.defineProperty(exports, "isCustodyReserveDatum", {
+	enumerable: true,
+	get: function() {
+		return isCustodyReserveDatum;
+	}
+});

package/dist/grants-Bnb-3Hkv.cjs

@@ -0,0 +1,16 @@
+require("./chunk-9hOWP6kD.cjs");
+require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_grant_rules = require("./grant-rules-B7eDuD5G.cjs");
+const require_grants = require("./grants-CIb6nOV7.cjs");
+exports.assertIssueRules = require_grant_rules.assertIssueRules;
+exports.circuitScope = require_grant_rules.circuitScope;
+exports.deriveGrantId = require_grants.deriveGrantId;
+exports.grantObjectCommit = require_grants.grantObjectCommit;
+exports.granteePoint = require_grant_rules.granteePoint;
+exports.issueGrantBinding = require_grants.issueGrantBinding;
+exports.originHash = require_grants.originHash;
+exports.prepareIssueGrant = require_grants.prepareIssueGrant;
+exports.prepareRevokeAllGrants = require_grants.prepareRevokeAllGrants;
+exports.prepareRevokeGrant = require_grants.prepareRevokeGrant;
+exports.scopeArgs = require_grants.scopeArgs;
+exports.scopeDigest = require_grants.scopeDigest;