@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/outputs-Bd2yZVjx.js

@@ -0,0 +1,720 @@
+import { d as fail, f as ok, i as isLowerCaseHex, n as hexToBytes, o as SUPPORTED_CUSTODY_CONTRACT_VERSIONS, r as isHash28Hex, t as bytesToHex, u as findCustodyLogic } from "./hex-mkXcV3pN.js";
+import { n as custodyGrantAssetId, t as CUSTODY_SLOT_LIMIT } from "./tokens-Diw4MLRM.js";
+import { Cardano, Serialization } from "@laceio/cardano/core";
+//#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 (!Cardano.util.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 (!Cardano.util.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 (!Cardano.util.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 (!Cardano.util.isPlutusBoundedBytes(data)) throw new MalformedData(path, `${what} as bytes`);
+	return bytesToHex(data);
+};
+const expectInt = (data, path, what) => {
+	if (!Cardano.util.isPlutusBigInt(data)) throw new MalformedData(path, `${what} as an integer`);
+	return data;
+};
+const expectList = (data, path, what) => {
+	if (!Cardano.util.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 Cardano.EnterpriseAddress.fromCredentials(networkId, payment).toAddress();
+	if (stake.kind === "inline") return Cardano.BaseAddress.fromCredentials(networkId, payment, toCardanoCredential(stake.credential)).toAddress();
+	return new Cardano.Address({
+		type: payment.type === Cardano.CredentialType.ScriptHash ? Cardano.AddressType.PointerScript : Cardano.AddressType.PointerKey,
+		networkId,
+		paymentPart: payment,
+		pointer: {
+			slot: stake.slot,
+			txIndex: Cardano.TxIndex(Number(stake.transactionIndex)),
+			certIndex: Cardano.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 = {
+	[Cardano.CredentialType.KeyHash]: 0,
+	[Cardano.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 ? Cardano.CredentialType.KeyHash : index === 1n ? Cardano.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);
+});
+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 ../../packages/lib/cardano-custody/src/analysis/value.ts
+/** Hex length of a policy id: every asset class on chain has a 28-byte one. */
+const POLICY_ID_HEX_LENGTH = 56;
+const valueDeltaOf = (value) => addValueDeltas([{
+	lovelace: value.coins,
+	assets: new Map([...value.assets ?? /* @__PURE__ */ new Map()].map(([assetId, quantity]) => [assetId.toLowerCase(), quantity]))
+}]);
+/** The sum of deltas, with zero token quantities dropped. */
+const addValueDeltas = (deltas) => {
+	let lovelace = 0n;
+	const assets = /* @__PURE__ */ new Map();
+	for (const delta of deltas) {
+		lovelace += delta.lovelace;
+		for (const [assetId, quantity] of delta.assets) {
+			const sum = (assets.get(assetId) ?? 0n) + quantity;
+			if (sum === 0n) assets.delete(assetId);
+			else assets.set(assetId, sum);
+		}
+	}
+	return {
+		lovelace,
+		assets
+	};
+};
+const negateValueDelta = (delta) => ({
+	lovelace: -delta.lovelace,
+	assets: new Map([...delta.assets].map(([assetId, quantity]) => [assetId, -quantity]))
+});
+/** The policy id of an asset id. */
+const policyIdOf = (assetId) => assetId.slice(0, POLICY_ID_HEX_LENGTH);
+/** The asset name of an asset id, as hex. */
+const assetNameOf = (assetId) => assetId.slice(POLICY_ID_HEX_LENGTH);
+/**
+* Whether an asset id names an asset class. Compared by parts, so an asset
+* whose policy id is not 28 bytes, which no value can hold, matches nothing.
+*/
+const isAssetIdOf = (assetId, asset) => asset.policyId.length === POLICY_ID_HEX_LENGTH && policyIdOf(assetId) === asset.policyId && assetNameOf(assetId) === asset.assetName;
+/** The quantity of one asset class: `assets.quantity_of` of the contract. */
+const quantityOfAsset = (delta, asset) => {
+	if (isCustodyLovelaceAsset(asset)) return delta.lovelace;
+	for (const [assetId, quantity] of delta.assets) if (isAssetIdOf(assetId, asset)) return quantity;
+	return 0n;
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/analysis/outputs.ts
+const OTHER = { kind: "other" };
+/** Hex length of a stake script hash: the state NFT name and the prefix of every grant token name. */
+const STAKE_SCRIPT_HASH_HEX_LENGTH = 56;
+const versionOfPayment = (credential) => credential.type === Cardano.CredentialType.ScriptHash ? SUPPORTED_CUSTODY_CONTRACT_VERSIONS.find((version) => version.accountValidatorHash === credential.hash) : void 0;
+/**
+* Whether a script hash is a logic in the catalogue of a supported contract
+* version: one whose rules Lace has reviewed.
+*/
+const isKnownCustodyLogic = (scriptHash) => SUPPORTED_CUSTODY_CONTRACT_VERSIONS.some((version) => findCustodyLogic(version, scriptHash).ok);
+/**
+* Classifies an address on any network against every supported custody
+* contract version. It reads the address only: `account` does not prove
+* that the stake script is a custody stake script or that the account
+* exists.
+*/
+const classifyCustodyAddress = (address) => {
+	const base = address.asBase();
+	const payment = (base ?? address.asEnterprise() ?? address.asPointer())?.getPaymentCredential();
+	const contractVersion = payment && versionOfPayment(payment);
+	if (!contractVersion) return OTHER;
+	const stake = base?.getStakeCredential();
+	return stake?.type === Cardano.CredentialType.ScriptHash ? {
+		kind: "account",
+		contractVersion,
+		stakeScriptHash: stake.hash
+	} : {
+		kind: "unspendable",
+		contractVersion
+	};
+};
+/** A key equal for two addresses exactly when their Plutus data is equal. */
+const plutusAddressKeyOf = (address) => {
+	const recipient = custodyRecipientFromAddress(address);
+	return recipient.ok ? recipientKey(recipient.value) : void 0;
+};
+const accountPlutusAddressKey = ({ accountValidatorHash, stakeScriptHash }) => recipientKey({
+	paymentCredential: {
+		type: Cardano.CredentialType.ScriptHash,
+		hash: accountValidatorHash
+	},
+	stakeCredential: {
+		kind: "inline",
+		credential: {
+			type: Cardano.CredentialType.ScriptHash,
+			hash: stakeScriptHash
+		}
+	}
+});
+const stakeCredentialOf = ({ stakeScriptHash }) => ({
+	type: Cardano.CredentialType.ScriptHash,
+	hash: stakeScriptHash
+});
+const accountAddressOf = (account, networkId) => Cardano.BaseAddress.fromCredentials(networkId, {
+	type: Cardano.CredentialType.ScriptHash,
+	hash: account.accountValidatorHash
+}, stakeCredentialOf(account)).toAddress().toBech32();
+const accountRewardAccountOf = (account, networkId) => Cardano.RewardAccount.fromCredential(stakeCredentialOf(account), networkId);
+const stateNftAssetIdOf = ({ accountValidatorHash, stakeScriptHash }) => `${accountValidatorHash}${stakeScriptHash}`;
+/**
+* The asset id of the account's grant token for `slot`, or undefined for a
+* slot no grant token name can carry, which the validator cannot name either.
+*/
+const grantAssetIdOf = (account, slot) => slot >= 0n && slot < CUSTODY_SLOT_LIMIT ? custodyGrantAssetId(account, slot) : void 0;
+/**
+* The output's datum as the script context sees it. A resolution that
+* carries both an inline datum and its hash, as some providers report an
+* inline datum, keeps the inline datum.
+*/
+const datumOf = (txOut) => {
+	if (txOut.datum !== void 0) return {
+		datumKind: "inline",
+		inlineDatum: txOut.datum
+	};
+	return {
+		datumKind: txOut.datumHash === void 0 ? "none" : "hash",
+		inlineDatum: void 0
+	};
+};
+const viewOfOutput = (txOut) => {
+	const address = Cardano.Address.fromString(txOut.address) ?? void 0;
+	return {
+		txOut,
+		address,
+		addressClass: address ? classifyCustodyAddress(address) : OTHER,
+		plutusAddressKey: address && plutusAddressKeyOf(address),
+		value: valueDeltaOf(txOut.value),
+		...datumOf(txOut),
+		hasReferenceScript: txOut.scriptReference !== void 0,
+		referenceScriptHash: txOut.scriptReference && Serialization.Script.fromCore(txOut.scriptReference).hash()
+	};
+};
+/** The account state an output carries as its inline datum, if it decodes. */
+const decodedInlineState = (view) => {
+	if (view.inlineDatum === void 0) return void 0;
+	const decoded = decodeCustodyAccountState(view.inlineDatum);
+	return decoded.ok ? decoded.value : void 0;
+};
+/** The grant an output carries as its inline datum, if it decodes. */
+const decodedInlineGrant = (view) => {
+	if (view.inlineDatum === void 0) return void 0;
+	const decoded = decodeCustodyGrant(view.inlineDatum);
+	return decoded.ok ? decoded.value : void 0;
+};
+/** Whether the output sits at the account address, compared as Plutus data. */
+const isAtAccount = (view, account) => view.plutusAddressKey !== void 0 && view.plutusAddressKey === accountPlutusAddressKey(account);
+/** `holds_state_nft`: exactly one of the account's state NFT. */
+const holdsStateNft = (value, account) => value.assets.get(stateNftAssetIdOf(account)) === 1n;
+/** `holds_only_lovelace_and_state_nft`: the state NFT and no other token. */
+const holdsOnlyLovelaceAndStateNft = (value, account) => value.assets.size === 1 && holdsStateNft(value, account);
+/** `holds_only_lovelace_and_grant_token`: one grant token of `slot` and no other token. */
+const holdsOnlyLovelaceAndGrantToken = (value, account, slot) => {
+	const assetId = grantAssetIdOf(account, slot);
+	return assetId !== void 0 && value.assets.size === 1 && value.assets.get(assetId) === 1n;
+};
+/** `holds_no_account_token`: no token under the account validator policy, of any account. */
+const holdsNoAccountToken = (value, accountValidatorHash) => ![...value.assets.keys()].some((assetId) => policyIdOf(assetId) === accountValidatorHash);
+/** Whether a value holds a token of the account: its state NFT or one of its grant tokens. */
+const holdsOwnAccountToken = (value, { accountValidatorHash, stakeScriptHash }) => [...value.assets.keys()].some((assetId) => policyIdOf(assetId) === accountValidatorHash && assetNameOf(assetId).startsWith(stakeScriptHash));
+/** `holds_account_token`: at the account address, holding one of its account tokens. */
+const holdsAccountToken = (view, account) => isAtAccount(view, account) && holdsOwnAccountToken(view.value, account);
+/** `is_control_output`: at the account address, holding its state NFT. */
+const isControlOutput = (view, account) => isAtAccount(view, account) && holdsStateNft(view.value, account);
+/**
+* Which kind of account UTxO an output at the account address is: the
+* control UTxO holds the state NFT, a grant UTxO another token of the
+* account, a reserve no account token and a datum, a fund neither.
+*/
+const accountUtxoKindOf = (view, account) => {
+	if (holdsStateNft(view.value, account)) return "control";
+	if (holdsOwnAccountToken(view.value, account)) return "grant";
+	return view.datumKind === "none" ? "fund" : "reserve";
+};
+/**
+* Whether an output breaks `tokens_sit_at_their_own_addresses` for one of
+* the account validators: every token under an account validator policy
+* must be a single one at the account address its name's first 28 bytes
+* name.
+*/
+const holdsMisplacedAccountToken = (view, accountValidatorHashes) => [...view.value.assets].some(([assetId, quantity]) => {
+	const accountValidatorHash = policyIdOf(assetId);
+	if (!accountValidatorHashes.includes(accountValidatorHash)) return false;
+	return quantity !== 1n || !isAtAccount(view, {
+		accountValidatorHash,
+		stakeScriptHash: assetNameOf(assetId).slice(0, STAKE_SCRIPT_HASH_HEX_LENGTH)
+	});
+});
+//#endregion
+export { isCustodyLovelaceAsset as A, recipientKey as B, policyIdOf as C, findCustodyStateViolations as D, findCustodyGrantViolations as E, encodeCustodyAccountState as F, unknownAlternative as G, decodeResult as H, encodeCustodyGrant as I, addressOfRepresentableRecipient as L, decodeCustodyGrant as M, decodeCustodyStateDevices as N, isCustodyGrantCurrent as O, decodeCustodyStateLogic as P, custodyRecipientFromAddress as R, negateValueDelta as S, CUSTODY_LOVELACE_ASSET as T, expectConstr as U, constr as V, expectConstrIndex as W, stateNftAssetIdOf as _, classifyCustodyAddress as a, assetNameOf as b, grantAssetIdOf as c, holdsNoAccountToken as d, holdsOnlyLovelaceAndGrantToken as f, isKnownCustodyLogic as g, isControlOutput as h, accountUtxoKindOf as i, decodeCustodyAccountState as j, isCustodyGrantExpired as k, holdsAccountToken as l, isAtAccount as m, accountPlutusAddressKey as n, decodedInlineGrant as o, holdsOnlyLovelaceAndStateNft as p, accountRewardAccountOf as r, decodedInlineState as s, accountAddressOf as t, holdsMisplacedAccountToken as u, viewOfOutput as v, quantityOfAsset as w, isAssetIdOf as x, addValueDeltas as y, custodyRecipientToAddress as z };