@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/pending-operation-B0_P78Jo.cjs

@@ -0,0 +1,26 @@
+//#region ../../packages/contract/cardano-context/src/custody/pending-operation.ts
+const isCustodyStatus = (value) => value === "pending" || value === "outcome-unknown";
+/**
+* The custody metadata of a pending activity; absent on any other activity,
+* and on one whose custody entry has no validity bound. A field the entry
+* holds in another shape than the wallet writes is left out.
+*/
+const cardanoCustodyActivityMetadataOf = (activity) => {
+	const custody = activity.blockchainSpecific?.Cardano?.custody;
+	if (typeof custody !== "object" || custody === null) return void 0;
+	const { invalidHereafter, operation, status, reference } = custody;
+	if (typeof invalidHereafter !== "number") return void 0;
+	return {
+		invalidHereafter,
+		...typeof operation === "string" && { operation },
+		...isCustodyStatus(status) && { status },
+		...typeof reference === "string" && { reference }
+	};
+};
+//#endregion
+Object.defineProperty(exports, "cardanoCustodyActivityMetadataOf", {
+	enumerable: true,
+	get: function() {
+		return cardanoCustodyActivityMetadataOf;
+	}
+});

package/dist/pending-operation-BIS6mpjB.js

@@ -0,0 +1,21 @@
+//#region ../../packages/contract/cardano-context/src/custody/pending-operation.ts
+const isCustodyStatus = (value) => value === "pending" || value === "outcome-unknown";
+/**
+* The custody metadata of a pending activity; absent on any other activity,
+* and on one whose custody entry has no validity bound. A field the entry
+* holds in another shape than the wallet writes is left out.
+*/
+const cardanoCustodyActivityMetadataOf = (activity) => {
+	const custody = activity.blockchainSpecific?.Cardano?.custody;
+	if (typeof custody !== "object" || custody === null) return void 0;
+	const { invalidHereafter, operation, status, reference } = custody;
+	if (typeof invalidHereafter !== "number") return void 0;
+	return {
+		invalidHereafter,
+		...typeof operation === "string" && { operation },
+		...isCustodyStatus(status) && { status },
+		...typeof reference === "string" && { reference }
+	};
+};
+//#endregion
+export { cardanoCustodyActivityMetadataOf as t };

package/dist/providers-FjhM47BH.cjs

