@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/submit-DOv8Z0Vf.js

@@ -0,0 +1,336 @@
+import { n as HexBytes } from "./bytes.vo-BB7_4JK6.js";
+import { D as MaintenanceUpdateRefusedError, E as MaintenanceAuthorityMismatchError, L as sha256 } from "./errors-DSq5wUwt.js";
+import { t as GRANTEE_WITHDRAWAL_CIRCUITS } from "./grant-circuits-Jxb5y1HW.js";
+//#region ../../packages/module/passport-account/src/acc/deployed-operations.ts
+/** Every impure circuit of the jubjub arm, activation included. */
+const JUBJUB_ARM_CIRCUITS = ["activate_initial_device", ...[
+	"withdraw_unshielded",
+	"append_inbox",
+	"withdraw_shielded",
+	"withdraw_shielded_to_contract",
+	"rotate_enc_key",
+	"add_device",
+	"remove_device"
+]].map((base) => `${base}_with_jubjub`);
+/** Permissionless deposit circuits shared by all arms. */
+const SHARED_CIRCUITS = ["deposit_unshielded", "deposit_shielded"];
+/**
+* The scoped grant circuits: the lifecycle a jubjub device authorises,
+* then the withdrawals of a jubjub grantee and of a secp256k1 grantee.
+*/
+const GRANT_CIRCUITS = [
+	...[
+		"issue_grant",
+		"revoke_grant",
+		"revoke_all_grants"
+	].map((base) => `${base}_with_jubjub`),
+	...GRANTEE_WITHDRAWAL_CIRCUITS["jubjub-schnorr"],
+	...GRANTEE_WITHDRAWAL_CIRCUITS["secp256k1-ecdsa"]
+];
+/**
+* The complete operation set this module deploys, in installation order:
+* the deposits, the jubjub device arm and the grant circuits. The device
+* arm is jubjub only: the compiled contract also carries k256 and P-256
+* device arms, their grant lifecycles and the recovery circuits, and none
+* of their verifier keys are installed, so on an account deployed here
+* only jubjub devices can ever authorise. A grant may name a jubjub or a
+* secp256k1 grantee, so the withdrawals of both grantee arms are
+* installed.
+*/
+const DEPLOYED_OPERATIONS = [
+	...SHARED_CIRCUITS,
+	...JUBJUB_ARM_CIRCUITS,
+	...GRANT_CIRCUITS
+];
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/verifier-key-insert.ts
+/**
+* The operation version the vendored contract's verifier keys belong to.
+* The compiler this module pins emits keys under the v7 header, which the
+* ledger files under operation version 'v4'; the midnight-js maintenance
+* helpers still assume 'v3' and refuse these keys before a transaction
+* exists, so the insert is built against the ledger directly.
+*/
+const VERIFIER_KEY_OPERATION_VERSION = "v4";
+/** The header every verifier key of the pinned compiler starts with. */
+const VERIFIER_KEY_HEADER = "midnight:verifier-key[v7]:";
+const headerOf = (verifierKey) => new TextDecoder().decode(verifierKey.subarray(0, 26));
+/**
+* Refuses a verifier key under any other header, naming the operation.
+* The ledger would refuse it too, but only once a transaction is being
+* built, after the key has been downloaded and a wave planned around it.
+*/
+const assertVerifierKeyHeader = (operation, verifierKey) => {
+	const header = headerOf(verifierKey);
+	if (header !== VERIFIER_KEY_HEADER) throw new Error(`The verifier key of '${operation}' is not a ${VERIFIER_KEY_HEADER} key, got '${header}'`);
+};
+/**
+* The maintenance update entry that installs one operation's verifier
+* key under the operation version the pinned compiler's keys belong to.
+*/
+const verifierKeyInsert = (ledger, operation, verifierKey) => {
+	assertVerifierKeyHeader(operation, verifierKey);
+	return new ledger.VerifierKeyInsert(operation, new ledger.ContractOperationVersionedVerifierKey(VERIFIER_KEY_OPERATION_VERSION, verifierKey));
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/maintenance-authority.ts
+/**
+* HKDF info of the maintenance authority secret a roster key derives. No
+* account address enters the derivation: the roster key is already
+* unique per account and is drawn before the address exists.
+*/
+const AUTHORITY_SECRET_INFO = new TextEncoder().encode("lace-passport:cma:v1");
+/** Byte length of a BIP-340 secret key. */
+const AUTHORITY_SECRET_LENGTH = 32;
+/** Loads the ledger on first use, so a host that never signs an update never loads it. */
+const loadMaintenanceLedger = async () => import("@midnightntwrk/ledger-v9");
+/**
+* The 32-byte authority secret HKDF-SHA256 derives from a roster key with
+* an empty salt. The caller owns the bytes and zeroes them.
+*/
+const deriveAuthoritySecret = async (rosterKey) => {
+	const material = await crypto.subtle.importKey("raw", rosterKey, "HKDF", false, ["deriveBits"]);
+	return new Uint8Array(await crypto.subtle.deriveBits({
+		name: "HKDF",
+		hash: "SHA-256",
+		salt: new Uint8Array(0),
+		info: AUTHORITY_SECRET_INFO
+	}, material, AUTHORITY_SECRET_LENGTH * 8));
+};
+/**
+* The ledger signing key over an authority secret.
+*
+* @throws when the secret is not a valid BIP-340 secret key, which a
+* uniform 32-byte secret is only with negligible probability.
+*/
+const signingKeyOf = (ledger, secret) => {
+	try {
+		return ledger.signingKeyFromBip340(secret);
+	} catch {
+		throw new Error("The maintenance authority secret a roster key derives is not a valid BIP-340 secret key.");
+	}
+};
+/**
+* Calls `run` with the Schnorr signing key of the maintenance authority a
+* roster key derives. The derived secret is zeroed before this settles,
+* on success and failure alike; the ledger signing key holds it as a hex
+* string and in wasm memory, which the ledger API cannot zero. `run` must
+* not retain the key.
+*/
+const withAuthorityKey = async (ledger, rosterKey, run) => {
+	const secret = await deriveAuthoritySecret(rosterKey);
+	try {
+		return run(signingKeyOf(ledger, secret));
+	} finally {
+		secret.fill(0);
+	}
+};
+/** The verifying key of the maintenance authority a roster key derives. */
+const authorityOf = async (ledger, rosterKey) => withAuthorityKey(ledger, rosterKey, (key) => {
+	const { tag, value } = ledger.signatureVerifyingKey(key);
+	return {
+		tag,
+		value
+	};
+});
+/** Whether two verifying keys are the same key of the same kind. */
+const isSameAuthority = (left, right) => left.tag === right.tag && left.value === right.value;
+/**
+* Holds one verifier key to the one the module pins for its operation:
+* the operation must be in the deployed roster, the key's sha256 must be
+* its pin and the key must carry the pinned compiler's header. The pins
+* cover every compiled circuit, recovery and other device arms included,
+* so the roster is what keeps an install to the operations this module
+* deploys.
+*
+* @throws {@link MaintenanceUpdateRefusedError} for an operation outside
+* the roster or without a pin, a key whose digest is not the pin, or a key
+* under another header.
+*/
+const assertPinnedVerifierKey = (pins, { operation, verifierKey }) => {
+	if (!DEPLOYED_OPERATIONS.includes(operation)) throw new MaintenanceUpdateRefusedError(`'${operation}' is not an operation this module deploys.`);
+	const pin = pins[operation];
+	if (!pin) throw new MaintenanceUpdateRefusedError(`No verifier key is pinned for '${operation}'.`);
+	if (HexBytes.fromByteArray(sha256(verifierKey)) !== pin) throw new MaintenanceUpdateRefusedError(`The verifier key of '${operation}' is not the pinned one.`);
+	try {
+		assertVerifierKeyHeader(operation, verifierKey);
+	} catch (error) {
+		throw new MaintenanceUpdateRefusedError(error.message);
+	}
+};
+/**
+* A copy of `changes` the caller no longer owns, so the values checked
+* are exactly the values signed.
+*/
+const copyOfChanges = (changes) => changes.kind === "replace-authority" ? {
+	kind: "replace-authority",
+	authority: {
+		tag: changes.authority.tag,
+		value: changes.authority.value
+	}
+} : {
+	kind: "insert-verifier-keys",
+	inserts: changes.inserts.map(({ operation, verifierKey }) => ({
+		operation,
+		verifierKey: verifierKey.slice()
+	}))
+};
+/**
+* Copies the changes of a maintenance update and holds the copy to what
+* the encryption key signs before any key is opened: a verifier key
+* install names at least one key and every key is the pinned one for an
+* operation of the deployed roster. A replace is held to the live roster
+* key once the keyring is open. The copy is what must be signed.
+*
+* @throws {@link MaintenanceUpdateRefusedError} when the changes are not
+* signable.
+*/
+const signableChanges = async (changes) => {
+	const copy = copyOfChanges(changes);
+	if (copy.kind === "replace-authority") return copy;
+	if (copy.inserts.length === 0) throw new MaintenanceUpdateRefusedError("A maintenance update must install at least one verifier key.");
+	const { expectedVk } = await import("./acc-module-Cmj8EsIb.js").then((n) => n.n);
+	for (const insert of copy.inserts) assertPinnedVerifierKey(expectedVk, insert);
+	return copy;
+};
+/**
+* The ledger maintenance update `changes` describes against the account
+* at `address` and the on-chain `counter`. A replace installs its
+* authority as the sole member of a one-of-one committee under the next
+* counter. Every flow that submits a signed update rebuilds it here, so
+* it submits exactly the update that was signed.
+*/
+const maintenanceUpdateOf = (ledger, { address, counter, changes }) => new ledger.MaintenanceUpdate(address, changes.kind === "insert-verifier-keys" ? changes.inserts.map(({ operation, verifierKey }) => verifierKeyInsert(ledger, operation, verifierKey)) : [new ledger.ReplaceAuthority(new ledger.ContractMaintenanceAuthority([changes.authority], 1, counter + 1n))], counter);
+/** The first of `rosterKeys` whose derived authority is `authority`, if any. */
+const findRosterKey = async (ledger, rosterKeys, authority) => {
+	for (const rosterKey of rosterKeys) if (isSameAuthority(await authorityOf(ledger, rosterKey), authority)) return rosterKey;
+};
+/**
+* The first of `rosterKeys` whose derived authority is `authority`.
+*
+* @throws {@link MaintenanceAuthorityMismatchError} when none is.
+*/
+const rosterKeyOf = async (ledger, rosterKeys, authority) => {
+	const rosterKey = await findRosterKey(ledger, rosterKeys, authority);
+	if (!rosterKey) throw new MaintenanceAuthorityMismatchError();
+	return rosterKey;
+};
+/** Whether any of `rosterKeys` derives the maintenance authority `authority`. */
+const derivesAuthority = async (ledger, rosterKeys, authority) => await findRosterKey(ledger, rosterKeys, authority) !== void 0;
+/**
+* The authority a replace installs: the one the live roster key derives,
+* which the replace must name.
+*
+* @throws {@link MaintenanceUpdateRefusedError} when it names another.
+*/
+const replacementOf = async (ledger, liveRosterKey, named) => {
+	const live = await authorityOf(ledger, liveRosterKey);
+	if (!isSameAuthority(live, named)) throw new MaintenanceUpdateRefusedError("A replace may only install the authority the live roster key derives.");
+	return live;
+};
+/** Signs the data of `update` with the authority `rosterKey` derives. */
+const signUpdate = async (ledger, rosterKey, update) => withAuthorityKey(ledger, rosterKey, (key) => {
+	const { tag, value } = ledger.signData(key, update.dataToSign);
+	return {
+		tag,
+		value
+	};
+});
+/**
+* Builds the maintenance update `changes` describes with
+* {@link maintenanceUpdateOf} and signs its data with the authority one
+* of `rosterKeys`, the live one first, derives when that authority is the
+* on-chain `authority`. A replace may install only the authority the live
+* roster key derives. The update is built here and never taken as bytes,
+* so the authority signs nothing but the changes it was asked for. The
+* changes must be the copy {@link signableChanges} answered.
+*
+* @throws {@link MaintenanceAuthorityMismatchError} when no roster key
+* derives the on-chain authority.
+* @throws {@link MaintenanceUpdateRefusedError} when a replace names
+* another authority than the live roster key's.
+*/
+const signMaintenanceUpdate = async (ledger, { address, rosterKeys, authority, counter, changes }) => {
+	const signer = await rosterKeyOf(ledger, rosterKeys, authority);
+	const installed = changes.kind === "replace-authority" ? await replacementOf(ledger, rosterKeys[0], changes.authority) : void 0;
+	const signature = await signUpdate(ledger, signer, maintenanceUpdateOf(ledger, {
+		address,
+		counter,
+		changes
+	}));
+	return installed ? {
+		signature,
+		authority: installed
+	} : { signature };
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/submit.ts
+const defaultSleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* Node rejections caused by the wallet's dust view lagging the chain: a
+* transaction built before the previous one landed can reuse a dust
+* nullifier (DustDoubleSpend) or emit an empty dust action set
+* (NotNormalized), and the node rejects it at submission.
+*/
+const DUST_RACE_PATTERN = /SubmissionError|Invalid Transaction|DustDoubleSpend|NotNormalized/;
+const errorText = (error) => error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+/**
+* Whether an error reports the verdict of a transaction that reached the
+* chain. midnight-js raises these carrying the finalized data, and builds
+* the message out of it, so the message can quote node text that reads
+* like a dust-race rejection. Such a submission consumed its
+* authorisation, so it must never be resubmitted whatever it says.
+*/
+const isFinalizedVerdict = (error) => typeof error === "object" && error !== null && "finalizedTxData" in error;
+/**
+* Runs a submission with a dust-race retry. A submission the node rejects
+* changes no chain state and invalidates no signed authorisation, so
+* waiting for the wallet's dust view to catch up and resubmitting is
+* sound. Only the documented dust-race rejections are retried; any other
+* error, or a dust race persisting past the retry budget, is rethrown.
+*/
+const submitWithDustRetry = async (submit, { sleep = defaultSleep, maxRetries = 3, retryDelayMs = 1e4 } = {}) => {
+	for (let attempt = 0;; attempt++) try {
+		return await submit();
+	} catch (error) {
+		if (!(!isFinalizedVerdict(error) && DUST_RACE_PATTERN.test(errorText(error))) || attempt >= maxRetries) throw error;
+		await sleep(retryDelayMs);
+	}
+};
+const defaultSubmit = async () => {
+	return (await import("@midnight-ntwrk/midnight-js-contracts")).submitTx;
+};
+/**
+* Submits an unproven deployment or call transaction through midnight-js,
+* wrapped in {@link submitWithDustRetry} so dust-race rejections rebuild
+* and resubmit instead of failing the flow.
+*/
+const submitTx = async (providers, options, config = {}) => {
+	const { submit, ...retryOptions } = config;
+	const run = submit ?? await defaultSubmit();
+	return submitWithDustRetry(async () => run(providers, options), retryOptions);
+};
+const finalizedStatus = (finalized) => {
+	const data = finalized;
+	return data?.public?.status ?? data?.status;
+};
+/**
+* Rejects a transaction that landed with a failing status. Such a
+* submission resolves, but the circuit's effects were discarded, so
+* nothing the call was meant to advance may be treated as done. A
+* submission carrying no status is accepted: absence is not a failure
+* verdict.
+*
+* Throwing here happens after {@link submitWithDustRetry} has resolved,
+* and the message matches none of the dust-race patterns, so a status
+* failure is never resubmitted: the transaction reached the chain, and a
+* rebuild could present an authorisation the contract has consumed.
+*/
+const assertSubmitted = (label, finalized) => {
+	const status = finalizedStatus(finalized);
+	if (String(status).toLowerCase().includes("fail")) throw new Error(`${label} failed: ${JSON.stringify(status)}`);
+};
+//#endregion
+export { derivesAuthority as a, maintenanceUpdateOf as c, assertVerifierKeyHeader as d, verifierKeyInsert as f, authorityOf as i, signMaintenanceUpdate as l, submitTx as n, isSameAuthority as o, DEPLOYED_OPERATIONS as p, submitWithDustRetry as r, loadMaintenanceLedger as s, assertSubmitted as t, signableChanges as u };