@laceio/sdk 0.1.0 → 0.1.1-canary.1

package/dist/{slice-Bjj2t2ut.cjs → slice-WMMMc1Xv.cjs}

@@ -1,6 +1,6 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_util_selector = require("./util-selector-C9H5RsNw.cjs");
-const require_reselect = require("./reselect-DPML1uFN.cjs");
+const require_util_selector = require("./util-selector-glXkO-jR.cjs");
+const require_reselect = require("./reselect-kP4DaAII.cjs");
 //#region ../../packages/contract/failures/src/store/slice.ts
 const slice = (0, require("@reduxjs/toolkit").createSlice)({
 	name: "failures",

package/dist/slice-a8VuIqzS.cjs

@@ -0,0 +1,378 @@
+const require_chunk = require("./chunk-9hOWP6kD.cjs");
+const require_serializable = require("./serializable-n3UoxbZc.cjs");
+const require_util_selector = require("./util-selector-glXkO-jR.cjs");
+const require_slice = require("./slice-C4toRM6A.cjs");
+const require_slice$1 = require("./slice-B9QKuhi0.cjs");
+const require_const = require("./const-DgBzKfz6.cjs");
+const require_utils = require("./utils-Du0YXRcU.cjs");
+let _reduxjs_toolkit = require("@reduxjs/toolkit");
+let lodash_merge = require("lodash/merge.js");
+lodash_merge = require_chunk.__toESM(lodash_merge);
+//#region ../../packages/contract/midnight-context/src/proof-server-mode.ts
+/** Local UI acknowledgement only; never an attestation or proving authorization.
+* Bump the version when the disclosure changes materially. */
+const proofServerDisclosureKey = (mode) => mode.kind === "delegated" || mode.kind === "tee-delegated" ? `v1:${mode.kind}:${mode.url}` : void 0;
+//#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 = (0, _reduxjs_toolkit.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;
+			switch (event.type) {
+				case "reset": return {
+					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 = {
+	proofServerDisclosureAcknowledgements: {},
+	defaultTestNetNetworkId: require_const.NetworkId.Preview,
+	defaultNetworksConfig: require_const.DEFAULT_NETWORKS_CONFIG,
+	userNetworksConfigOverrides: require_const.EMPTY_PARTIAL_NETWORKS_CONFIG,
+	isActivityPageHeaderBannerDismissed: false,
+	isPortfolioBannerDismissed: false,
+	supportedNetworksIds: [...require_const.MidnightSDKNetworkId],
+	dustBalanceByAccount: {},
+	dustAvailableByAccount: {},
+	dustGenerationDetailsByAccount: {},
+	publicKeysByAccount: {}
+};
+const slice = (0, _reduxjs_toolkit.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 || !require_const.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 ? require_serializable.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: {
+		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 = require_util_selector.markParameterizedSelector((0, _reduxjs_toolkit.createSelector)(slice.selectors.selectPublicKeysByAccount, (_, accountId) => accountId, (publicKeysByAccount, accountId) => publicKeysByAccount[accountId]));
+const selectDustGenerationDetails = require_util_selector.markParameterizedSelector((0, _reduxjs_toolkit.createSelector)(slice.selectors.selectSerializedDustGenerationDetailsByAccount, (_, accountIds) => accountIds, (allDustGenerationDetails, accountIds) => accountIds.reduce((accumulator, accountId) => {
+	const dustGenerationDetails = allDustGenerationDetails[accountId];
+	accumulator[accountId] = dustGenerationDetails ? require_serializable.Serializable.fromCached(dustGenerationDetails) : void 0;
+	return accumulator;
+}, {})));
+const selectMidnightBlockchainNetworkId = (0, _reduxjs_toolkit.createSelector)(require_slice$1.networkSelectors.network.selectNetworkType, require_slice$1.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 = (0, _reduxjs_toolkit.createSelector)(require_slice$1.networkSelectors.network.selectNetworkType, selectMidnightBlockchainNetworkId, slice.selectors.selectDefaultTestNetNetworkId, (networkType, blockchainNetworkId, defaultTestNetNetworkId) => {
+	if (!blockchainNetworkId) return networkType === "mainnet" ? require_const.NetworkId.MainNet : defaultTestNetNetworkId;
+	return require_const.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 = (0, _reduxjs_toolkit.createSelector)(require_slice$1.networkSelectors.network.selectInitialNetworkType, slice.selectors.selectDefaultTestNetNetworkId, (initialNetworkType, defaultTestNetNetworkId) => initialNetworkType === "mainnet" ? require_const.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", require_const.FEATURE_FLAG_MIDNIGHT_NODE_URLS], ["indexerAddress", require_const.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 = (0, _reduxjs_toolkit.createSelector)(require_slice.featuresSelectors.features.selectLoadedFeatures, slice.selectors.selectSupportedNetworksIds, (loadedFeatures, supportedNetworksIds) => {
+	const { featureFlags } = loadedFeatures;
+	if (!featureFlags.find((f) => f.key === require_const.FEATURE_FLAG_MIDNIGHT_REMOTE_PROOF_SERVER)) return {};
+	const result = {};
+	for (const networkId of supportedNetworksIds) {
+		const mode = require_const.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 = (0, _reduxjs_toolkit.createSelector)(selectRemoteProofServerOptions, require_slice.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 ? require_utils.getValidNetworkStringPayload(supportedNetworksIds, flag) : {}];
+	});
+	const result = { ...require_const.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 = (0, _reduxjs_toolkit.createSelector)(require_slice.featuresSelectors.features.selectLoadedFeatures, (loadedFeatures) => loadedFeatures.featureFlags.some((f) => f.key === require_const.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 = (0, _reduxjs_toolkit.createSelector)(slice.selectors.selectNetworksDefaultConfig, selectRemoteProofServerOptions, selectIsTemenosProofServerEnabled, (defaultNetworksConfig, remoteProofServerOptions, isTemenosEnabled) => {
+	const result = {};
+	for (const [id, config] of Object.entries(defaultNetworksConfig)) {
+		const networkId = id;
+		const modes = [];
+		modes.push(config.proofServer ?? require_const.defaultLocalProofServerMode);
+		for (const remote of remoteProofServerOptions[networkId] ?? []) modes.push({
+			kind: "delegated",
+			url: remote.url,
+			label: remote.label,
+			...remote.descriptionKey ? { descriptionKey: remote.descriptionKey } : {}
+		});
+		const temenosMode = require_const.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 = (0, _reduxjs_toolkit.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) => require_const.isSameProofServerMode(mode, proofServer));
+		result[networkId] = canonical ? {
+			...rest,
+			proofServer: canonical
+		} : rest;
+	}
+	return result;
+});
+const selectUnavailableProofServerNetworks = (0, _reduxjs_toolkit.createSelector)(slice.selectors.selectNetworksConfigUserOverrides, selectHonouredUserNetworksConfigOverrides, (overrides, honoured) => Object.keys(overrides).filter((networkId) => overrides[networkId]?.proofServer && !honoured[networkId]?.proofServer));
+const selectNetworksConfig = (0, _reduxjs_toolkit.createSelector)(slice.selectors.selectNetworksDefaultConfig, selectNetworksConfigFeatureFlagsOverrides, selectHonouredUserNetworksConfigOverrides, (defaultNetworkConfig, featureFlagsNetworksConfigOverrides, userNetworksConfigOverrides) => {
+	const result = (0, lodash_merge.default)({}, 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 = (0, _reduxjs_toolkit.createSelector)(selectNetworksConfig, selectNetworkId, (networksConfig, networkId) => ({
+	networkId,
+	config: networksConfig[networkId]
+}));
+const midnightContextReducers = {
+	[slice.name]: slice.reducer,
+	[teeAttestationSlice.name]: teeAttestationSlice.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 = (0, _reduxjs_toolkit.createAction)("midnight/resetSyncState");
+const midnightContextActions = { midnightContext: {
+	...slice.actions,
+	...teeAttestationSlice.actions,
+	resetSyncState
+} };
+const midnightContextSelectors = { midnightContext: {
+	...slice.selectors,
+	...teeAttestationSlice.selectors,
+	selectMidnightBlockchainNetworkId,
+	selectNetworkId,
+	selectInitialNetworkId,
+	selectNetworksConfig,
+	selectNetworksConfigFeatureFlagsOverrides,
+	selectRemoteProofServerOptions,
+	selectAllProofServerModes,
+	selectUnavailableProofServerNetworks,
+	selectIsTemenosProofServerEnabled,
+	selectCurrentNetwork,
+	selectDustGenerationDetails,
+	selectPublicKeysByAccountId
+} };
+//#endregion
+Object.defineProperty(exports, "initialState", {
+	enumerable: true,
+	get: function() {
+		return initialState;
+	}
+});
+Object.defineProperty(exports, "midnightContextActions", {
+	enumerable: true,
+	get: function() {
+		return midnightContextActions;
+	}
+});
+Object.defineProperty(exports, "midnightContextReducers", {
+	enumerable: true,
+	get: function() {
+		return midnightContextReducers;
+	}
+});
+Object.defineProperty(exports, "midnightContextSelectors", {
+	enumerable: true,
+	get: function() {
+		return midnightContextSelectors;
+	}
+});