@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/{slice-oqm_r1cS.cjs → slice-DnG-yvpI.cjs}

@@ -1,6 +1,6 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_slice = require("./slice-D11FHQuQ.cjs");
-const require_feature_flag_key_vo = require("./feature-flag-key.vo-BPz-ZAp6.cjs");
+const require_slice = require("./slice-BiRsDKOK.cjs");
+const require_feature_flag_key_vo = require("./feature-flag-key.vo-RlfHL3hq.cjs");
 let _reduxjs_toolkit = require("@reduxjs/toolkit");
 //#region ../../packages/contract/analytics/src/const.ts
 /**

package/dist/{slice-BNu73oBa.js → slice-DyNs7oWp.js}

@@ -1,5 +1,5 @@
-import { r as featuresSelectors } from "./slice-Be7hj4Iy.js";
-import { t as FeatureFlagKey } from "./feature-flag-key.vo-ofrB6ZVQ.js";
+import { r as featuresSelectors } from "./slice-Bk0Sv05J.js";
+import { t as FeatureFlagKey } from "./feature-flag-key.vo-DN_-4-sG.js";
 import { createAction, createSelector, createSlice } from "@reduxjs/toolkit";
 //#region ../../packages/contract/analytics/src/const.ts
 /**

package/dist/{slice-CB4SnzMm.js → slice-GwiiJRoq.js}

@@ -1,6 +1,6 @@
-import { n as markParameterizedSelector } from "./util-selector-CcK-GAdE.js";
-import { r as featuresSelectors } from "./slice-Be7hj4Iy.js";
-import { t as FeatureFlagKey } from "./feature-flag-key.vo-ofrB6ZVQ.js";
+import { n as markParameterizedSelector } from "./util-selector-BSTsxgne.js";
+import { r as featuresSelectors } from "./slice-Bk0Sv05J.js";
+import { t as FeatureFlagKey } from "./feature-flag-key.vo-DN_-4-sG.js";
 import { createSelector, createSlice } from "@reduxjs/toolkit";
 //#region ../../packages/contract/network/src/value-objects/feature-id.vo.ts
 const FeatureId = (value) => value;

package/dist/slice-oWnc7YVD.js

@@ -0,0 +1,412 @@
+import { n as markParameterizedSelector } from "./util-selector-BSTsxgne.js";
+import { r as featuresSelectors } from "./slice-Bk0Sv05J.js";
+import { i as networkSelectors } from "./slice-GwiiJRoq.js";
+import { t as Serializable } from "./serializable-BHdKIgk3.js";
+import { S as isSameProofServerMode, _ as REMOTE_PROOF_SERVER_MODES, a as FEATURE_FLAG_MIDNIGHT_REMOTE_PROOF_SERVER, b as defaultLocalProofServerMode, g as MidnightNetworkId, i as FEATURE_FLAG_MIDNIGHT_NODE_URLS, n as EMPTY_PARTIAL_NETWORKS_CONFIG, o as FEATURE_FLAG_MIDNIGHT_TEE_TEMENOS_PROOF_SERVER, r as FEATURE_FLAG_MIDNIGHT_INDEXER_URLS, s as MidnightSDKNetworkId, t as DEFAULT_NETWORKS_CONFIG, v as TEMENOS_PROOF_SERVER_MODES } from "./const-D0CbQlo4.js";
+import { a as getValidNetworkStringPayload } from "./utils-DFwzEvbv.js";
+import { createAction, createSelector, createSlice } from "@reduxjs/toolkit";
+import merge from "lodash/merge.js";
+import { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
+//#region ../../packages/contract/midnight-context/src/proof-server-mode.ts
+/** Local UI acknowledgement only; never an attestation or proving authorization.
+* Custom endpoints may forward proof inputs, even when addressed via localhost.
+* Bump the version when the disclosure changes materially. */
+const proofServerDisclosureKey = (mode) => mode.kind === "local-host" || mode.kind === "delegated" || mode.kind === "tee-delegated" ? `v1:${mode.kind}:${mode.url}` : void 0;
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/proof-activity-slice.ts
+/** Background-owned summaries, intentionally excluded from persisted wallet state. */
+const proofActivitySlice = createSlice({
+	name: "midnightProofActivities",
+	initialState: [],
+	reducers: {
+		proofActivitiesUpdated: (_state, { payload }) => payload,
+		proofActivityDismissRequested: (state, { payload }) => state.filter((activity) => activity.id !== payload || activity.status !== "succeeded" && activity.status !== "failed")
+	},
+	selectors: { selectProofActivities: (state) => state }
+});
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/tee-attestation-slice.ts
+const initialTeeAttestationState = {
+	status: "idle",
+	steps: []
+};
+/**
+* Folds {@link AttestationProgressEvent}s into checklist state for the
+* send-flow processing UI. Transient by design — never persisted; each
+* proof request starts with a `reset`.
+*/
+const teeAttestationSlice = createSlice({
+	name: "midnightTeeAttestation",
+	initialState: initialTeeAttestationState,
+	reducers: {
+		teeAttestationProgressCleared: () => initialTeeAttestationState,
+		teeAttestationProgressStarted: (_state, { payload }) => ({
+			...initialTeeAttestationState,
+			operationId: payload.operationId,
+			accountId: payload.accountId
+		}),
+		teeAttestationProgressUpdated: (state, { payload }) => {
+			if (payload.operationId !== state.operationId) return state;
+			const { event } = payload;
+			if (event.type === "phase" && event.phase === "proof-material") return {
+				...state,
+				proofMaterialRequests: Math.max(0, (state.proofMaterialRequests ?? 0) + (event.status === "started" ? 1 : -1))
+			};
+			if (event.type === "phase" && event.phase.startsWith("transaction-")) {
+				const ids = [
+					"preparing",
+					"proving",
+					"finalizing",
+					"submitting",
+					"inclusion",
+					"confirmation"
+				];
+				const id = event.phase.slice(12);
+				const current = state.transactionSteps ?? ids.map((id) => ({
+					id,
+					status: "pending"
+				}));
+				if (id === "failed") return {
+					...state,
+					transactionSteps: current.map((step) => step.status === "running" ? {
+						...step,
+						status: "failed"
+					} : step)
+				};
+				const index = ids.indexOf(id);
+				if (index < 0) return state;
+				return {
+					...state,
+					transactionSteps: current.map((step, index_) => ({
+						...step,
+						status: index_ < index ? "done" : index_ > index ? "pending" : event.status === "completed" ? "done" : event.status === "failed" ? "failed" : "running"
+					}))
+				};
+			}
+			switch (event.type) {
+				case "reset": return {
+					...state.transactionSteps ? { transactionSteps: state.transactionSteps } : {},
+					operationId: state.operationId,
+					accountId: state.accountId,
+					status: "running",
+					steps: event.steps.map((id) => ({
+						id,
+						status: "pending"
+					}))
+				};
+				case "check": {
+					const checks = state.checks ?? [];
+					const existingIndex = checks.findIndex((check) => check.id === event.check.id && (check.phase ?? "verify-locally") === (event.check.phase ?? "verify-locally"));
+					return {
+						...state,
+						checks: existingIndex === -1 ? [...checks, event.check] : checks.map((check, index) => index === existingIndex ? event.check : check)
+					};
+				}
+				case "phase": {
+					const stepStatus = event.status === "started" ? "running" : event.status === "completed" ? "done" : "failed";
+					const steps = state.steps.map((step) => step.id === event.phase ? {
+						...step,
+						status: stepStatus,
+						...event.detail === void 0 ? {} : { detail: event.detail }
+					} : step);
+					if (event.status === "failed") return {
+						...state,
+						steps,
+						status: "failed",
+						failure: {
+							phase: event.phase,
+							checkId: state.checks?.find((check) => check.status === "failed" && (check.phase ?? "verify-locally") === event.phase)?.id,
+							...event.detail === void 0 ? {} : { detail: event.detail }
+						}
+					};
+					return {
+						...state,
+						steps,
+						...(event.phase === "proving" || event.phase === "checking") && event.status === "completed" ? { status: "succeeded" } : {}
+					};
+				}
+			}
+		}
+	},
+	selectors: { selectTeeAttestationProgress: (state) => state }
+});
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/slice.ts
+const initialState = {
+	supportsWasmProver: false,
+	proofServerDisclosureAcknowledgements: {},
+	defaultTestNetNetworkId: NetworkId.NetworkId.Preview,
+	defaultNetworksConfig: DEFAULT_NETWORKS_CONFIG,
+	userNetworksConfigOverrides: EMPTY_PARTIAL_NETWORKS_CONFIG,
+	isActivityPageHeaderBannerDismissed: false,
+	isPortfolioBannerDismissed: false,
+	supportedNetworksIds: [...MidnightSDKNetworkId],
+	dustBalanceByAccount: {},
+	dustAvailableByAccount: {},
+	dustGenerationDetailsByAccount: {},
+	publicKeysByAccount: {}
+};
+const slice = createSlice({
+	name: "midnightContext",
+	initialState,
+	reducers: {
+		acknowledgeProofServerDisclosure: (state, { payload }) => {
+			const key = proofServerDisclosureKey(payload);
+			if (key) {
+				state.proofServerDisclosureAcknowledgements ??= {};
+				state.proofServerDisclosureAcknowledgements[key] = true;
+			}
+		},
+		setUserNetworkConfigOverride: (state, { payload }) => {
+			const { networkId, config, featureFlagsOverrides } = payload;
+			if (!state.supportedNetworksIds.includes(networkId)) return state;
+			const baseNetworkConfig = {
+				...state.defaultNetworksConfig[networkId],
+				...featureFlagsOverrides
+			};
+			const userNetworksConfigOverrides = state.userNetworksConfigOverrides[networkId];
+			if (!userNetworksConfigOverrides) return state;
+			if (baseNetworkConfig.nodeAddress !== config.nodeAddress) userNetworksConfigOverrides.nodeAddress = config.nodeAddress;
+			else delete userNetworksConfigOverrides.nodeAddress;
+			if (baseNetworkConfig.indexerAddress !== config.indexerAddress) userNetworksConfigOverrides.indexerAddress = config.indexerAddress;
+			else delete userNetworksConfigOverrides.indexerAddress;
+			const baseProofServer = baseNetworkConfig.proofServer;
+			if (config.proofServer && (!baseProofServer || !isSameProofServerMode(baseProofServer, config.proofServer))) userNetworksConfigOverrides.proofServer = config.proofServer;
+			else delete userNetworksConfigOverrides.proofServer;
+		},
+		setSupportedNetworksIds: (state, { payload }) => {
+			state.supportedNetworksIds = payload;
+		},
+		setDefaultProofServers: (state, { payload }) => {
+			for (const [networkId, proofServer] of Object.entries(payload)) {
+				const networkConfig = state.defaultNetworksConfig[networkId];
+				if (networkConfig && proofServer) networkConfig.proofServer = proofServer;
+			}
+		},
+		dismissActivityPageHeaderBanner: (state) => {
+			state.isActivityPageHeaderBannerDismissed = true;
+		},
+		dismissPortfolioBanner: (state) => {
+			state.isPortfolioBannerDismissed = true;
+		},
+		setDustBalance: (state, { payload: { accountId, dustAvailable, dustBalance } }) => {
+			state.dustBalanceByAccount[accountId] = dustBalance;
+			state.dustAvailableByAccount[accountId] = dustAvailable;
+		},
+		setDustGenerationDetails: {
+			reducer: (state, { payload: { accountId, dustGenerationDetails } }) => {
+				if (dustGenerationDetails === void 0) {
+					delete state.dustGenerationDetailsByAccount[accountId];
+					return;
+				}
+				state.dustGenerationDetailsByAccount[accountId] = dustGenerationDetails;
+			},
+			prepare: ({ accountId, dustGenerationDetails }) => ({ payload: {
+				accountId,
+				dustGenerationDetails: dustGenerationDetails ? Serializable.to(dustGenerationDetails) : void 0
+			} })
+		},
+		setPublicKeys: (state, { payload: { accountId, publicKeys } }) => {
+			state.publicKeysByAccount[accountId] = publicKeys;
+		},
+		resetAccountDust: (state, { payload: { accountId } }) => {
+			delete state.dustBalanceByAccount[accountId];
+			delete state.dustAvailableByAccount[accountId];
+			delete state.dustGenerationDetailsByAccount[accountId];
+		}
+	},
+	selectors: {
+		selectSupportsWasmProver: (state) => state.supportsWasmProver,
+		selectProofServerDisclosureAcknowledgements: (state) => state.proofServerDisclosureAcknowledgements,
+		selectNetworksDefaultConfig: (state) => state.defaultNetworksConfig,
+		selectSupportedNetworksIds: (state) => {
+			return state.supportedNetworksIds;
+		},
+		selectNetworksConfigUserOverrides: (state) => state.userNetworksConfigOverrides,
+		selectIsActivityPageHeaderBannerDismissed: (state) => state.isActivityPageHeaderBannerDismissed,
+		selectIsPortfolioBannerDismissed: (state) => state.isPortfolioBannerDismissed,
+		selectDefaultTestNetNetworkId: (state) => state.defaultTestNetNetworkId,
+		selectDustBalanceByAccount: (state) => state.dustBalanceByAccount,
+		selectDustAvailableByAccount: (state) => state.dustAvailableByAccount,
+		selectSerializedDustGenerationDetailsByAccount: (state) => state.dustGenerationDetailsByAccount,
+		selectPublicKeysByAccount: (state) => state.publicKeysByAccount
+	}
+});
+const selectPublicKeysByAccountId = markParameterizedSelector(createSelector(slice.selectors.selectPublicKeysByAccount, (_, accountId) => accountId, (publicKeysByAccount, accountId) => publicKeysByAccount[accountId]));
+const selectDustGenerationDetails = markParameterizedSelector(createSelector(slice.selectors.selectSerializedDustGenerationDetailsByAccount, (_, accountIds) => accountIds, (allDustGenerationDetails, accountIds) => accountIds.reduce((accumulator, accountId) => {
+	const dustGenerationDetails = allDustGenerationDetails[accountId];
+	accumulator[accountId] = dustGenerationDetails ? Serializable.fromCached(dustGenerationDetails) : void 0;
+	return accumulator;
+}, {})));
+const selectMidnightBlockchainNetworkId = createSelector(networkSelectors.network.selectNetworkType, networkSelectors.network.selectBlockchainNetworks, (networkType, blockchainNetworks) => blockchainNetworks["Midnight"]?.[networkType]);
+/**
+* Derives the active Midnight network ID from the global network store.
+* Returns undefined if Midnight blockchain is not registered.
+*/
+const selectNetworkId = createSelector(networkSelectors.network.selectNetworkType, selectMidnightBlockchainNetworkId, slice.selectors.selectDefaultTestNetNetworkId, (networkType, blockchainNetworkId, defaultTestNetNetworkId) => {
+	if (!blockchainNetworkId) return networkType === "mainnet" ? NetworkId.NetworkId.MainNet : defaultTestNetNetworkId;
+	return MidnightNetworkId.getNetworkNameId(blockchainNetworkId);
+});
+/**
+* Derives the Midnight network ID that corresponds to `initialNetworkType`.
+* Used as the preselected network in the onboarding flow so that a new wallet
+* starts on the network intended by the `INITIAL_NETWORK_TYPE` feature flag,
+* regardless of any previously-persisted `networkType` from an earlier wallet.
+*/
+const selectInitialNetworkId = createSelector(networkSelectors.network.selectInitialNetworkType, slice.selectors.selectDefaultTestNetNetworkId, (initialNetworkType, defaultTestNetNetworkId) => initialNetworkType === "mainnet" ? NetworkId.NetworkId.MainNet : defaultTestNetNetworkId);
+/**
+* Every string config field a feature flag can override, and the flag that
+* carries it. These — and `proofServer`, derived from the remote proof-server
+* options below — must stay on this derived path: a field routed through a
+* side effect into `userNetworksConfigOverrides` instead shadows later flag
+* changes and is indistinguishable from a genuine user setting.
+*/
+const NETWORK_CONFIG_FEATURE_FLAG_KEYS = [["nodeAddress", FEATURE_FLAG_MIDNIGHT_NODE_URLS], ["indexerAddress", FEATURE_FLAG_MIDNIGHT_INDEXER_URLS]];
+/**
+* Derives the list of remote proof server options per network from the
+* boolean `BLOCKCHAIN_MIDNIGHT_REMOTE_PROOF_SERVER` feature flag. URLs and
+* display metadata come exclusively from the source-controlled catalogue.
+* Legacy URL payloads are deliberately ignored.
+*/
+const selectRemoteProofServerOptions = createSelector(featuresSelectors.features.selectLoadedFeatures, slice.selectors.selectSupportedNetworksIds, (loadedFeatures, supportedNetworksIds) => {
+	const { featureFlags } = loadedFeatures;
+	if (!featureFlags.find((f) => f.key === FEATURE_FLAG_MIDNIGHT_REMOTE_PROOF_SERVER)) return {};
+	const result = {};
+	for (const networkId of supportedNetworksIds) {
+		const mode = REMOTE_PROOF_SERVER_MODES[networkId];
+		if (mode) result[networkId] = [mode];
+	}
+	return result;
+});
+/**
+* Derives feature flag network config overrides directly from loaded features.
+* Since loaded features ARE persisted, this selector produces the correct value
+* immediately on startup — eliminating the oscillation caused by the previous
+* approach (Redux state populated by an async side effect).
+*/
+const selectNetworksConfigFeatureFlagsOverrides = createSelector(selectRemoteProofServerOptions, featuresSelectors.features.selectLoadedFeatures, slice.selectors.selectSupportedNetworksIds, (remoteProofServerOptions, loadedFeatures, supportedNetworksIds) => {
+	const { featureFlags } = loadedFeatures;
+	const overridesByConfigKey = NETWORK_CONFIG_FEATURE_FLAG_KEYS.map(([configKey, flagKey]) => {
+		const flag = featureFlags.find((f) => f.key === flagKey);
+		return [configKey, flag ? getValidNetworkStringPayload(supportedNetworksIds, flag) : {}];
+	});
+	const result = { ...EMPTY_PARTIAL_NETWORKS_CONFIG };
+	for (const networkId of supportedNetworksIds) {
+		const config = {};
+		for (const [configKey, overrides] of overridesByConfigKey) {
+			const value = overrides[networkId];
+			if (value) config[configKey] = value;
+		}
+		const firstRemote = remoteProofServerOptions[networkId]?.[0];
+		if (firstRemote) config.proofServer = {
+			kind: "delegated",
+			url: firstRemote.url,
+			label: firstRemote.label,
+			...firstRemote.descriptionKey ? { descriptionKey: firstRemote.descriptionKey } : {}
+		};
+		result[networkId] = config;
+	}
+	return result;
+});
+/**
+* The Temenos TEE option is build-baked; this remote boolean flag decides
+* whether it is offered and — as the kill switch — whether an already
+* persisted `tee-delegated` selection is still honoured.
+*/
+const selectIsTemenosProofServerEnabled = createSelector(featuresSelectors.features.selectLoadedFeatures, (loadedFeatures) => loadedFeatures.featureFlags.some((f) => f.key === FEATURE_FLAG_MIDNIGHT_TEE_TEMENOS_PROOF_SERVER));
+/**
+* All proof server modes available for a given network, ordered by
+* trust-tier section (on-device first, delegated last). Drives the
+* settings UI directly — sections collapse to empty when no entries
+* qualify (e.g. no WASM support, no paired phone, no flag-provided
+* remotes).
+*/
+const selectAllProofServerModes = createSelector(slice.selectors.selectNetworksDefaultConfig, selectRemoteProofServerOptions, createSelector(selectIsTemenosProofServerEnabled, slice.selectors.selectSupportsWasmProver, (isTemenosEnabled, supportsWasmProver) => ({
+	isTemenosEnabled,
+	supportsWasmProver
+})), (defaultNetworksConfig, remoteProofServerOptions, { isTemenosEnabled, supportsWasmProver }) => {
+	const result = {};
+	for (const [id, config] of Object.entries(defaultNetworksConfig)) {
+		const networkId = id;
+		const modes = [];
+		if (supportsWasmProver) modes.push({ kind: "in-process" });
+		modes.push(config.proofServer ?? defaultLocalProofServerMode);
+		for (const remote of remoteProofServerOptions[networkId] ?? []) modes.push({
+			kind: "delegated",
+			url: remote.url,
+			label: remote.label,
+			...remote.descriptionKey ? { descriptionKey: remote.descriptionKey } : {}
+		});
+		const temenosMode = TEMENOS_PROOF_SERVER_MODES[networkId];
+		if (isTemenosEnabled && temenosMode) modes.push(temenosMode);
+		result[networkId] = modes;
+	}
+	return result;
+});
+/** Only currently available source-controlled modes can override the default.
+* Legacy persisted URLs and disabled providers must not bypass the catalogue. */
+const selectHonouredUserNetworksConfigOverrides = createSelector(slice.selectors.selectNetworksConfigUserOverrides, selectAllProofServerModes, (overrides, modes) => {
+	const result = { ...overrides };
+	for (const id of Object.keys(overrides)) {
+		const networkId = id;
+		const override = overrides[networkId];
+		if (!override?.proofServer) continue;
+		const { proofServer, ...rest } = override;
+		const canonical = modes[networkId]?.find((mode) => isSameProofServerMode(mode, proofServer));
+		result[networkId] = canonical ? {
+			...rest,
+			proofServer: canonical
+		} : rest;
+	}
+	return result;
+});
+const selectUnavailableProofServerNetworks = createSelector(slice.selectors.selectNetworksConfigUserOverrides, selectHonouredUserNetworksConfigOverrides, (overrides, honoured) => Object.keys(overrides).filter((networkId) => overrides[networkId]?.proofServer && !honoured[networkId]?.proofServer));
+const selectNetworksConfig = createSelector(slice.selectors.selectNetworksDefaultConfig, selectNetworksConfigFeatureFlagsOverrides, selectHonouredUserNetworksConfigOverrides, (defaultNetworkConfig, featureFlagsNetworksConfigOverrides, userNetworksConfigOverrides) => {
+	const result = merge({}, defaultNetworkConfig, featureFlagsNetworksConfigOverrides, userNetworksConfigOverrides);
+	for (const id of Object.keys(defaultNetworkConfig)) {
+		const networkId = id;
+		result[networkId].proofServer = userNetworksConfigOverrides[networkId]?.proofServer ?? featureFlagsNetworksConfigOverrides[networkId]?.proofServer ?? defaultNetworkConfig[networkId].proofServer;
+	}
+	return result;
+});
+const selectCurrentNetwork = createSelector(selectNetworksConfig, selectNetworkId, (networksConfig, networkId) => ({
+	networkId,
+	config: networksConfig[networkId]
+}));
+const midnightContextReducers = {
+	[slice.name]: slice.reducer,
+	[teeAttestationSlice.name]: teeAttestationSlice.reducer,
+	[proofActivitySlice.name]: proofActivitySlice.reducer
+};
+/**
+* Per-account "reset sync state" intent. Lives on the contract (not a module
+* slice) because two different modules implement it — `@lace-module/midnight-sync`
+* for the monolith engine and `@lace-module/midnight-host-pull` for the shell
+* guest — and modules cannot subscribe to another module's actions (ADR 14).
+*/
+const resetSyncState = createAction("midnight/resetSyncState");
+const midnightContextActions = { midnightContext: {
+	...slice.actions,
+	...teeAttestationSlice.actions,
+	...proofActivitySlice.actions,
+	resetSyncState
+} };
+const midnightContextSelectors = { midnightContext: {
+	...slice.selectors,
+	...teeAttestationSlice.selectors,
+	...proofActivitySlice.selectors,
+	selectMidnightBlockchainNetworkId,
+	selectNetworkId,
+	selectInitialNetworkId,
+	selectNetworksConfig,
+	selectNetworksConfigFeatureFlagsOverrides,
+	selectRemoteProofServerOptions,
+	selectAllProofServerModes,
+	selectUnavailableProofServerNetworks,
+	selectIsTemenosProofServerEnabled,
+	selectCurrentNetwork,
+	selectDustGenerationDetails,
+	selectPublicKeysByAccountId
+} };
+//#endregion
+export { midnightContextSelectors as i, midnightContextActions as n, midnightContextReducers as r, initialState as t };