@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/account-BOQruszJ.js

@@ -0,0 +1,6 @@
+import { a as isCardanoAccount } from "./util-Cp5cZkfK.js";
+//#region ../../packages/contract/cardano-context/src/custody/account.ts
+/** Whether `account` is a Cardano custody account. */
+const isCardanoCustodyAccount = (account) => isCardanoAccount(account) && account.accountType === "CardanoCustody";
+//#endregion
+export { isCardanoCustodyAccount as t };

package/dist/account-BUOj4pYJ.cjs

@@ -0,0 +1,11 @@
+const require_util = require("./util-Bu4W5lF4.cjs");
+//#region ../../packages/contract/cardano-context/src/custody/account.ts
+/** Whether `account` is a Cardano custody account. */
+const isCardanoCustodyAccount = (account) => require_util.isCardanoAccount(account) && account.accountType === "CardanoCustody";
+//#endregion
+Object.defineProperty(exports, "isCardanoCustodyAccount", {
+	enumerable: true,
+	get: function() {
+		return isCardanoCustodyAccount;
+	}
+});

package/dist/account-call-7wnopBq0.cjs

@@ -0,0 +1,5 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+require("./_polyfill-buffer-patch-CM8X7JiY.cjs");
+require("./codecs-Cswkg7Tm.cjs");
+const require_account_call = require("./account-call-Bd4Rpbvt.cjs");
+exports.readAccountLedger = require_account_call.readAccountLedger;

package/dist/account-call-B9d_2Xwi.js

@@ -0,0 +1,4 @@
+import "./_polyfill-buffer-patch-yNxN4d5E.js";
+import "./codecs-Dc1Krpbt.js";
+import { a as readAccountLedger } from "./account-call-C3CkDqEC.js";
+export { readAccountLedger };

package/dist/account-call-Bd4Rpbvt.cjs

@@ -0,0 +1,323 @@
+const require_bytes_vo = require("./bytes.vo-BNRquqaO.cjs");
+const require_errors = require("./errors-BIftM8ZN.cjs");
+const require_providers = require("./providers-FjhM47BH.cjs");
+const require_gated_call = require("./gated-call-DgJm1Mi_.cjs");
+const require_acc_module = require("./acc-module-4iIUv6My.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 isShieldedInputEvent = (content) => content.tag === "zswapInput";
+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 and the coins it spent 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, and a shielded spend's event
+	* carries the nullifier the ledger recorded for the coin it consumed.
+	*/
+	const queryShieldedEvents = 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 ?? []);
+		const found = {
+			outputs: [],
+			nullifiers: []
+		};
+		if (events.length === 0) return found;
+		const { Event } = await import("@midnightntwrk/ledger-v9");
+		for (const { raw } of events) {
+			const { content } = Event.deserialize(eventBytes(stripHexPrefix(raw ?? "")));
+			if (isShieldedOutputEvent(content)) found.outputs.push({
+				commitment: content.commitment.toLowerCase(),
+				...content.contract === void 0 ? {} : { contractAddress: content.contract.toLowerCase() },
+				index: content.mtIndex
+			});
+			else if (isShieldedInputEvent(content)) found.nullifiers.push(content.nullifier.toLowerCase());
+		}
+		return found;
+	};
+	return {
+		queryContractState: async (address) => (await provider()).queryContractState(address),
+		enumerateContractActions,
+		queryShieldedEvents
+	};
+};
+//#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 contract state the indexer serves at `address`, which must exist.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountState = 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 state;
+};
+/**
+* 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) => require_acc_module.ledger((await queryAccountState(indexer, address)).data);
+/**
+* The operations the account at `address` holds verifier keys for, which
+* are the circuits the chain will accept a call to.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountOperations = async (indexer, address) => (await queryAccountState(indexer, address)).operations().map(String);
+/**
+* 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, "queryAccountOperations", {
+	enumerable: true,
+	get: function() {
+		return queryAccountOperations;
+	}
+});
+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-C3CkDqEC.js

@@ -0,0 +1,276 @@
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { t as AccountContractMissingError } from "./errors-DSq5wUwt.js";
+import { i as AccAddress, t as createMidnightProviders } from "./providers-WtiSuxFu.js";
+import { d as UseCounter, n as executeGatedCall, t as connectAccountHandle, u as DeviceEpoch } from "./gated-call-D-tT7P_t.js";
+import { i as ledger } from "./acc-module-Cmj8EsIb.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 isShieldedInputEvent = (content) => content.tag === "zswapInput";
+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 and the coins it spent 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, and a shielded spend's event
+	* carries the nullifier the ledger recorded for the coin it consumed.
+	*/
+	const queryShieldedEvents = 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 ?? []);
+		const found = {
+			outputs: [],
+			nullifiers: []
+		};
+		if (events.length === 0) return found;
+		const { Event } = await import("@midnightntwrk/ledger-v9");
+		for (const { raw } of events) {
+			const { content } = Event.deserialize(eventBytes(stripHexPrefix(raw ?? "")));
+			if (isShieldedOutputEvent(content)) found.outputs.push({
+				commitment: content.commitment.toLowerCase(),
+				...content.contract === void 0 ? {} : { contractAddress: content.contract.toLowerCase() },
+				index: content.mtIndex
+			});
+			else if (isShieldedInputEvent(content)) found.nullifiers.push(content.nullifier.toLowerCase());
+		}
+		return found;
+	};
+	return {
+		queryContractState: async (address) => (await provider()).queryContractState(address),
+		enumerateContractActions,
+		queryShieldedEvents
+	};
+};
+//#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 contract state the indexer serves at `address`, which must exist.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountState = async (indexer, address) => {
+	const state = await indexer.queryContractState(address);
+	if (!state) throw new AccountContractMissingError(`No live Account Custody Contract found at ${address}.`);
+	return state;
+};
+/**
+* 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) => ledger((await queryAccountState(indexer, address)).data);
+/**
+* The operations the account at `address` holds verifier keys for, which
+* are the circuits the chain will accept a call to.
+*
+* @throws {@link AccountContractMissingError} when the indexer serves no
+* contract at the address.
+*/
+const queryAccountOperations = async (indexer, address) => (await queryAccountState(indexer, address)).operations().map(String);
+/**
+* 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 { readAccountLedger as a, createIndexerClient as c, queryAccountOperations as i, isNotAuthorisedAbort as n, submitAccountCall as o, queryAccountLedger as r, withRefreshedLocalDevice as s, UNKNOWN_ENTRY_ABORT as t };

package/dist/account-guards-BtjTGxDZ.cjs

@@ -0,0 +1,42 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_outputs = require("./outputs-CJoQBIA2.cjs");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+//#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 = _laceio_cardano_core.Cardano.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;
+	}
+});