@@ -0,0 +1,388 @@
+const require_errors = require("./errors-BIftM8ZN.cjs");
+const require_artefact_loader = require("./artefact-loader-BWWYAD7E.cjs");
+//#region ../../packages/contract/passport/src/value-objects/acc-address.vo.ts
+/** Types a string as an Account Custody Contract address. It checks nothing. */
+const AccAddress = (value) => value;
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/network-id.ts
+/**
+* Applies the Midnight network id the rest of the Midnight libraries read
+* from module-global state. Address formats and transaction binding depend
+* on it, and every wallet or contract operation throws until it is set, so
+* each entry point into a chain flow applies it before doing any work.
+* Setting the same id again is harmless; a different id replaces the
+* previous one, which is why one network config owns the value.
+*/
+const applyNetworkId = async (networkId) => {
+	const { setNetworkId } = await import("@midnight-ntwrk/midnight-js-network-id");
+	setNetworkId(networkId);
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/http-prover.ts
+/**
+* Thrown when the proof server rejects a request or does not answer before
+* the timeout. `status` carries the HTTP status code of the final response;
+* it is undefined when the request timed out before any response arrived.
+*/
+var ProofServerError = class extends Error {
+	code = "proof-server";
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "ProofServerError";
+	}
+};
+/**
+* Thrown when the ledger asks for the circuit of a contract the client holds
+* no key material for, for example a contract the account's circuits call.
+* Without it the proof server would receive the request with no circuit IR
+* and answer a bare 400.
+*/
+var UnresolvedContractCircuitError = class extends Error {
+	code = "unresolved-contract-circuit";
+	constructor(contractAddress, circuit, verifierKeyHash) {
+		super(`No key material for circuit "${circuit}" of contract ${contractAddress}${verifierKeyHash === void 0 ? "" : ` (vk=${verifierKeyHash})`}: the prover only resolves the Account Custody Contract circuits listed in its manifest.`);
+		this.contractAddress = contractAddress;
+		this.circuit = circuit;
+		this.verifierKeyHash = verifierKeyHash;
+		this.name = "UnresolvedContractCircuitError";
+	}
+};
+/**
+* Canonical contract key location: `contract:<address>/<circuit>?vk=<hash>`.
+* The ledger stamps every contract call's proof preimage with this form;
+* the vk query pin is the sha256 of the verifier key the chain expects.
+*/
+const CANONICAL_KEY_LOCATION = /^contract:([0-9a-f]+)\/([^?]+)(?:\?vk=([0-9a-f]+))?$/;
+/**
+* The default {@link KeyMaterialResolver}: maps a key location onto the
+* Account Custody Contract manifest and downloads that circuit's prover
+* key, verifier key, and IR through {@link loadCircuitAssets}, so every
+* byte is verified against the manifest's sha256 pins. Canonical contract
+* locations resolve by circuit name, and their embedded vk pin must match
+* the manifest's, so proving against a drifted artefact fails before the
+* proof server is asked. A canonical contract location whose circuit the
+* manifest does not list, such as a circuit of a contract the account
+* calls, throws {@link UnresolvedContractCircuitError}. Any other unlisted location
+* resolves to undefined (a protocol builtin the proof server supplies
+* itself).
+*/
+const createManifestKeyMaterialResolver = ({ artefactUrl, fetchBytes, manifest = require_artefact_loader.accManifest }) => {
+	const entries = Object.values(manifest.circuits);
+	return async (keyLocation) => {
+		const canonical = CANONICAL_KEY_LOCATION.exec(keyLocation);
+		const circuitName = canonical ? canonical[2] : keyLocation;
+		const vkPin = canonical?.[3];
+		const entry = entries.find((candidate) => candidate.keyLocation === keyLocation || candidate.name === circuitName);
+		if (!entry) {
+			if (canonical) throw new UnresolvedContractCircuitError(canonical[1], canonical[2], vkPin);
+			return;
+		}
+		if (vkPin !== void 0 && vkPin !== entry.verifierKeySha256) throw new require_errors.ArtefactIntegrityError(`verifier key pin mismatch for ${entry.name}: the chain expects ${vkPin}, the manifest pins ${entry.verifierKeySha256}`);
+		const assets = await require_artefact_loader.loadCircuitAssets({
+			artefactUrl,
+			circuit: entry.name,
+			fetchBytes,
+			manifest
+		});
+		return {
+			proverKey: assets.proverKey,
+			verifierKey: assets.verifierKey,
+			ir: assets.zkir
+		};
+	};
+};
+/** Proving a circuit call can legitimately take minutes on large circuits. */
+const TIMEOUT_MS = 3e5;
+/** A 500/503 is transient (proof server busy or restarting); one retry. */
+const RETRYABLE_STATUSES = new Set([500, 503]);
+const defaultFetchBytes$1 = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+/**
+* A {@link PassportProver} over the Midnight proof server's HTTP API,
+* wire-compatible with the stock midnight-js client: the key location is
+* resolved client-side to the circuit's key material (prover key and IR),
+* the serialized preimage plus that material is framed with the protocol
+* payload codecs, and the framed bytes are POSTed to /prove and /check as
+* application/octet-stream with nothing else. A location the resolver
+* does not know travels without key material; the proof server supplies
+* the protocol builtin keys itself. The protocol codec loads lazily so
+* platforms only pay for it when a proof is actually requested.
+*
+* @param baseUrl - The proof server's URL; requests go to `<baseUrl>/prove`
+*   and `<baseUrl>/check`.
+* @param options - Where key material comes from, and the transports. It
+*   throws without `resolveKeyMaterial` or an `artefactUrl`.
+*/
+const createHttpProver = (baseUrl, options = {}) => {
+	const fetchHttp = options.fetchHttp ?? globalThis.fetch;
+	const resolveKeyMaterial = options.resolveKeyMaterial ?? (options.artefactUrl === void 0 ? void 0 : createManifestKeyMaterialResolver({
+		artefactUrl: options.artefactUrl,
+		fetchBytes: options.fetchBytes ?? defaultFetchBytes$1
+	}));
+	if (!resolveKeyMaterial) throw new Error("createHttpProver needs resolveKeyMaterial or an artefactUrl for the default manifest resolver.");
+	const base = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+	const loadPayloadCodec = async () => import("@midnight-ntwrk/midnight-js-protocol/ledger");
+	const request = async (url, payload) => {
+		const controller = new AbortController();
+		const timer = setTimeout(() => {
+			controller.abort();
+		}, TIMEOUT_MS);
+		try {
+			return await fetchHttp(url, {
+				method: "POST",
+				headers: { "Content-Type": "application/octet-stream" },
+				body: payload,
+				signal: controller.signal
+			});
+		} catch (error) {
+			if (controller.signal.aborted) throw new ProofServerError(`Proof server request timed out after ${TIMEOUT_MS}ms: ${url}`);
+			throw error;
+		} finally {
+			clearTimeout(timer);
+		}
+	};
+	const post = async (path, payload) => {
+		const url = `${base}${path}`;
+		for (let attempt = 0;; attempt++) {
+			const response = await request(url, payload);
+			if (response.ok) return new Uint8Array(await response.arrayBuffer());
+			if (attempt === 0 && RETRYABLE_STATUSES.has(response.status)) continue;
+			throw new ProofServerError(`Proof server request failed: url="${url}", status="${response.status} ${response.statusText}"`, response.status);
+		}
+	};
+	return {
+		prove: async (preimage, keyLocation, overwriteBindingInput) => {
+			const [{ createProvingPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
+			return post("/prove", createProvingPayload(preimage, overwriteBindingInput, keyMaterial));
+		},
+		check: async (preimage, keyLocation) => {
+			const [{ createCheckPayload }, keyMaterial] = await Promise.all([loadPayloadCodec(), resolveKeyMaterial(keyLocation)]);
+			return post("/check", createCheckPayload(preimage, keyMaterial?.ir));
+		}
+	};
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/infra/providers.ts
+/**
+* The ledger era every provider seam serves. The framework reads it before
+* an operation starts and refuses a provider set that cannot carry a
+* transaction end to end, so a mismatch fails before any proof is paid for.
+*/
+const SERVED_ERAS = ["v9"];
+const v9 = (tx) => ({
+	version: "v9",
+	tx
+});
+const ZSWAP_SEED_LENGTH = 32;
+const defaultRandomBytes = (length) => crypto.getRandomValues(new Uint8Array(length));
+const defaultFetchBytes = async (url) => {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Artefact download failed: url="${url}", status="${response.status} ${response.statusText}"`);
+	return new Uint8Array(await response.arrayBuffer());
+};
+/**
+* In-memory {@link AccProviders}.privateStateProvider. The account private
+* state only needs to outlive one deploy-and-activate flow, so nothing is
+* written to disk; contract-address scoping is a no-op because each flow
+* gets its own provider instance.
+*/
+const createInMemoryPrivateStateProvider = () => {
+	const privateStates = /* @__PURE__ */ new Map();
+	const signingKeys = /* @__PURE__ */ new Map();
+	return {
+		setContractAddress: (_address) => void 0,
+		set: async (privateStateId, state) => {
+			privateStates.set(privateStateId, state);
+		},
+		get: async (privateStateId) => privateStates.get(privateStateId) ?? null,
+		remove: async (privateStateId) => {
+			privateStates.delete(privateStateId);
+		},
+		clear: async () => {
+			privateStates.clear();
+		},
+		setSigningKey: async (address, key) => {
+			signingKeys.set(address, key);
+		},
+		getSigningKey: async (address) => signingKeys.get(address) ?? null,
+		removeSigningKey: async (address) => {
+			signingKeys.delete(address);
+		},
+		clearSigningKeys: async () => {
+			signingKeys.clear();
+		}
+	};
+};
+/**
+* Assembles the midnight-js providers {@link deployAccount} runs through,
+* swapping the platform seams in where the stock providers would expect a
+* full wallet:
+*
+* - zkConfigProvider downloads ZK assets through {@link loadCircuitAssets},
+*   so every byte is verified against the manifest's sha256 pins. A
+*   verifier key asked for alone is downloaded alone, so deploying an
+*   account fetches no prover key it does not prove with. A circuit this
+*   module never proves, such as a secp256k1 grant withdrawal, has no
+*   manifest entry: its verifier key asked for alone is verified against
+*   the contract's own expected pin, and it is skipped when verifier keys
+*   are listed.
+* - proofProvider adapts the {@link PassportProver} to the ledger's
+*   circuit-level proving interface.
+* - walletProvider delegates balancing to the {@link FeeSponsor}; the user
+*   holds no tokens, so the sponsor covers every fee. Its Zswap keys are
+*   ephemeral, generated per flow: the transactions move no coins, the
+*   keys only satisfy transaction construction and are discarded with the
+*   providers.
+* - midnightProvider submits each finalized transaction over the node RPC
+*   relay, opening and closing a connection per submission.
+*
+* `onStage` reports the proving and sponsoring stages as they start, so
+* the caller can surface flow progress that otherwise happens inside
+* midnight-js calls.
+*/
+const createMidnightProviders = async ({ network, prover, sponsor, fetchBytes = defaultFetchBytes, manifest = require_artefact_loader.accManifest, onStage, randomBytes = defaultRandomBytes, createPublicDataProvider, createSubmissionService }) => {
+	await applyNetworkId(network.networkId);
+	const ledger = await import("@midnightntwrk/ledger-v9");
+	const zswapKeys = ledger.ZswapSecretKeys.fromSeed(randomBytes(ZSWAP_SEED_LENGTH));
+	const coinPublicKey = zswapKeys.coinPublicKey;
+	const encryptionPublicKey = zswapKeys.encryptionPublicKey;
+	zswapKeys.clear();
+	const assetCache = /* @__PURE__ */ new Map();
+	const circuitAssets = async (circuit) => {
+		let assets = assetCache.get(circuit);
+		if (!assets) {
+			assets = require_artefact_loader.loadCircuitAssets({
+				artefactUrl: network.artefactUrl,
+				circuit,
+				fetchBytes,
+				manifest
+			});
+			assetCache.set(circuit, assets);
+		}
+		return assets;
+	};
+	const isPinnedCircuit = (circuitId) => circuitId in manifest.circuits;
+	const verifierKeyCache = /* @__PURE__ */ new Map();
+	const verifierKeyPin = async (circuitId) => {
+		if (isPinnedCircuit(circuitId)) return manifest.circuits[circuitId].verifierKeySha256;
+		const { expectedVk } = await Promise.resolve().then(() => require("./acc-module-4iIUv6My.cjs")).then((n) => n.acc_module_exports);
+		const expectedSha256 = expectedVk[circuitId];
+		if (!expectedSha256) throw new require_artefact_loader.UnknownCircuitError(circuitId);
+		return expectedSha256;
+	};
+	const verifierKey = async (circuitId) => {
+		const cachedAssets = isPinnedCircuit(circuitId) ? assetCache.get(circuitId) : void 0;
+		if (cachedAssets) return (await cachedAssets).verifierKey;
+		let key = verifierKeyCache.get(circuitId);
+		if (!key) {
+			key = (async () => {
+				const expectedSha256 = await verifierKeyPin(circuitId);
+				return require_artefact_loader.loadVerifierKey({
+					artefactUrl: network.artefactUrl,
+					circuit: circuitId,
+					fetchBytes,
+					expectedSha256
+				});
+			})();
+			verifierKeyCache.set(circuitId, key);
+		}
+		return key;
+	};
+	const zkConfigProvider = {
+		getZKIR: async (circuitId) => (await circuitAssets(circuitId)).zkir,
+		getProverKey: async (circuitId) => (await circuitAssets(circuitId)).proverKey,
+		getVerifierKey: async (circuitId) => verifierKey(circuitId),
+		getVerifierKeys: async (circuitIds) => Promise.all(circuitIds.filter((circuitId) => isPinnedCircuit(circuitId)).map(async (circuitId) => [circuitId, await verifierKey(circuitId)])),
+		get: async (circuitId) => ({
+			circuitId,
+			...await circuitAssets(circuitId)
+		})
+	};
+	const resolveKeyMaterial = createManifestKeyMaterialResolver({
+		artefactUrl: network.artefactUrl,
+		fetchBytes,
+		manifest
+	});
+	const provingProvider = {
+		prove: async (preimage, keyLocation, overwriteBindingInput) => prover.prove(preimage, keyLocation, overwriteBindingInput),
+		check: async (preimage, keyLocation) => ledger.parseCheckResult(await prover.check(preimage, keyLocation)),
+		lookupKey: async (keyLocation) => resolveKeyMaterial(keyLocation)
+	};
+	const proofProvider = {
+		supportedEras: SERVED_ERAS,
+		proveTx: async ({ tx }) => {
+			onStage?.("proving");
+			return v9(await tx.prove(provingProvider, ledger.CostModel.initialCostModel()));
+		}
+	};
+	const walletProvider = {
+		supportedEras: SERVED_ERAS,
+		getCoinPublicKey: () => coinPublicKey,
+		getEncryptionPublicKey: () => encryptionPublicKey,
+		balanceTx: async ({ tx }) => {
+			onStage?.("sponsoring");
+			const balanced = await sponsor.balanceAndSign(tx.serialize());
+			return v9(ledger.Transaction.deserialize("signature", "proof", "binding", balanced));
+		}
+	};
+	const defaultSubmissionService = async () => {
+		const { createNodeRelaySubmissionService } = await Promise.resolve().then(() => require("./node-relay-DWe1U0w2.cjs"));
+		return createNodeRelaySubmissionService(network.nodeUrl);
+	};
+	const midnightProvider = {
+		supportedEras: SERVED_ERAS,
+		submitTx: async ({ tx }) => {
+			const service = await (createSubmissionService ?? defaultSubmissionService)();
+			try {
+				await service.submitTransaction(tx, "InBlock");
+				return tx.identifiers().at(-1);
+			} finally {
+				await service.close();
+			}
+		}
+	};
+	const defaultPublicDataProvider = async () => {
+		const { indexerPublicDataProvider } = await import("@midnight-ntwrk/midnight-js-indexer-public-data-provider");
+		return indexerPublicDataProvider({
+			queryURL: network.indexerUrl,
+			subscriptionURL: network.indexerWsUrl
+		});
+	};
+	return {
+		publicDataProvider: await (createPublicDataProvider ?? defaultPublicDataProvider)(),
+		zkConfigProvider,
+		proofProvider,
+		privateStateProvider: createInMemoryPrivateStateProvider(),
+		walletProvider,
+		midnightProvider
+	};
+};
+//#endregion
+Object.defineProperty(exports, "AccAddress", {
+	enumerable: true,
+	get: function() {
+		return AccAddress;
+	}
+});
+Object.defineProperty(exports, "applyNetworkId", {
+	enumerable: true,
+	get: function() {
+		return applyNetworkId;
+	}
+});
+Object.defineProperty(exports, "createHttpProver", {
+	enumerable: true,
+	get: function() {
+		return createHttpProver;
+	}
+});
+Object.defineProperty(exports, "createMidnightProviders", {
+	enumerable: true,
+	get: function() {
+		return createMidnightProviders;
+	}
+});