@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/account-call-B7cF8ly4.cjs

@@ -0,0 +1,293 @@
+const require_bytes_vo = require("./bytes.vo-hecRu3YZ.cjs");
+const require_providers = require("./providers-1on_fwJO.cjs");
+const require_gated_call = require("./gated-call-DdDrxEq5.cjs");
+const require_errors = require("./errors-BA3b8aVu.cjs");
+const require_acc_module = require("./acc-module-NL_8mEHH.cjs");
+//#region ../../packages/module/passport-account/src/infra/indexer.ts
+const TX_FIELDS = `transaction {
+  hash
+  block { height }
+  ... on RegularTransaction { identifiers zswapStartIndex zswapEndIndex }
+}`;
+const ACTION_FIELDS = `
+  __typename
+  ... on ContractDeploy { ${TX_FIELDS} }
+  ... on ContractCall   { entryPoint ${TX_FIELDS} }
+  ... on ContractUpdate { ${TX_FIELDS} }
+`;
+const isShieldedOutputEvent = (content) => content.tag === "zswapOutput";
+const toRecord = (action) => {
+	const transaction = action.transaction ?? {};
+	return {
+		kind: action.__typename,
+		entryPoint: action.entryPoint ?? void 0,
+		txHash: String(transaction.hash ?? ""),
+		identifiers: (transaction.identifiers ?? []).map(String),
+		blockHeight: Number(transaction.block?.height ?? 0),
+		startIndex: transaction.zswapStartIndex == null ? void 0 : Number(transaction.zswapStartIndex),
+		endIndex: transaction.zswapEndIndex == null ? void 0 : Number(transaction.zswapEndIndex)
+	};
+};
+const stripHexPrefix = (address) => address.replace(/^0x/, "");
+const HEX_BYTES_PATTERN = /^(?:[0-9a-fA-F]{2})*$/;
+/**
+* The bytes of a ledger event the indexer returned as hex. A payload that
+* is not whole hex bytes is refused outright: decoding it leniently would
+* hand the ledger a truncated event and lose the output it described.
+*/
+const eventBytes = (raw) => {
+	if (!HEX_BYTES_PATTERN.test(raw)) throw new Error(`transactions query: ledger event is not hex: "${raw}"`);
+	return require_bytes_vo.ByteArray.fromHex(require_bytes_vo.HexBytes(raw));
+};
+/**
+* Reads Passport contract data from a Midnight indexer: the current
+* contract state through the midnight-js public data provider, the
+* complete per-address action history through the indexer's
+* contractActions subscription, and the shielded outputs a transaction
+* created through the ledger events the indexer keeps per transaction.
+*/
+const createIndexerClient = ({ indexerUrl, indexerWsUrl, fetchHttp = globalThis.fetch, createSocket = (url, protocol) => new WebSocket(url, protocol), createPublicDataProvider }) => {
+	const defaultProvider = async () => {
+		const { indexerPublicDataProvider } = await import("@midnight-ntwrk/midnight-js-indexer-public-data-provider");
+		return indexerPublicDataProvider({
+			queryURL: indexerUrl,
+			subscriptionURL: indexerWsUrl
+		});
+	};
+	let providerPromise;
+	const provider = async () => providerPromise ??= (createPublicDataProvider ?? defaultProvider)();
+	const postQuery = async (name, query, variables) => {
+		const response = await fetchHttp(indexerUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				query,
+				variables
+			})
+		});
+		if (!response.ok) throw new Error(`${name} query failed: HTTP ${response.status} ${response.statusText}`);
+		const body = await response.json();
+		if (body.errors?.length) throw new Error(`${name} query: ${JSON.stringify(body.errors)}`);
+		return body;
+	};
+	const latestContractAction = async (address) => {
+		const action = (await postQuery("contractAction", `query($address: HexEncoded!) { contractAction(address: $address) { ${ACTION_FIELDS} } }`, { address: stripHexPrefix(address) })).data?.contractAction;
+		return action ? toRecord(action) : null;
+	};
+	const enumerateContractActions = async (address, { timeoutMs = 6e4, drainMs = 500 } = {}) => {
+		const frontier = await latestContractAction(address);
+		if (!frontier) return [];
+		return new Promise((resolve, reject) => {
+			const actions = [];
+			const socket = createSocket(indexerWsUrl, "graphql-transport-ws");
+			let drain;
+			const deadline = setTimeout(() => {
+				fail(/* @__PURE__ */ new Error(`contractActions replay timed out after ${timeoutMs}ms (${actions.length} received)`));
+			}, timeoutMs);
+			const finish = (error) => {
+				clearTimeout(deadline);
+				if (drain) clearTimeout(drain);
+				try {
+					socket.close();
+				} catch {}
+				if (error) reject(error);
+				else resolve(actions);
+			};
+			const fail = (error) => {
+				finish(error);
+			};
+			socket.addEventListener("error", (event) => {
+				fail(/* @__PURE__ */ new Error(`indexer websocket: ${event.message ?? "error"}`));
+			});
+			socket.addEventListener("open", () => {
+				socket.send(JSON.stringify({ type: "connection_init" }));
+			});
+			socket.addEventListener("message", (event) => {
+				const message = JSON.parse(String(event.data));
+				switch (message.type ?? "") {
+					case "connection_ack":
+						socket.send(JSON.stringify({
+							id: "1",
+							type: "subscribe",
+							payload: {
+								query: `subscription($address: HexEncoded!) {
+                    contractActions(address: $address, offset: { height: 0 }) { ${ACTION_FIELDS} }
+                  }`,
+								variables: { address: stripHexPrefix(address) }
+							}
+						}));
+						break;
+					case "next": {
+						if (message.payload?.errors?.length) {
+							fail(/* @__PURE__ */ new Error(`contractActions subscription: ${JSON.stringify(message.payload.errors)}`));
+							break;
+						}
+						const action = message.payload?.data?.contractActions;
+						if (!action) break;
+						actions.push(toRecord(action));
+						if (actions.at(-1)?.txHash === frontier.txHash && !drain) drain = setTimeout(() => {
+							finish();
+						}, drainMs);
+						break;
+					}
+					case "error":
+						fail(/* @__PURE__ */ new Error(`contractActions subscription: ${JSON.stringify(message.payload)}`));
+						break;
+					case "complete":
+						finish();
+						break;
+					default: break;
+				}
+			});
+		});
+	};
+	/**
+	* The indexer keeps, per transaction, the events the ledger emitted while
+	* applying it; a shielded output's event carries the commitment and the
+	* tree index the ledger assigned, so the index is read, never inferred
+	* from the transaction's position window.
+	*/
+	const queryShieldedOutputs = async (txHash) => {
+		const events = ((await postQuery("transactions", `query($offset: TransactionOffset!) { transactions(offset: $offset) { hash ... on RegularTransaction { zswapLedgerEvents { raw } } } }`, { offset: { hash: stripHexPrefix(txHash) } })).data?.transactions ?? []).flatMap((transaction) => transaction.zswapLedgerEvents ?? []);
+		if (events.length === 0) return [];
+		const { Event } = await import("@midnightntwrk/ledger-v9");
+		return events.flatMap(({ raw }) => {
+			const { content } = Event.deserialize(eventBytes(stripHexPrefix(raw ?? "")));
+			return isShieldedOutputEvent(content) ? [{
+				commitment: content.commitment.toLowerCase(),
+				...content.contract === void 0 ? {} : { contractAddress: content.contract.toLowerCase() },
+				index: content.mtIndex
+			}] : [];
+		});
+	};
+	return {
+		queryContractState: async (address) => (await provider()).queryContractState(address),
+		enumerateContractActions,
+		queryShieldedOutputs
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/flows/account-call.ts
+/** Contract aborts meaning the authorising key was rejected. */
+const NOT_AUTHORISED_ABORTS = ["failed assert: invalid signature", "failed assert: device key"];
+/**
+* Raised by the caller checks in require_authorised and by the target
+* check in _do_remove_device: the same string for two different failures.
+*/
+const UNKNOWN_ENTRY_ABORT = "failed assert: unknown device entry";
+/** Whether a contract abort message says the authorising key was rejected. */
+const isNotAuthorisedAbort = (message) => NOT_AUTHORISED_ABORTS.some((abort) => message.includes(abort));
+/**
+* The decoded ledger state of the account at `address`, which must hold
+* a live contract.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountLedger = async (indexer, address) => {
+	const state = await indexer.queryContractState(address);
+	if (!state) throw new require_errors.AccountContractMissingError(`No live Account Custody Contract found at ${address}.`);
+	return require_acc_module.ledger(state.data);
+};
+/**
+* Reads the account's ledger state through a fresh indexer client, which
+* is returned with it so a flow can read the state again after a call.
+*/
+const readAccountLedger = async (address, { indexerUrl, indexerWsUrl }) => {
+	const indexer = createIndexerClient({
+		indexerUrl,
+		indexerWsUrl
+	});
+	return {
+		indexer,
+		ledgerState: await queryAccountLedger(indexer, address)
+	};
+};
+/**
+* Submits one gated call and reports the position it left the local
+* device in. The handle is connected without the account encryption
+* secret: the device and grant lifecycle circuits read no private state,
+* so deriving it here would only widen the window the secret spends in
+* memory. The successor commitment is computed against the epoch read
+* before the call, which is the epoch the accepted call ran under: a
+* gated call never changes device_epoch (it is only written at
+* construction), so the pre-call epoch names the very entry the contract
+* inserted.
+*/
+const submitAccountCall = async ({ circuit, args, account, localUseCounter, ledgerState, onStage }, { passportAuthoriser, passportNetwork, passportProver, passportSponsor }) => {
+	const handle = await require_gated_call.connectAccountHandle(await require_providers.createMidnightProviders({
+		network: passportNetwork,
+		prover: passportProver,
+		sponsor: passportSponsor,
+		...onStage ? { onStage } : {}
+	}), account.address);
+	const address = require_providers.AccAddress(account.address);
+	const advancedCounter = await require_gated_call.executeGatedCall({
+		handle,
+		authoriser: passportAuthoriser,
+		circuit,
+		args,
+		address,
+		ledgerState,
+		knownUseCounter: localUseCounter === void 0 ? void 0 : require_gated_call.UseCounter(BigInt(localUseCounter))
+	});
+	return {
+		advancedCounter,
+		localCommitmentHex: await passportAuthoriser.deviceCommitment(address, require_gated_call.DeviceEpoch(ledgerState.device_epoch), advancedCounter)
+	};
+};
+/**
+* The devices list with the local device's row moved to the commitment it
+* holds after an accepted call. An entry is single use: the call consumed
+* the one the row carried and the contract inserted its successor, so
+* leaving the row as it was would name an entry the on-chain set no
+* longer holds. Only existing rows are rewritten, so a removal that
+* dropped the local row does not resurrect it.
+*/
+const withRefreshedLocalDevice = (devices, commitmentHex) => devices.map((device) => device.isLocal ? {
+	...device,
+	commitmentHex
+} : device);
+//#endregion
+Object.defineProperty(exports, "UNKNOWN_ENTRY_ABORT", {
+	enumerable: true,
+	get: function() {
+		return UNKNOWN_ENTRY_ABORT;
+	}
+});
+Object.defineProperty(exports, "createIndexerClient", {
+	enumerable: true,
+	get: function() {
+		return createIndexerClient;
+	}
+});
+Object.defineProperty(exports, "isNotAuthorisedAbort", {
+	enumerable: true,
+	get: function() {
+		return isNotAuthorisedAbort;
+	}
+});
+Object.defineProperty(exports, "queryAccountLedger", {
+	enumerable: true,
+	get: function() {
+		return queryAccountLedger;
+	}
+});
+Object.defineProperty(exports, "readAccountLedger", {
+	enumerable: true,
+	get: function() {
+		return readAccountLedger;
+	}
+});
+Object.defineProperty(exports, "submitAccountCall", {
+	enumerable: true,
+	get: function() {
+		return submitAccountCall;
+	}
+});
+Object.defineProperty(exports, "withRefreshedLocalDevice", {
+	enumerable: true,
+	get: function() {
+		return withRefreshedLocalDevice;
+	}
+});

package/dist/account-call-BF4rBcNw.js

@@ -0,0 +1,3 @@
+import "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { i as readAccountLedger } from "./account-call-CoCq3V55.js";
+export { readAccountLedger };

package/dist/account-call-CoCq3V55.js

@@ -0,0 +1,252 @@
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { i as AccAddress, t as createMidnightProviders } from "./providers-C1MsxfMA.js";
+import { n as executeGatedCall, o as DeviceEpoch, s as UseCounter, t as connectAccountHandle } from "./gated-call-CcsuW9L5.js";
+import { t as AccountContractMissingError } from "./errors-pkQdxW-7.js";
+import { i as ledger } from "./acc-module-ur8CkBd1.js";
+//#region ../../packages/module/passport-account/src/infra/indexer.ts
+const TX_FIELDS = `transaction {
+  hash
+  block { height }
+  ... on RegularTransaction { identifiers zswapStartIndex zswapEndIndex }
+}`;
+const ACTION_FIELDS = `
+  __typename
+  ... on ContractDeploy { ${TX_FIELDS} }
+  ... on ContractCall   { entryPoint ${TX_FIELDS} }
+  ... on ContractUpdate { ${TX_FIELDS} }
+`;
+const isShieldedOutputEvent = (content) => content.tag === "zswapOutput";
+const toRecord = (action) => {
+	const transaction = action.transaction ?? {};
+	return {
+		kind: action.__typename,
+		entryPoint: action.entryPoint ?? void 0,
+		txHash: String(transaction.hash ?? ""),
+		identifiers: (transaction.identifiers ?? []).map(String),
+		blockHeight: Number(transaction.block?.height ?? 0),
+		startIndex: transaction.zswapStartIndex == null ? void 0 : Number(transaction.zswapStartIndex),
+		endIndex: transaction.zswapEndIndex == null ? void 0 : Number(transaction.zswapEndIndex)
+	};
+};
+const stripHexPrefix = (address) => address.replace(/^0x/, "");
+const HEX_BYTES_PATTERN = /^(?:[0-9a-fA-F]{2})*$/;
+/**
+* The bytes of a ledger event the indexer returned as hex. A payload that
+* is not whole hex bytes is refused outright: decoding it leniently would
+* hand the ledger a truncated event and lose the output it described.
+*/
+const eventBytes = (raw) => {
+	if (!HEX_BYTES_PATTERN.test(raw)) throw new Error(`transactions query: ledger event is not hex: "${raw}"`);
+	return ByteArray.fromHex(HexBytes(raw));
+};
+/**
+* Reads Passport contract data from a Midnight indexer: the current
+* contract state through the midnight-js public data provider, the
+* complete per-address action history through the indexer's
+* contractActions subscription, and the shielded outputs a transaction
+* created through the ledger events the indexer keeps per transaction.
+*/
+const createIndexerClient = ({ indexerUrl, indexerWsUrl, fetchHttp = globalThis.fetch, createSocket = (url, protocol) => new WebSocket(url, protocol), createPublicDataProvider }) => {
+	const defaultProvider = async () => {
+		const { indexerPublicDataProvider } = await import("@midnight-ntwrk/midnight-js-indexer-public-data-provider");
+		return indexerPublicDataProvider({
+			queryURL: indexerUrl,
+			subscriptionURL: indexerWsUrl
+		});
+	};
+	let providerPromise;
+	const provider = async () => providerPromise ??= (createPublicDataProvider ?? defaultProvider)();
+	const postQuery = async (name, query, variables) => {
+		const response = await fetchHttp(indexerUrl, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				query,
+				variables
+			})
+		});
+		if (!response.ok) throw new Error(`${name} query failed: HTTP ${response.status} ${response.statusText}`);
+		const body = await response.json();
+		if (body.errors?.length) throw new Error(`${name} query: ${JSON.stringify(body.errors)}`);
+		return body;
+	};
+	const latestContractAction = async (address) => {
+		const action = (await postQuery("contractAction", `query($address: HexEncoded!) { contractAction(address: $address) { ${ACTION_FIELDS} } }`, { address: stripHexPrefix(address) })).data?.contractAction;
+		return action ? toRecord(action) : null;
+	};
+	const enumerateContractActions = async (address, { timeoutMs = 6e4, drainMs = 500 } = {}) => {
+		const frontier = await latestContractAction(address);
+		if (!frontier) return [];
+		return new Promise((resolve, reject) => {
+			const actions = [];
+			const socket = createSocket(indexerWsUrl, "graphql-transport-ws");
+			let drain;
+			const deadline = setTimeout(() => {
+				fail(/* @__PURE__ */ new Error(`contractActions replay timed out after ${timeoutMs}ms (${actions.length} received)`));
+			}, timeoutMs);
+			const finish = (error) => {
+				clearTimeout(deadline);
+				if (drain) clearTimeout(drain);
+				try {
+					socket.close();
+				} catch {}
+				if (error) reject(error);
+				else resolve(actions);
+			};
+			const fail = (error) => {
+				finish(error);
+			};
+			socket.addEventListener("error", (event) => {
+				fail(/* @__PURE__ */ new Error(`indexer websocket: ${event.message ?? "error"}`));
+			});
+			socket.addEventListener("open", () => {
+				socket.send(JSON.stringify({ type: "connection_init" }));
+			});
+			socket.addEventListener("message", (event) => {
+				const message = JSON.parse(String(event.data));
+				switch (message.type ?? "") {
+					case "connection_ack":
+						socket.send(JSON.stringify({
+							id: "1",
+							type: "subscribe",
+							payload: {
+								query: `subscription($address: HexEncoded!) {
+                    contractActions(address: $address, offset: { height: 0 }) { ${ACTION_FIELDS} }
+                  }`,
+								variables: { address: stripHexPrefix(address) }
+							}
+						}));
+						break;
+					case "next": {
+						if (message.payload?.errors?.length) {
+							fail(/* @__PURE__ */ new Error(`contractActions subscription: ${JSON.stringify(message.payload.errors)}`));
+							break;
+						}
+						const action = message.payload?.data?.contractActions;
+						if (!action) break;
+						actions.push(toRecord(action));
+						if (actions.at(-1)?.txHash === frontier.txHash && !drain) drain = setTimeout(() => {
+							finish();
+						}, drainMs);
+						break;
+					}
+					case "error":
+						fail(/* @__PURE__ */ new Error(`contractActions subscription: ${JSON.stringify(message.payload)}`));
+						break;
+					case "complete":
+						finish();
+						break;
+					default: break;
+				}
+			});
+		});
+	};
+	/**
+	* The indexer keeps, per transaction, the events the ledger emitted while
+	* applying it; a shielded output's event carries the commitment and the
+	* tree index the ledger assigned, so the index is read, never inferred
+	* from the transaction's position window.
+	*/
+	const queryShieldedOutputs = async (txHash) => {
+		const events = ((await postQuery("transactions", `query($offset: TransactionOffset!) { transactions(offset: $offset) { hash ... on RegularTransaction { zswapLedgerEvents { raw } } } }`, { offset: { hash: stripHexPrefix(txHash) } })).data?.transactions ?? []).flatMap((transaction) => transaction.zswapLedgerEvents ?? []);
+		if (events.length === 0) return [];
+		const { Event } = await import("@midnightntwrk/ledger-v9");
+		return events.flatMap(({ raw }) => {
+			const { content } = Event.deserialize(eventBytes(stripHexPrefix(raw ?? "")));
+			return isShieldedOutputEvent(content) ? [{
+				commitment: content.commitment.toLowerCase(),
+				...content.contract === void 0 ? {} : { contractAddress: content.contract.toLowerCase() },
+				index: content.mtIndex
+			}] : [];
+		});
+	};
+	return {
+		queryContractState: async (address) => (await provider()).queryContractState(address),
+		enumerateContractActions,
+		queryShieldedOutputs
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/flows/account-call.ts
+/** Contract aborts meaning the authorising key was rejected. */
+const NOT_AUTHORISED_ABORTS = ["failed assert: invalid signature", "failed assert: device key"];
+/**
+* Raised by the caller checks in require_authorised and by the target
+* check in _do_remove_device: the same string for two different failures.
+*/
+const UNKNOWN_ENTRY_ABORT = "failed assert: unknown device entry";
+/** Whether a contract abort message says the authorising key was rejected. */
+const isNotAuthorisedAbort = (message) => NOT_AUTHORISED_ABORTS.some((abort) => message.includes(abort));
+/**
+* The decoded ledger state of the account at `address`, which must hold
+* a live contract.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountLedger = async (indexer, address) => {
+	const state = await indexer.queryContractState(address);
+	if (!state) throw new AccountContractMissingError(`No live Account Custody Contract found at ${address}.`);
+	return ledger(state.data);
+};
+/**
+* Reads the account's ledger state through a fresh indexer client, which
+* is returned with it so a flow can read the state again after a call.
+*/
+const readAccountLedger = async (address, { indexerUrl, indexerWsUrl }) => {
+	const indexer = createIndexerClient({
+		indexerUrl,
+		indexerWsUrl
+	});
+	return {
+		indexer,
+		ledgerState: await queryAccountLedger(indexer, address)
+	};
+};
+/**
+* Submits one gated call and reports the position it left the local
+* device in. The handle is connected without the account encryption
+* secret: the device and grant lifecycle circuits read no private state,
+* so deriving it here would only widen the window the secret spends in
+* memory. The successor commitment is computed against the epoch read
+* before the call, which is the epoch the accepted call ran under: a
+* gated call never changes device_epoch (it is only written at
+* construction), so the pre-call epoch names the very entry the contract
+* inserted.
+*/
+const submitAccountCall = async ({ circuit, args, account, localUseCounter, ledgerState, onStage }, { passportAuthoriser, passportNetwork, passportProver, passportSponsor }) => {
+	const handle = await connectAccountHandle(await createMidnightProviders({
+		network: passportNetwork,
+		prover: passportProver,
+		sponsor: passportSponsor,
+		...onStage ? { onStage } : {}
+	}), account.address);
+	const address = AccAddress(account.address);
+	const advancedCounter = await executeGatedCall({
+		handle,
+		authoriser: passportAuthoriser,
+		circuit,
+		args,
+		address,
+		ledgerState,
+		knownUseCounter: localUseCounter === void 0 ? void 0 : UseCounter(BigInt(localUseCounter))
+	});
+	return {
+		advancedCounter,
+		localCommitmentHex: await passportAuthoriser.deviceCommitment(address, DeviceEpoch(ledgerState.device_epoch), advancedCounter)
+	};
+};
+/**
+* The devices list with the local device's row moved to the commitment it
+* holds after an accepted call. An entry is single use: the call consumed
+* the one the row carried and the contract inserted its successor, so
+* leaving the row as it was would name an entry the on-chain set no
+* longer holds. Only existing rows are rewritten, so a removal that
+* dropped the local row does not resurrect it.
+*/
+const withRefreshedLocalDevice = (devices, commitmentHex) => devices.map((device) => device.isLocal ? {
+	...device,
+	commitmentHex
+} : device);
+//#endregion
+export { submitAccountCall as a, readAccountLedger as i, isNotAuthorisedAbort as n, withRefreshedLocalDevice as o, queryAccountLedger as r, createIndexerClient as s, UNKNOWN_ENTRY_ABORT as t };

package/dist/account-call-DFcD257E.cjs

@@ -0,0 +1,4 @@
+require("./chunk-9hOWP6kD.cjs");
+require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_account_call = require("./account-call-B7cF8ly4.cjs");
+exports.readAccountLedger = require_account_call.readAccountLedger;

package/dist/account-guards-BeKbV9D1.cjs

@@ -0,0 +1,41 @@
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_outputs = require("./outputs-BEM1GPMf.cjs");
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-account-guard.ts
+/**
+* An ordinary builder was asked to spend from a Cardano custody account.
+* Its UTxOs are locked by the custody script, and a key-signed build would
+* be one the chain refuses; only the custody builder spends them.
+*/
+var CardanoCustodyAccountRefusedError = class extends Error {
+	code = "custody-account";
+	constructor(accountId) {
+		super(`Account ${accountId} is a Cardano custody account; build its transactions with the custody builder`);
+		this.name = "CardanoCustodyAccountRefusedError";
+	}
+};
+const isCustodyAddress = (address) => {
+	const parsed = require_Address.Address.fromString(address);
+	return !!parsed && require_outputs.classifyCustodyAddress(parsed).kind !== "other";
+};
+/**
+* Throws when any of the account's Cardano addresses pays a supported
+* custody account validator, with any stake part or none.
+*
+* @throws `CardanoCustodyAccountRefusedError`
+*/
+const refuseCustodyAccount = (accountId, addresses) => {
+	if (addresses.some((address) => address.accountId === accountId && address.blockchainName === "Cardano" && isCustodyAddress(address.address))) throw new CardanoCustodyAccountRefusedError(accountId);
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/account-guards.ts
+/** Throws when an ordinary builder may not spend from the account. */
+const refuseExtensionAccount = (accountId, addresses) => {
+	refuseCustodyAccount(accountId, addresses);
+};
+//#endregion
+Object.defineProperty(exports, "refuseExtensionAccount", {
+	enumerable: true,
+	get: function() {
+		return refuseExtensionAccount;
+	}
+});

package/dist/account-guards-qnFXuXSE.js

@@ -0,0 +1,36 @@
+import { t as Address } from "./Address-_c_-9hLC.js";
+import { a as classifyCustodyAddress } from "./outputs-5qdW8s-f.js";
+//#region ../../packages/module/blockchain-cardano/src/store/custody/custody-account-guard.ts
+/**
+* An ordinary builder was asked to spend from a Cardano custody account.
+* Its UTxOs are locked by the custody script, and a key-signed build would
+* be one the chain refuses; only the custody builder spends them.
+*/
+var CardanoCustodyAccountRefusedError = class extends Error {
+	code = "custody-account";
+	constructor(accountId) {
+		super(`Account ${accountId} is a Cardano custody account; build its transactions with the custody builder`);
+		this.name = "CardanoCustodyAccountRefusedError";
+	}
+};
+const isCustodyAddress = (address) => {
+	const parsed = Address.fromString(address);
+	return !!parsed && classifyCustodyAddress(parsed).kind !== "other";
+};
+/**
+* Throws when any of the account's Cardano addresses pays a supported
+* custody account validator, with any stake part or none.
+*
+* @throws `CardanoCustodyAccountRefusedError`
+*/
+const refuseCustodyAccount = (accountId, addresses) => {
+	if (addresses.some((address) => address.accountId === accountId && address.blockchainName === "Cardano" && isCustodyAddress(address.address))) throw new CardanoCustodyAccountRefusedError(accountId);
+};
+//#endregion
+//#region ../../packages/module/blockchain-cardano/src/store/account-guards.ts
+/** Throws when an ordinary builder may not spend from the account. */
+const refuseExtensionAccount = (accountId, addresses) => {
+	refuseCustodyAccount(accountId, addresses);
+};
+//#endregion
+export { refuseExtensionAccount as t };

package/dist/{activity-type.stable-ClO9j_PH.cjs → activity-type-BPXxdHBP.cjs}

@@ -1,4 +1,4 @@
-//#region ../../packages/contract/activities/src/activity-type.stable.ts
+//#region ../../packages/contract/activities/src/activity-type.ts
 /** What an activity did, such as `Send`, `Receive`, `Rewards` or `Delegation`. */
 let ActivityType = /* @__PURE__ */ function(ActivityType) {
 	ActivityType["Send"] = "Send";
@@ -11,6 +11,7 @@ let ActivityType = /* @__PURE__ */ function(ActivityType) {
 	ActivityType["Registration"] = "Registration";
 	ActivityType["Deregistration"] = "Deregistration";
 	ActivityType["Withdrawal"] = "Withdrawal";
+	ActivityType["NightDesignation"] = "NightDesignation";
 	return ActivityType;
 }({});
 //#endregion

package/dist/{activity-type.stable-Ml0SOYv9.js → activity-type-C1geyPsH.js}

@@ -1,4 +1,4 @@
-//#region ../../packages/contract/activities/src/activity-type.stable.ts
+//#region ../../packages/contract/activities/src/activity-type.ts
 /** What an activity did, such as `Send`, `Receive`, `Rewards` or `Delegation`. */
 let ActivityType = /* @__PURE__ */ function(ActivityType) {
 	ActivityType["Send"] = "Send";
@@ -11,6 +11,7 @@ let ActivityType = /* @__PURE__ */ function(ActivityType) {
 	ActivityType["Registration"] = "Registration";
 	ActivityType["Deregistration"] = "Deregistration";
 	ActivityType["Withdrawal"] = "Withdrawal";
+	ActivityType["NightDesignation"] = "NightDesignation";
 	return ActivityType;
 }({});
 //#endregion