@laceio/sdk 0.1.1 → 0.1.2-canary.1

package/dist/gated-call-D-tT7P_t.js

@@ -0,0 +1,722 @@
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-BB7_4JK6.js";
+import { E as MaintenanceAuthorityMismatchError, d as DeviceEntryNotFoundError, l as CreationArtefactMismatchError, o as AuthorityNotRetiredError, s as AuthorityRetiredError, t as AccountContractMissingError } from "./errors-DSq5wUwt.js";
+import { d as assertVerifierKeyHeader, f as verifierKeyInsert, n as submitTx, o as isSameAuthority, p as DEPLOYED_OPERATIONS, r as submitWithDustRetry, t as assertSubmitted } from "./submit-DOv8Z0Vf.js";
+import { a as pureCircuits, i as ledger, r as expectedVk, t as Contract } from "./acc-module-Cmj8EsIb.js";
+import { n as JubjubDevice, r as authArgs } from "./signer-DGluibtn.js";
+//#region ../../packages/contract/passport/src/value-objects/use-counter.vo.ts
+/** Types a bigint as an authoriser's use counter. It checks nothing. */
+const UseCounter = (value) => value;
+//#endregion
+//#region ../../packages/contract/passport/src/value-objects/device-epoch.vo.ts
+/** Types a bigint as a device authoriser's epoch. It checks nothing. */
+const DeviceEpoch = (value) => value;
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/wave-plan.ts
+/**
+* Most verifier key bytes one transaction may carry. A deploy or
+* maintenance update above it is refused by the node for exhausting the
+* block limits, so the roster is split into waves packed under this
+* figure. The budget is a packing heuristic over the measured key sizes,
+* not the node's own weight check.
+*/
+const VERIFIER_BYTE_BUDGET = 15e3;
+const sizeOf = (sizes, operation) => {
+	const size = sizes.get(operation);
+	if (size === void 0) throw new Error(`No verifier key size for operation '${operation}'`);
+	return size;
+};
+const assertBudget = (budget) => {
+	if (!Number.isFinite(budget) || budget <= 0) throw new Error(`The verifier byte budget must be a positive number, got ${budget}`);
+};
+/**
+* Packs the operations greedily, in order, into batches no larger than
+* the budget. Greedy over one fixed order keeps the plan deterministic
+* for a given roster and key set, so a retry computes the same waves.
+*/
+const packOperations = (operations, sizes, budget) => {
+	const batches = [];
+	let current = {
+		operations: [],
+		verifierBytes: 0
+	};
+	for (const operation of operations) {
+		const size = sizeOf(sizes, operation);
+		if (size > budget) throw new Error(`The verifier key of '${operation}' (${size} bytes) exceeds the ${budget} byte wave budget`);
+		if (current.verifierBytes + size > budget) {
+			batches.push(current);
+			current = {
+				operations: [],
+				verifierBytes: 0
+			};
+		}
+		current.operations.push(operation);
+		current.verifierBytes += size;
+	}
+	if (current.operations.length > 0) batches.push(current);
+	return batches;
+};
+/**
+* The maintenance waves for the given batches. The replacement of the
+* deploy-time authority rides on the last of them, the last update that
+* needs it; with nothing left to install, a replace-only update is the
+* whole of it.
+*/
+const toMaintenanceWaves = (batches) => {
+	const waves = batches.map((batch) => ({
+		kind: "maintenance",
+		...batch,
+		replacesAuthority: false
+	}));
+	const last = waves.at(-1);
+	if (last) last.replacesAuthority = true;
+	else waves.push({
+		kind: "maintenance",
+		operations: [],
+		verifierBytes: 0,
+		replacesAuthority: true
+	});
+	return waves;
+};
+/**
+* Plans a fresh deployment: the deploy carries the longest prefix of the
+* roster under the budget, and every later wave is one maintenance update
+* with the next batch. The order is the roster's, so the activation
+* circuit lands in the deploy and the account is usable as early as the
+* waves allow.
+*/
+const planDeployWaves = (operations, sizes, { budget = VERIFIER_BYTE_BUDGET } = {}) => {
+	assertBudget(budget);
+	const [deploy, ...rest] = packOperations(operations, sizes, budget);
+	if (!deploy) throw new Error("A deployment needs at least one operation");
+	return [{
+		kind: "deploy",
+		...deploy,
+		replacesAuthority: false
+	}, ...toMaintenanceWaves(rest)];
+};
+/**
+* Plans the waves a deployed contract still needs: the roster operations
+* not yet installed, packed as maintenance updates, and the replacement
+* of the deploy-time authority while it is still live.
+* Installed operations are read from chain rather than from any local
+* count, so a wave that landed without being recorded is never sent
+* twice.
+*
+* @throws {@link AuthorityRetiredError} when operations are missing but
+* the deploy-time authority is already replaced: nothing that holds it
+* can install them any more.
+*/
+const planResumeWaves = ({ operations, sizes, installed, isAuthorityReplaced, budget = VERIFIER_BYTE_BUDGET }) => {
+	assertBudget(budget);
+	const installedSet = new Set(installed);
+	const missing = operations.filter((operation) => !installedSet.has(operation));
+	if (isAuthorityReplaced) {
+		if (missing.length > 0) throw new AuthorityRetiredError(`The deploy-time maintenance authority is replaced and ${missing.length} operations are not installed: ${missing.join(", ")}`);
+		return [];
+	}
+	return toMaintenanceWaves(packOperations(missing, sizes, budget));
+};
+/**
+* Plans the waves that install `operations` on a live account: one
+* maintenance update per batch packed under the budget, in the order
+* given, none replacing the authority, which stays the one that signs
+* them.
+*/
+const planInstallWaves = (operations, sizes, { budget = VERIFIER_BYTE_BUDGET } = {}) => {
+	assertBudget(budget);
+	return packOperations(operations, sizes, budget).map((batch) => ({
+		kind: "maintenance",
+		...batch,
+		replacesAuthority: false
+	}));
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/deploy.ts
+const ACTIVATE_INITIAL_DEVICE_CIRCUIT = "activate_initial_device_with_jubjub";
+const SALT_LENGTH = 32;
+const RECOVERY_WRAP_LENGTH = 64;
+const PRIVATE_STATE_ID_LENGTH$1 = 8;
+/** Three days, the veto window published with the throwaway recovery. */
+const VETO_WINDOW_SECONDS = 259200n;
+const DEPLOY_TX_TTL_MS = 6e4;
+/** How long a landed wave may take to show in the indexer's state. */
+const AUTHORITY_POLL_ATTEMPTS = 60;
+const AUTHORITY_POLL_DELAY_MS = 2e3;
+/** How long a landed deploy may take to appear in the indexer at all. */
+const INDEXED_POLL_ATTEMPTS = 30;
+const defaultSleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* The contract's witness implementations over {@link AccountPrivateState}.
+* `held_coin` serves the exact qualified coin a shielded spend consumes;
+* a color the store has not captured cannot be spent by a conforming
+* client, so the witness refuses it.
+*/
+const accountWitnesses = { held_coin: (context, color) => {
+	const key = HexBytes.fromByteArray(color);
+	const stored = context.privateState.coins[key];
+	if (!stored) throw new Error(`held_coin witness: no coin for color ${key} in the local store`);
+	return [context.privateState, {
+		nonce: ByteArray.fromHex(HexBytes(stored.nonceHex)),
+		color: ByteArray.fromHex(HexBytes(stored.colorHex)),
+		value: BigInt(stored.value),
+		mt_index: BigInt(stored.mtIndex)
+	}];
+} };
+/** The private state a handle starts from: no captured coins yet. */
+const initialAccountPrivateState = () => ({ coins: {} });
+const noSponsorSetup = async () => void 0;
+/** The expiry of a transaction built now, once the sponsor is ready. */
+const transactionTtl = async (sponsorReady) => {
+	await sponsorReady();
+	return new Date(Date.now() + DEPLOY_TX_TTL_MS);
+};
+const defaultRandomBytes = (length) => crypto.getRandomValues(new Uint8Array(length));
+const importChainModules = async () => Promise.all([
+	import("@midnight-ntwrk/midnight-js-contracts"),
+	import("@midnightntwrk/ledger-v9"),
+	import("@midnight-ntwrk/midnight-js-network-id"),
+	import("@midnight-ntwrk/compact-js/effect/CompiledContract")
+]);
+/**
+* Names the verifier keys this build installs: the lowercase hex sha256
+* over each roster operation's name and the sha256 pin of its verifier
+* key, in installation order. A deployment records it once the deploy
+* lands, and a resume compares it before any wave, so an account never
+* holds verifier keys of two builds.
+*/
+const deployedVerifierKeysDigest = async () => {
+	const pins = DEPLOYED_OPERATIONS.map((operation) => {
+		const pin = expectedVk[operation];
+		if (!pin) throw new Error(`No verifier key pin for '${operation}'`);
+		return `${operation}:${pin}`;
+	});
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(pins.join("\n")));
+	return HexBytes.fromByteArray(new Uint8Array(digest));
+};
+/**
+* The verifier key of each of `operations`, downloaded through the zk
+* config provider so each one is checked against its pin and its header,
+* and the sizes the wave plan is computed from. The plan follows the
+* real keys, so a roster or key-size change re-plans itself.
+*/
+const loadVerifierKeys = async (providers, operations) => {
+	const zkConfig = providers.zkConfigProvider;
+	const keys = new Map(await Promise.all(operations.map(async (operation) => {
+		const key = await zkConfig.getVerifierKey(operation);
+		assertVerifierKeyHeader(operation, key);
+		return [operation, key];
+	})));
+	return {
+		keys,
+		sizes: new Map([...keys].map(([operation, key]) => [operation, key.length]))
+	};
+};
+const queryContractState = async ({ providers, address }) => providers.publicDataProvider.queryContractState(address);
+/** The contract state as the indexer serves it, which must exist. */
+const readProvidedState = async (chain) => {
+	const state = await queryContractState(chain);
+	if (!state) throw new AccountContractMissingError(`No live Account Custody Contract found at ${chain.address}.`);
+	return state;
+};
+/**
+* The contract state as it stands on chain, read as the ledger's class.
+* The public data provider hands back a compact-runtime state; the two
+* bridge by serialisation.
+*/
+const readContractState = async (chain) => chain.ledger.ContractState.deserialize((await readProvidedState(chain)).serialize());
+/**
+* The contract maintenance authority as it stands on chain: its
+* committee, threshold and the counter the next update is built against.
+*
+* @throws {@link AccountContractMissingError} when the address holds no
+* live contract.
+*/
+const readMaintenanceAuthority = async (chain) => (await readContractState(chain)).maintenanceAuthority;
+/**
+* Blocks until the indexer serves the contract the deploy created. The
+* deploy is final once its submission settles, but the indexer can lag
+* the block it landed in, and the first wave reads the authority counter
+* from it.
+*/
+const awaitContractIndexed = async (chain, sleep) => {
+	for (let attempt = 0; attempt < INDEXED_POLL_ATTEMPTS; attempt++) {
+		if (await queryContractState(chain)) return;
+		await sleep(AUTHORITY_POLL_DELAY_MS);
+	}
+	throw new AccountContractMissingError(`The Account Custody Contract deployed at ${chain.address} never appeared in the indexer.`);
+};
+/**
+* Blocks until the chain shows the counter a wave advanced the authority
+* to. The next update must be built against the advanced counter, and
+* the indexer can lag the block the wave landed in.
+*/
+const awaitAuthorityCounter = async (chain, expected, sleep) => {
+	for (let attempt = 0; attempt < AUTHORITY_POLL_ATTEMPTS; attempt++) {
+		const { maintenanceAuthority } = await readContractState(chain);
+		if (maintenanceAuthority.counter >= expected) return;
+		await sleep(AUTHORITY_POLL_DELAY_MS);
+	}
+	throw new Error(`The maintenance authority counter of ${chain.address} never reached ${expected}`);
+};
+/**
+* Submits one maintenance update carrying the signature of the sole
+* committee member, at index 0, and blocks until the chain shows the
+* counter its application advanced the authority to, so the next update
+* or call is built against the advanced state.
+*
+* @throws when the update lands with a failing status, or when the
+* counter never advances within the polling window.
+*/
+const submitMaintenanceUpdate = async ({ providers, ledger, address, networkId, update, signature, label, sleep = defaultSleep, sponsorReady = noSponsorSetup }) => {
+	assertSubmitted(label, await submitTx(providers, { unprovenTx: ledger.Transaction.fromParts(networkId.getNetworkId(), void 0, void 0, ledger.Intent.new(await transactionTtl(sponsorReady)).addMaintenanceUpdate(update.addSignature(0n, signature))) }));
+	await awaitAuthorityCounter({
+		providers,
+		ledger,
+		address
+	}, update.counter + 1n, sleep);
+};
+/**
+* The committee that succeeds the deploy-time authority: none for a
+* locked account, which retires it, or else the handover authority
+* alone, so every device holding the roster key can sign maintenance.
+*/
+const successorOf = ({ lockAccount, handoverAuthority }) => lockAccount ? [] : [handoverAuthority];
+/** Whether a committee on chain is exactly `expected`, member for member. */
+const isCommittee = (committee, expected) => committee.length === expected.length && committee.every((member, index) => isSameAuthority(member, expected[index]));
+const verifierKeyOf = (verifierKeys, operation) => {
+	const key = verifierKeys.get(operation);
+	if (!key) throw new Error(`No verifier key loaded for '${operation}'`);
+	return key;
+};
+/**
+* Submits the maintenance waves in order, each one update carrying its
+* batch of verifier key inserts, signed by the maintenance authority key.
+* The counter is read from chain before every update because each
+* applied update advances it, and the wave that replaces the authority
+* installs the successor committee, threshold one, at the counter its
+* own application leaves behind.
+*/
+const installWaves = async ({ providers, ledger, address, networkId, waves, verifierKeys, authorityKey, successor, sleep, sponsorReady }) => {
+	const chain = {
+		providers,
+		ledger,
+		address
+	};
+	for (const [index, wave] of waves.entries()) {
+		const { counter } = await readMaintenanceAuthority(chain);
+		const updates = wave.operations.map((operation) => verifierKeyInsert(ledger, operation, verifierKeyOf(verifierKeys, operation)));
+		if (wave.replacesAuthority) updates.push(new ledger.ReplaceAuthority(new ledger.ContractMaintenanceAuthority([...successor], 1, counter + 1n)));
+		const update = new ledger.MaintenanceUpdate(address, updates, counter);
+		await submitMaintenanceUpdate({
+			...chain,
+			networkId,
+			update,
+			signature: ledger.signData(authorityKey, update.dataToSign),
+			label: `Verifier key wave ${index + 1} of ${waves.length}`,
+			sleep,
+			sponsorReady
+		});
+	}
+};
+/**
+* Connects to the deployed contract and returns the account with its
+* activation call. The connection checks the pinned circuits' keys on
+* chain, so it runs only once every wave is in.
+*/
+const toDeployedAccount = async ({ providers, findContract, compiledContract, address, publicKey, salt, privateStateId, isActivated }) => {
+	const found = await findContract(providers, {
+		contractAddress: address,
+		compiledContract,
+		privateStateId,
+		initialPrivateState: initialAccountPrivateState()
+	});
+	return {
+		address,
+		salt,
+		isActivated,
+		activate: async () => {
+			const finalized = await submitWithDustRetry(async () => found.callTx[ACTIVATE_INITIAL_DEVICE_CIRCUIT](publicKey, salt));
+			assertSubmitted("Account activation", finalized);
+			return finalized;
+		}
+	};
+};
+const compileAccountContract = (CompiledContract) => CompiledContract.make("account", Contract).pipe(CompiledContract.withWitnesses(accountWitnesses));
+const privateStateIdFrom = (randomBytes) => `account-${HexBytes.fromByteArray(randomBytes(PRIVATE_STATE_ID_LENGTH$1))}`;
+/**
+* The state the deploy carries: the constructor's data and maintenance
+* authority with only the first wave's operations, each one's verifier
+* key set from the downloaded, header-checked bytes. The pipeline's own
+* state is not reused as is because compact-js fills verifier keys only
+* for the circuits the zk config provider lists, the manifest-pinned
+* ones, so the deposits would land without a key.
+*/
+const toDeployedState = ({ ledger, fullState, operations, verifierKeys }) => {
+	const deployedState = new ledger.ContractState();
+	deployedState.data = fullState.data;
+	deployedState.maintenanceAuthority = fullState.maintenanceAuthority;
+	for (const name of operations) {
+		const operation = fullState.operation(name);
+		if (!operation) throw new Error(`Compiled account contract has no operation '${name}'`);
+		operation.verifierKey = verifierKeyOf(verifierKeys, name);
+		deployedState.setOperation(name, operation);
+	}
+	return deployedState;
+};
+/**
+* Deploys a fresh Account Custody Contract carrying the deposits, the
+* jubjub device arm and the grant circuits, including the secp256k1
+* grantee withdrawals, and returns its address, the boot salt, and the
+* activation call.
+*
+* The constructor cannot insert the initial device entry (the contract
+* address does not exist yet inside it), so it stores a salted boot
+* commitment over the authoriser's public key with no device entry yet;
+* `activate` presents the same key and salt to install the real entry
+* once every wave is in.
+*
+* The constructor also publishes the account's recovery material: a
+* recovery public key, the wrap its secret is sealed under, and the veto
+* window a recovery must survive. This module offers no recovery, so it
+* publishes a throwaway: a fresh jubjub key whose secret is discarded
+* here and a three day window. No secret is sealed, so the wrap is left
+* empty: all zero bytes are the unambiguous "no container" encoding,
+* whereas random bytes would be indistinguishable on chain from a sealed
+* viewing secret. Nobody holds the secret, so the account is recoverable
+* by nobody, exactly as before the contract gained the field.
+*
+* The roster's verifier keys exceed what one transaction may carry, so
+* the deployment runs in waves: the deploy carries the budgeted prefix of
+* the roster, and each later wave is one maintenance update inserting
+* the next batch, signed by the maintenance authority the deploy minted.
+* `onDeployed` is called between the deploy and the first update with
+* what a retry needs ({@link PendingDeployment}), so an interruption
+* leaves a deployment {@link resumeAccountDeployment} can finish.
+* The deploy and every wave are built only once `sponsorReady`
+* resolves, so a sponsor's setup never runs down their expiry.
+*
+* The maintenance authority's signing key is total custody: it can
+* replace any operation's verifier key and release the account's assets
+* around the device seam. The deploy-time key only signs the waves: the
+* last wave always replaces it, and the key is dropped once the account
+* is activated, held until then only for the duration of the flow and in
+* the pending record a retry reads. `lockAccount` decides what replaces
+* it, explicitly:
+*
+* - `true`: an unsatisfiable authority (empty committee at threshold 1).
+*   No maintenance update can ever be signed again, so the device seam
+*   becomes the only way to move the account's assets. The cost is that
+*   the account can never receive a future arm's circuits.
+* - `false`: `handoverAuthority` alone at threshold 1, the authority the
+*   account's roster key derives. Every enrolled device that holds the
+*   roster key can then sign maintenance updates through the encryption
+*   key seam and grantees never can; a roster rotation rotates the
+*   authority with it, so a removed device loses its upgrade rights.
+*/
+const deployAccount = async ({ providers, authoriser, encPublicKey, lockAccount, handoverAuthority, onDeployed, randomBytes = defaultRandomBytes, sleep = defaultSleep, sponsorReady = noSponsorSetup }) => {
+	const [contracts, ledger, networkId, CompiledContract] = await importChainModules();
+	const publicKey = await authoriser.devicePublicKey();
+	const salt = randomBytes(SALT_LENGTH);
+	const bootCommitment = pureCircuits.derive_boot_commitment_with_jubjub(salt, publicKey);
+	const recoveryPublicKey = JubjubDevice.generate().pk;
+	const recoveryWrap = new Uint8Array(RECOVERY_WRAP_LENGTH);
+	const privateStateId = privateStateIdFrom(randomBytes);
+	const compiledContract = compileAccountContract(CompiledContract);
+	const createDeployTransaction = contracts.createUnprovenDeployTx;
+	const deployData = await createDeployTransaction(providers, {
+		compiledContract,
+		initialPrivateState: initialAccountPrivateState(),
+		args: [
+			bootCommitment,
+			encPublicKey,
+			recoveryPublicKey,
+			recoveryWrap,
+			VETO_WINDOW_SECONDS
+		]
+	});
+	const fullState = ledger.ContractState.deserialize(deployData.public.initialContractState.serialize());
+	const { keys: verifierKeys, sizes } = await loadVerifierKeys(providers, DEPLOYED_OPERATIONS);
+	const verifierKeysDigest = await deployedVerifierKeysDigest();
+	const [deployWave, ...maintenanceWaves] = planDeployWaves(DEPLOYED_OPERATIONS, sizes);
+	const deploy = new ledger.ContractDeploy(toDeployedState({
+		ledger,
+		fullState,
+		operations: deployWave.operations,
+		verifierKeys
+	}));
+	const address = String(deploy.address);
+	assertSubmitted("Account deploy", await submitTx(providers, { unprovenTx: ledger.Transaction.fromParts(networkId.getNetworkId(), void 0, void 0, ledger.Intent.new(await transactionTtl(sponsorReady)).addDeploy(deploy)) }));
+	const authorityKey = deployData.private.signingKey;
+	await onDeployed(address, {
+		operations: [...DEPLOYED_OPERATIONS],
+		lockAccount,
+		verifierKeysDigest,
+		saltHex: HexBytes.fromByteArray(salt),
+		authorityKey,
+		handoverAuthority
+	});
+	await awaitContractIndexed({
+		providers,
+		ledger,
+		address
+	}, sleep);
+	await installWaves({
+		providers,
+		ledger,
+		address,
+		networkId,
+		waves: maintenanceWaves,
+		verifierKeys,
+		authorityKey,
+		successor: successorOf({
+			lockAccount,
+			handoverAuthority
+		}),
+		sleep,
+		sponsorReady
+	});
+	return toDeployedAccount({
+		providers,
+		findContract: contracts.findDeployedContract,
+		compiledContract,
+		address,
+		publicKey,
+		salt,
+		privateStateId,
+		isActivated: false
+	});
+};
+/**
+* Whether the chain shows the deploy-time authority already replaced by
+* the committee the recorded lock choice installs, a retirement or a
+* handover that landed, rather than still live.
+*
+* @throws {@link MaintenanceAuthorityMismatchError} when the committee
+* is neither: the waves can no longer be signed and the record does not
+* describe this contract.
+*/
+const isDeployAuthorityReplaced = ({ ledger, address, committee, pending }) => {
+	if (isCommittee(committee, successorOf(pending))) return true;
+	if (isCommittee(committee, [ledger.signatureVerifyingKey(pending.authorityKey)])) return false;
+	throw new MaintenanceAuthorityMismatchError(`The maintenance authority of the account at ${address} is neither the deploy-time key nor the one its unfinished creation installs, so it cannot be resumed.`);
+};
+/**
+* Finishes a deployment whose waves were interrupted. The operations the
+* contract already holds are read from chain, the waves still missing
+* are planned from the pending roster and submitted, and the account is
+* returned with its activation call; a deployment that only missed its
+* activation plans no wave at all. A deployment the chain shows already
+* activated, because the creation died between its activation and its
+* final record write, installs nothing and is returned as activated once
+* the chain shows its authority replaced. The lock choice and the
+* handover authority are the ones recorded when the deployment began.
+* The chain's authority is read as the deploy-time key still live, or as
+* already replaced when it is the committee the recorded choice
+* installs, a retirement or a handover that landed. An activated
+* deployment whose deploy-time key is still live is refused under either
+* choice: the flow replaces the authority before it activates, so the
+* waves ran outside it and the verifier keys they installed are not
+* known to be this build's. A deployment recorded under other verifier
+* key pins than this build installs, or without a handover authority, is
+* refused before the chain is read.
+*
+* @throws {@link CreationArtefactMismatchError} when the recorded
+* verifier key digest is missing or is not this build's, or when the
+* record names no handover authority.
+* @throws {@link MaintenanceAuthorityMismatchError} when the chain's
+* authority is neither the deploy-time key nor the recorded successor.
+* @throws {@link AuthorityNotRetiredError} when the chain shows the
+* account activated with the deploy-time authority still live, whether it
+* was to be locked or handed to its devices.
+* @throws {@link AuthorityRetiredError} when operations are missing but
+* the authority has already been replaced, which no update can mend.
+* @throws {@link AccountContractMissingError} when the address holds no
+* live contract.
+*/
+const resumeAccountDeployment = async ({ providers, authoriser, address, pending, randomBytes = defaultRandomBytes, sleep = defaultSleep, sponsorReady = noSponsorSetup }) => {
+	if (pending.verifierKeysDigest !== await deployedVerifierKeysDigest()) throw new CreationArtefactMismatchError(`The unfinished creation of the account at ${address} was started under other verifier key pins than this build installs, so it cannot be resumed.`);
+	if (!pending.handoverAuthority) throw new CreationArtefactMismatchError(`The unfinished creation of the account at ${address} names no maintenance authority to hand over to, so it cannot be resumed.`);
+	const [contracts, ledger$1, networkId, CompiledContract] = await importChainModules();
+	const publicKey = await authoriser.devicePublicKey();
+	const chain = {
+		providers,
+		ledger: ledger$1,
+		address
+	};
+	const provided = await readProvidedState(chain);
+	const isActivated = ledger(provided.data).booted;
+	const onChain = ledger$1.ContractState.deserialize(provided.serialize());
+	const isAuthorityReplaced = isDeployAuthorityReplaced({
+		ledger: ledger$1,
+		address,
+		committee: onChain.maintenanceAuthority.committee,
+		pending
+	});
+	if (isActivated && !isAuthorityReplaced) throw new AuthorityNotRetiredError(pending.lockAccount ? `The account at ${address} was created to be locked and is activated, but its maintenance authority is still live.` : `The account at ${address} was created to hand its maintenance authority to its devices, but is activated with the deploy-time authority still live.`);
+	if (!isActivated) {
+		const { keys: verifierKeys, sizes } = await loadVerifierKeys(providers, pending.operations);
+		const waves = planResumeWaves({
+			operations: pending.operations,
+			sizes,
+			installed: onChain.operations().map(String),
+			isAuthorityReplaced
+		});
+		await installWaves({
+			...chain,
+			networkId,
+			waves,
+			verifierKeys,
+			authorityKey: pending.authorityKey,
+			successor: successorOf(pending),
+			sleep,
+			sponsorReady
+		});
+	}
+	return toDeployedAccount({
+		providers,
+		findContract: contracts.findDeployedContract,
+		compiledContract: compileAccountContract(CompiledContract),
+		address,
+		publicKey,
+		salt: ByteArray.fromHex(HexBytes(pending.saltHex)),
+		privateStateId: privateStateIdFrom(randomBytes),
+		isActivated
+	});
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/use-counter.ts
+/** How far past the last known counter the rescan probes. */
+const RESCAN_LIMIT = 4096n;
+/**
+* Candidates batched per deviceCommitments call. 64 keeps a typical rescan
+* (small counter drift) at one ceremony while it caps a full-window miss at
+* 64 ceremonies instead of 4096, and the per-chunk membership check stops
+* the scan before the remaining commitments are ever computed.
+*/
+const RESCAN_CHUNK = 64n;
+const isLiveEntry = (ledgerState, commitmentHex) => ledgerState.devices.member(ByteArray.fromHex(HexBytes(commitmentHex)));
+const probeInBatches = async (deviceCommitments, { ledgerState, address, epoch, from, to }) => {
+	for (let chunkStart = from; chunkStart < to; chunkStart += RESCAN_CHUNK) {
+		const counters = [];
+		const chunkEnd = chunkStart + RESCAN_CHUNK < to ? chunkStart + RESCAN_CHUNK : to;
+		for (let candidate = chunkStart; candidate < chunkEnd; candidate++) counters.push(UseCounter(candidate));
+		const commitments = await deviceCommitments(address, epoch, counters);
+		for (const [index, useCounter] of counters.entries()) {
+			const commitmentHex = commitments[index];
+			if (isLiveEntry(ledgerState, commitmentHex)) return {
+				useCounter,
+				commitmentHex
+			};
+		}
+	}
+};
+const probeOneByOne = async ({ ledgerState, authoriser, address, epoch, from, to }) => {
+	for (let candidate = from; candidate < to; candidate++) {
+		const useCounter = UseCounter(candidate);
+		const commitmentHex = await authoriser.deviceCommitment(address, epoch, useCounter);
+		if (isLiveEntry(ledgerState, commitmentHex)) return {
+			useCounter,
+			commitmentHex
+		};
+	}
+};
+const probeWindow = async (props) => {
+	const { deviceCommitments } = props.authoriser;
+	return deviceCommitments ? probeInBatches(deviceCommitments, props) : probeOneByOne(props);
+};
+/**
+* Recovers the device's current use counter from chain. The Account
+* Custody Contract stores one rolling entry per device, positioned at the
+* counter of its next authorisation, so the local counter can fall behind
+* after out-of-band calls or lost state. Candidate counters are probed
+* from the last known value (0 when unknown): the commitment computed for
+* each candidate is tested for membership in the on-chain device set, and
+* the first live entry wins. That window ends after RESCAN_LIMIT
+* candidates, and only then are the counters below the anchor probed,
+* from 0 up to it: a device removed and re-enrolled gets a fresh entry at
+* a low counter while the persisted anchor still holds the old high one,
+* and without the second pass such a device reads as revoked. A device
+* with no entry in either pass is not registered on the account, has been
+* revoked, or holds a counter beyond the probed window (a synced passkey
+* used heavily on another device can outrun RESCAN_LIMIT between
+* sign-ins here); the miss raises DeviceEntryNotFoundError, which names
+* that ambiguity. An authoriser exposing deviceCommitments is probed in
+* RESCAN_CHUNK batches so one key ceremony covers a whole chunk of
+* candidates; otherwise each candidate costs one deviceCommitment call.
+*/
+const resolveUseCounter = async ({ ledgerState, authoriser, address, knownUseCounter }) => {
+	const epoch = DeviceEpoch(ledgerState.device_epoch);
+	const anchor = knownUseCounter ?? 0n;
+	const probe = async (from, to) => probeWindow({
+		ledgerState,
+		authoriser,
+		address,
+		epoch,
+		from,
+		to
+	});
+	const ahead = await probe(anchor, anchor + RESCAN_LIMIT);
+	if (ahead) return ahead;
+	const behind = await probe(0n, anchor);
+	if (behind) return behind;
+	throw new DeviceEntryNotFoundError(`No live device entry on the ledger within ${RESCAN_LIMIT} counters of the last known one (${anchor}), nor below it; the device is not registered on this account, or its counter has moved beyond the probed window.`);
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/gated-call.ts
+const PRIVATE_STATE_ID_LENGTH = 8;
+/**
+* Connects to a deployed Account Custody Contract and returns the handle
+* gated calls run through. The private state starts without the account
+* encryption secret: the device-management and grant lifecycle circuits
+* consume no witnesses, so no coin or encryption key material is needed.
+* Shielded flows will seed the viewing secret when they arrive.
+*/
+const connectAccountHandle = async (providers, contractAddress) => {
+	const [contracts, CompiledContract] = await Promise.all([import("@midnight-ntwrk/midnight-js-contracts"), import("@midnight-ntwrk/compact-js/effect/CompiledContract")]);
+	const compiledContract = CompiledContract.make("account", Contract).pipe(CompiledContract.withWitnesses(accountWitnesses));
+	const findContract = contracts.findDeployedContract;
+	return findContract(providers, {
+		contractAddress,
+		compiledContract,
+		privateStateId: `account-${HexBytes.fromByteArray(crypto.getRandomValues(new Uint8Array(PRIVATE_STATE_ID_LENGTH)))}`,
+		initialPrivateState: initialAccountPrivateState()
+	});
+};
+/**
+* Executes one authorised circuit call against a deployed Account Custody
+* Contract: resolves the device's current use counter from the ledger,
+* has the authoriser sign the call over the observed auth nonce, submits
+* the circuit with the authorising material appended as its trailing
+* arguments (pk, use counter, announcement, closing scalar, grind nonce),
+* and returns the counter the device holds after the accepted call: the
+* consumed one plus one.
+*
+* A transaction that lands with a failing status rejects instead of
+* returning: the contract applied nothing, so no counter may advance and
+* no roster change may be recorded for it.
+*/
+const executeGatedCall = async ({ handle, authoriser, circuit, args, address, ledgerState, knownUseCounter }) => {
+	const call = handle.callTx[circuit];
+	if (!call) throw new Error(`Account contract handle has no circuit '${circuit}'`);
+	const { useCounter } = await resolveUseCounter({
+		ledgerState,
+		authoriser,
+		address,
+		knownUseCounter
+	});
+	const authorisation = await authoriser.authorise({
+		account: address,
+		circuit,
+		args,
+		witnessValues: [],
+		authNonce: ledgerState.auth_nonce,
+		useCounter
+	});
+	const finalized = await submitWithDustRetry(async () => call(...args, ...authArgs(authorisation)));
+	assertSubmitted(`Call to ${circuit}`, finalized);
+	return UseCounter(useCounter + 1n);
+};
+//#endregion
+export { loadVerifierKeys as a, submitMaintenanceUpdate as c, UseCounter as d, deployAccount as i, planInstallWaves as l, executeGatedCall as n, readMaintenanceAuthority as o, resolveUseCounter as r, resumeAccountDeployment as s, connectAccountHandle as t, DeviceEpoch as u };