@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/outputs-CJoQBIA2.cjs

@@ -0,0 +1,990 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_hex = require("./hex-D9ITYbwt.cjs");
+const require_tokens = require("./tokens-Cevp7rdU.cjs");
+let _laceio_cardano_core = require("@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 require_hex.ok(decode());
+	} catch (error) {
+		if (error instanceof MalformedData) return require_hex.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) => require_hex.hexToBytes(hex);
+/** The constructor index of a value that must be a constructor. */
+const expectConstrIndex = (data, path, what) => {
+	if (!_laceio_cardano_core.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 (!_laceio_cardano_core.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 (!_laceio_cardano_core.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 (!_laceio_cardano_core.Cardano.util.isPlutusBoundedBytes(data)) throw new MalformedData(path, `${what} as bytes`);
+	return require_hex.bytesToHex(data);
+};
+const expectInt = (data, path, what) => {
+	if (!_laceio_cardano_core.Cardano.util.isPlutusBigInt(data)) throw new MalformedData(path, `${what} as an integer`);
+	return data;
+};
+const expectList = (data, path, what) => {
+	if (!_laceio_cardano_core.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 require_hex.ok({
+		paymentCredential: credentialFrom(base.getPaymentCredential()),
+		stakeCredential: {
+			kind: "inline",
+			credential: credentialFrom(base.getStakeCredential())
+		}
+	});
+	const enterprise = address.asEnterprise();
+	if (enterprise) return require_hex.ok({ paymentCredential: credentialFrom(enterprise.getPaymentCredential()) });
+	const pointer = address.asPointer();
+	if (pointer) {
+		const { slot, txIndex, certIndex } = pointer.getStakePointer();
+		return require_hex.ok({
+			paymentCredential: credentialFrom(pointer.getPaymentCredential()),
+			stakeCredential: {
+				kind: "pointer",
+				slot,
+				transactionIndex: BigInt(txIndex),
+				certificateIndex: BigInt(certIndex)
+			}
+		});
+	}
+	return require_hex.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 (!require_hex.isHash28Hex(recipient.paymentCredential.hash)) return false;
+	const stake = recipient.stakeCredential;
+	if (!stake) return true;
+	if (stake.kind === "inline") return require_hex.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 _laceio_cardano_core.Cardano.EnterpriseAddress.fromCredentials(networkId, payment).toAddress();
+	if (stake.kind === "inline") return _laceio_cardano_core.Cardano.BaseAddress.fromCredentials(networkId, payment, toCardanoCredential(stake.credential)).toAddress();
+	return new _laceio_cardano_core.Cardano.Address({
+		type: payment.type === _laceio_cardano_core.Cardano.CredentialType.ScriptHash ? _laceio_cardano_core.Cardano.AddressType.PointerScript : _laceio_cardano_core.Cardano.AddressType.PointerKey,
+		networkId,
+		paymentPart: payment,
+		pointer: {
+			slot: stake.slot,
+			txIndex: _laceio_cardano_core.Cardano.TxIndex(Number(stake.transactionIndex)),
+			certIndex: _laceio_cardano_core.Cardano.CertIndex(Number(stake.certificateIndex))
+		}
+	});
+};
+/** The address a recipient stands for on the given network. */
+const custodyRecipientToAddress = (recipient, networkId) => isRepresentableRecipient(recipient) ? require_hex.ok(addressOfRepresentableRecipient(recipient, networkId)) : require_hex.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 = {
+	[_laceio_cardano_core.Cardano.CredentialType.KeyHash]: 0,
+	[_laceio_cardano_core.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 ? _laceio_cardano_core.Cardano.CredentialType.KeyHash : index === 1n ? _laceio_cardano_core.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 === "" || require_hex.isLowerCaseHex(policyId, POLICY_ID_BYTES);
+const isAssetNameWellFormed = ({ policyId, assetName }) => require_hex.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 >= require_tokens.CUSTODY_SLOT_LIMIT) violations.push({
+		code: "slot-out-of-range",
+		slot
+	});
+	if (!require_hex.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 (!require_hex.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 (!require_hex.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 === _laceio_cardano_core.Cardano.CredentialType.ScriptHash ? require_hex.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) => require_hex.SUPPORTED_CUSTODY_CONTRACT_VERSIONS.some((version) => require_hex.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 === _laceio_cardano_core.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: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+		hash: accountValidatorHash
+	},
+	stakeCredential: {
+		kind: "inline",
+		credential: {
+			type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+			hash: stakeScriptHash
+		}
+	}
+});
+const stakeCredentialOf = ({ stakeScriptHash }) => ({
+	type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+	hash: stakeScriptHash
+});
+const accountAddressOf = (account, networkId) => _laceio_cardano_core.Cardano.BaseAddress.fromCredentials(networkId, {
+	type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+	hash: account.accountValidatorHash
+}, stakeCredentialOf(account)).toAddress().toBech32();
+const accountRewardAccountOf = (account, networkId) => _laceio_cardano_core.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 < require_tokens.CUSTODY_SLOT_LIMIT ? require_tokens.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 = _laceio_cardano_core.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 && _laceio_cardano_core.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
+Object.defineProperty(exports, "CUSTODY_LOVELACE_ASSET", {
+	enumerable: true,
+	get: function() {
+		return CUSTODY_LOVELACE_ASSET;
+	}
+});
+Object.defineProperty(exports, "accountAddressOf", {
+	enumerable: true,
+	get: function() {
+		return accountAddressOf;
+	}
+});
+Object.defineProperty(exports, "accountPlutusAddressKey", {
+	enumerable: true,
+	get: function() {
+		return accountPlutusAddressKey;
+	}
+});
+Object.defineProperty(exports, "accountRewardAccountOf", {
+	enumerable: true,
+	get: function() {
+		return accountRewardAccountOf;
+	}
+});
+Object.defineProperty(exports, "accountUtxoKindOf", {
+	enumerable: true,
+	get: function() {
+		return accountUtxoKindOf;
+	}
+});
+Object.defineProperty(exports, "addValueDeltas", {
+	enumerable: true,
+	get: function() {
+		return addValueDeltas;
+	}
+});
+Object.defineProperty(exports, "addressOfRepresentableRecipient", {
+	enumerable: true,
+	get: function() {
+		return addressOfRepresentableRecipient;
+	}
+});
+Object.defineProperty(exports, "assetNameOf", {
+	enumerable: true,
+	get: function() {
+		return assetNameOf;
+	}
+});
+Object.defineProperty(exports, "classifyCustodyAddress", {
+	enumerable: true,
+	get: function() {
+		return classifyCustodyAddress;
+	}
+});
+Object.defineProperty(exports, "constr", {
+	enumerable: true,
+	get: function() {
+		return constr;
+	}
+});
+Object.defineProperty(exports, "custodyRecipientFromAddress", {
+	enumerable: true,
+	get: function() {
+		return custodyRecipientFromAddress;
+	}
+});
+Object.defineProperty(exports, "custodyRecipientToAddress", {
+	enumerable: true,
+	get: function() {
+		return custodyRecipientToAddress;
+	}
+});
+Object.defineProperty(exports, "decodeCustodyAccountState", {
+	enumerable: true,
+	get: function() {
+		return decodeCustodyAccountState;
+	}
+});
+Object.defineProperty(exports, "decodeCustodyGrant", {
+	enumerable: true,
+	get: function() {
+		return decodeCustodyGrant;
+	}
+});
+Object.defineProperty(exports, "decodeCustodyStateDevices", {
+	enumerable: true,
+	get: function() {
+		return decodeCustodyStateDevices;
+	}
+});
+Object.defineProperty(exports, "decodeCustodyStateLogic", {
+	enumerable: true,
+	get: function() {
+		return decodeCustodyStateLogic;
+	}
+});
+Object.defineProperty(exports, "decodeResult", {
+	enumerable: true,
+	get: function() {
+		return decodeResult;
+	}
+});
+Object.defineProperty(exports, "decodedInlineGrant", {
+	enumerable: true,
+	get: function() {
+		return decodedInlineGrant;
+	}
+});
+Object.defineProperty(exports, "decodedInlineState", {
+	enumerable: true,
+	get: function() {
+		return decodedInlineState;
+	}
+});
+Object.defineProperty(exports, "encodeCustodyAccountState", {
+	enumerable: true,
+	get: function() {
+		return encodeCustodyAccountState;
+	}
+});
+Object.defineProperty(exports, "encodeCustodyGrant", {
+	enumerable: true,
+	get: function() {
+		return encodeCustodyGrant;
+	}
+});
+Object.defineProperty(exports, "expectConstr", {
+	enumerable: true,
+	get: function() {
+		return expectConstr;
+	}
+});
+Object.defineProperty(exports, "expectConstrIndex", {
+	enumerable: true,
+	get: function() {
+		return expectConstrIndex;
+	}
+});
+Object.defineProperty(exports, "findCustodyGrantViolations", {
+	enumerable: true,
+	get: function() {
+		return findCustodyGrantViolations;
+	}
+});
+Object.defineProperty(exports, "findCustodyStateViolations", {
+	enumerable: true,
+	get: function() {
+		return findCustodyStateViolations;
+	}
+});
+Object.defineProperty(exports, "grantAssetIdOf", {
+	enumerable: true,
+	get: function() {
+		return grantAssetIdOf;
+	}
+});
+Object.defineProperty(exports, "holdsAccountToken", {
+	enumerable: true,
+	get: function() {
+		return holdsAccountToken;
+	}
+});
+Object.defineProperty(exports, "holdsMisplacedAccountToken", {
+	enumerable: true,
+	get: function() {
+		return holdsMisplacedAccountToken;
+	}
+});
+Object.defineProperty(exports, "holdsNoAccountToken", {
+	enumerable: true,
+	get: function() {
+		return holdsNoAccountToken;
+	}
+});
+Object.defineProperty(exports, "holdsOnlyLovelaceAndGrantToken", {
+	enumerable: true,
+	get: function() {
+		return holdsOnlyLovelaceAndGrantToken;
+	}
+});
+Object.defineProperty(exports, "holdsOnlyLovelaceAndStateNft", {
+	enumerable: true,
+	get: function() {
+		return holdsOnlyLovelaceAndStateNft;
+	}
+});
+Object.defineProperty(exports, "isAssetIdOf", {
+	enumerable: true,
+	get: function() {
+		return isAssetIdOf;
+	}
+});
+Object.defineProperty(exports, "isAtAccount", {
+	enumerable: true,
+	get: function() {
+		return isAtAccount;
+	}
+});
+Object.defineProperty(exports, "isControlOutput", {
+	enumerable: true,
+	get: function() {
+		return isControlOutput;
+	}
+});
+Object.defineProperty(exports, "isCustodyGrantCurrent", {
+	enumerable: true,
+	get: function() {
+		return isCustodyGrantCurrent;
+	}
+});
+Object.defineProperty(exports, "isCustodyGrantExpired", {
+	enumerable: true,
+	get: function() {
+		return isCustodyGrantExpired;
+	}
+});
+Object.defineProperty(exports, "isCustodyLovelaceAsset", {
+	enumerable: true,
+	get: function() {
+		return isCustodyLovelaceAsset;
+	}
+});
+Object.defineProperty(exports, "isKnownCustodyLogic", {
+	enumerable: true,
+	get: function() {
+		return isKnownCustodyLogic;
+	}
+});
+Object.defineProperty(exports, "negateValueDelta", {
+	enumerable: true,
+	get: function() {
+		return negateValueDelta;
+	}
+});
+Object.defineProperty(exports, "policyIdOf", {
+	enumerable: true,
+	get: function() {
+		return policyIdOf;
+	}
+});
+Object.defineProperty(exports, "quantityOfAsset", {
+	enumerable: true,
+	get: function() {
+		return quantityOfAsset;
+	}
+});
+Object.defineProperty(exports, "recipientKey", {
+	enumerable: true,
+	get: function() {
+		return recipientKey;
+	}
+});
+Object.defineProperty(exports, "stateNftAssetIdOf", {
+	enumerable: true,
+	get: function() {
+		return stateNftAssetIdOf;
+	}
+});
+Object.defineProperty(exports, "unknownAlternative", {
+	enumerable: true,
+	get: function() {
+		return unknownAlternative;
+	}
+});
+Object.defineProperty(exports, "viewOfOutput", {
+	enumerable: true,
+	get: function() {
+		return viewOfOutput;
+	}
+});