@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/const-CUnCl5U0.js

@@ -0,0 +1,13 @@
+import { s as BitcoinNetworkId } from "./address-B9ntKL8K.js";
+import { t as TokenId } from "./token-id.vo-Bvwhr3ZE.js";
+import { n as BitcoinNetwork } from "./types-B8uiJn-X.js";
+//#region ../../packages/contract/bitcoin-context/src/const.ts
+/** Enables Bitcoin accounts: the Bitcoin chain and provider modules load with it. */
+const BITCOIN_FEATURE_FLAG = "BLOCKCHAIN_BITCOIN";
+/** Enables Bitcoin fee rate estimates from mempool.space. */
+const BITCOIN_MEMPOOL_FEE_MARKET_FEATURE_FLAG = "BITCOIN_MEMPOOL_FEE_MARKET";
+const BITCOIN_TOKEN_ID = TokenId("bitcoin");
+const allSupportedNetworks = [BitcoinNetwork.Mainnet, BitcoinNetwork.Testnet];
+const supportedNetworkIds = new Map(allSupportedNetworks.map((network) => [BitcoinNetworkId(network), network]));
+//#endregion
+export { supportedNetworkIds as a, allSupportedNetworks as i, BITCOIN_MEMPOOL_FEE_MARKET_FEATURE_FLAG as n, BITCOIN_TOKEN_ID as r, BITCOIN_FEATURE_FLAG as t };

package/dist/{const-DXk2tFyv.js → const-CjmfjBP3.js}

@@ -1,4 +1,4 @@
-import { t as FeatureFlagKey } from "./feature-flag-key.vo-ofrB6ZVQ.js";
+import { t as FeatureFlagKey } from "./feature-flag-key.vo-DN_-4-sG.js";
 //#region ../../packages/contract/network/src/const.ts
 /**
 * Sets the network type a new wallet starts on: its payload is `'mainnet'` or

package/dist/{const-BDEg2Trq.cjs → const-D-eZIS4n.cjs}

@@ -1,8 +1,8 @@
 require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_time_vo = require("./time.vo-CQ8pSXz2.cjs");
-const require_feature_flag_key_vo = require("./feature-flag-key.vo-BPz-ZAp6.cjs");
-const require_token_id_vo = require("./token-id.vo-BxG9TG0O.cjs");
-const require_cardano_network_id_vo = require("./cardano-network-id.vo-DSxrFk9S.cjs");
+const require_time_vo = require("./time.vo-D3wWRw9L.cjs");
+const require_feature_flag_key_vo = require("./feature-flag-key.vo-RlfHL3hq.cjs");
+const require_token_id_vo = require("./token-id.vo-DXv5uS9n.cjs");
+const require_cardano_network_id_vo = require("./cardano-network-id.vo-BEDPn6Li.cjs");
 let _laceio_cardano_core = require("@laceio/cardano/core");
 //#region ../../packages/contract/cardano-context/src/const.ts
 /**

package/dist/const-D0CbQlo4.js

@@ -0,0 +1,154 @@
+import { t as FeatureFlagKey } from "./feature-flag-key.vo-DN_-4-sG.js";
+import { t as BlockchainNetworkId } from "./blockchain-network-id.vo-CiVykuqG.js";
+import { NetworkId } from "@midnightntwrk/wallet-sdk-abstractions";
+//#region ../../packages/lib/vendor/src/midnight-proof-servers.ts
+/**
+* Stable identity for a mode — what we compare to decide if two selections
+* refer to the same option (e.g. for radio-button highlighting and for
+* deciding whether the user's pick differs from the default).
+*
+* Labels/descriptions are denormalised metadata; they may drift across
+* application updates, so identity is keyed on `kind` + `url`/`pairingId`.
+*/
+const isSameProofServerMode = (a, b) => {
+	if (a.kind !== b.kind) return false;
+	switch (a.kind) {
+		case "in-process": return true;
+		case "local-host": return a.url === b.url;
+		case "paired-device": {
+			const right = b;
+			return a.url === right.url && a.pairingId === right.pairingId;
+		}
+		case "delegated": return a.url === b.url;
+		case "tee-delegated": return a.url === b.url;
+	}
+};
+/** Returns the configured HTTP endpoint, or undefined for in-process proving. */
+const getProofServerEndpoint = (mode) => "url" in mode ? mode.url : void 0;
+const TEMENOS_PREPROD_DEPLOYMENT_MODE = {
+	kind: "tee-delegated",
+	url: "https://api.proofserver.wastedp.io",
+	label: "Temenos (remote TEE proof server)",
+	descriptionKey: "midnight.proof-server.tee-delegated.description"
+};
+const TEMENOS_MAINNET_DEPLOYMENT_MODE = {
+	kind: "tee-delegated",
+	url: "https://api.proofserver.mainnet.wastedp.io",
+	label: "Temenos (remote TEE proof server)",
+	descriptionKey: "midnight.proof-server.tee-delegated.description"
+};
+const TEMENOS_PREVIEW_DEPLOYMENT_MODE = {
+	kind: "tee-delegated",
+	url: "https://api.proofserver.preview.wastedp.io",
+	label: "Temenos (remote TEE proof server)",
+	descriptionKey: "midnight.proof-server.tee-delegated.description"
+};
+/**
+* Contract-visible part of the baked Temenos TEE proof-server config, per
+* network: just enough for `selectAllProofServerModes` to synthesize the
+* settings row without importing module code. The heavyweight attestation
+* config (evidence/Warden endpoints, application id, AMD root certificates)
+* lives in the vendor Temenos driver, keyed by the same network id and
+* cross-checked against this mode's `url` at module load.
+*
+* Values are build-baked and reviewed like code (rotating an endpoint
+* requires a release); the remote feature flag only toggles visibility.
+*/
+const TEMENOS_PROOF_SERVER_MODES = {
+	["mainnet"]: TEMENOS_MAINNET_DEPLOYMENT_MODE,
+	["preprod"]: TEMENOS_PREPROD_DEPLOYMENT_MODE,
+	["preview"]: TEMENOS_PREVIEW_DEPLOYMENT_MODE
+};
+/** Source-controlled ordinary remote providers. Currently empty: the Midnight
+* Foundation service was decommissioned. Keep the selection infrastructure;
+* a feature flag or legacy payload must not resurrect a retired endpoint. */
+const REMOTE_PROOF_SERVER_MODES = {};
+const defaultLocalProofServerMode = {
+	kind: "local-host",
+	url: "http://localhost:6300"
+};
+/** Refuses unsupported modes and routes recognized TEE hosts only through attestation. */
+const assertProofServerRouting = (mode, hasAttestedProver, hasLocalProver = false) => {
+	if (mode.kind === "in-process" && hasLocalProver) return;
+	if (mode.kind === "in-process" || mode.kind === "paired-device") throw new Error(`Unsupported Midnight proof server mode "${mode.kind}"`);
+	const hostname = new URL(mode.url).hostname.replace(/\.$/, "");
+	if (Object.values(TEMENOS_PROOF_SERVER_MODES).some((candidate) => candidate && new URL(candidate.url).hostname.replace(/\.$/, "") === hostname) && mode.kind !== "tee-delegated") throw new Error("Cannot attest a TEE proof server through ordinary HTTP; select tee-delegated");
+	if (mode.kind === "tee-delegated" && !hasAttestedProver) throw new Error("Cannot attest Midnight proof server: proof server mode \"tee-delegated\" needs an attested prover");
+};
+//#endregion
+//#region ../../packages/contract/midnight-context/src/value-objects/midnight-network-id.vo.ts
+const MIDNIGHT_NETWORK_PREFIX = "midnight-";
+/** Converts a Midnight network name to its blockchain-qualified identity and back. */
+const MidnightNetworkId = Object.assign((networkId) => BlockchainNetworkId(`${MIDNIGHT_NETWORK_PREFIX}${networkId}`), { getNetworkNameId: (networkId) => networkId?.startsWith(MIDNIGHT_NETWORK_PREFIX) ? networkId.slice(9) : void 0 });
+//#endregion
+//#region ../../packages/contract/midnight-context/src/const.ts
+const FEATURE_FLAG_MIDNIGHT_REMOTE_PROOF_SERVER = FeatureFlagKey("BLOCKCHAIN_MIDNIGHT_REMOTE_PROOF_SERVER");
+const FEATURE_FLAG_MIDNIGHT_INDEXER_URLS = FeatureFlagKey("BLOCKCHAIN_MIDNIGHT_INDEXER_URLS");
+const FEATURE_FLAG_MIDNIGHT_NODE_URLS = FeatureFlagKey("BLOCKCHAIN_MIDNIGHT_NODE_URLS");
+/**
+* Gates the Temenos TEE proof-server option (LW-15081). Boolean gate with
+* no payload by design: all Temenos configuration (endpoints, trust
+* anchors) is baked into the build, so the remote flag system controls
+* visibility only and can never inject or alter a TEE entry.
+*/
+const FEATURE_FLAG_MIDNIGHT_TEE_TEMENOS_PROOF_SERVER = FeatureFlagKey("BLOCKCHAIN_MIDNIGHT_TEE_TEMENOS_PROOF_SERVER");
+const defaultTxTtlLength = 3600 * 1e3;
+/** The Midnight networks, keyed by name. */
+const MidnightSDKNetworkIds = NetworkId.NetworkId;
+/** Every Midnight network id. */
+const MidnightSDKNetworkId = Object.values(MidnightSDKNetworkIds);
+const supportedNetworkIds = new Map(MidnightSDKNetworkId.map((id) => [MidnightNetworkId(id), id]));
+const MidnightSDKTestNetworkId = MidnightSDKNetworkId.filter((id) => id !== "mainnet");
+const DEFAULT_NETWORKS_CONFIG = {
+	[NetworkId.NetworkId.Undeployed]: {
+		nodeAddress: "http://localhost:9944",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "http://localhost:8088/api/v4/graphql"
+	},
+	[NetworkId.NetworkId.MainNet]: {
+		nodeAddress: "https://blockfrost.lw.iog.io/midnight-mainnet-rpc/",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "https://blockfrost.lw.iog.io/midnight-mainnet/"
+	},
+	[NetworkId.NetworkId.PreProd]: {
+		nodeAddress: "https://blockfrost.lw.iog.io/midnight-preprod-rpc/",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "https://blockfrost.lw.iog.io/midnight-preprod/"
+	},
+	[NetworkId.NetworkId.Preview]: {
+		nodeAddress: "https://blockfrost.lw.iog.io/midnight-preview-rpc/",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "https://blockfrost.lw.iog.io/midnight-preview/"
+	},
+	[NetworkId.NetworkId.QaNet]: {
+		nodeAddress: "https://rpc.qanet.midnight.network",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "https://indexer.qanet.midnight.network/api/v4/graphql"
+	},
+	[NetworkId.NetworkId.DevNet]: {
+		nodeAddress: "http://localhost:9944",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "http://localhost:8088/api/v4/graphql"
+	},
+	[NetworkId.NetworkId.TestNet]: {
+		nodeAddress: "http://localhost:9944",
+		proofServer: defaultLocalProofServerMode,
+		indexerAddress: "http://localhost:8088/api/v4/graphql"
+	}
+};
+const EMPTY_PARTIAL_NETWORKS_CONFIG = {
+	[NetworkId.NetworkId.Undeployed]: {},
+	[NetworkId.NetworkId.MainNet]: {},
+	[NetworkId.NetworkId.PreProd]: {},
+	[NetworkId.NetworkId.Preview]: {},
+	[NetworkId.NetworkId.QaNet]: {},
+	[NetworkId.NetworkId.DevNet]: {},
+	[NetworkId.NetworkId.TestNet]: {}
+};
+/** The token type of NIGHT, Midnight's native token. */
+const NIGHT_TOKEN_ID = "0000000000000000000000000000000000000000000000000000000000000000";
+const NIGHT_TOKEN_TICKER = "NIGHT";
+const TNIGHT_TOKEN_TICKER = "tNIGHT";
+const NIGHT_ICON = "data:image/png;base64,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";
+//#endregion
+export { isSameProofServerMode as S, REMOTE_PROOF_SERVER_MODES as _, FEATURE_FLAG_MIDNIGHT_REMOTE_PROOF_SERVER as a, defaultLocalProofServerMode as b, MidnightSDKNetworkIds as c, NIGHT_TOKEN_ID as d, NIGHT_TOKEN_TICKER as f, MidnightNetworkId as g, supportedNetworkIds as h, FEATURE_FLAG_MIDNIGHT_NODE_URLS as i, MidnightSDKTestNetworkId as l, defaultTxTtlLength as m, EMPTY_PARTIAL_NETWORKS_CONFIG as n, FEATURE_FLAG_MIDNIGHT_TEE_TEMENOS_PROOF_SERVER as o, TNIGHT_TOKEN_TICKER as p, FEATURE_FLAG_MIDNIGHT_INDEXER_URLS as r, MidnightSDKNetworkId as s, DEFAULT_NETWORKS_CONFIG as t, NIGHT_ICON as u, TEMENOS_PROOF_SERVER_MODES as v, getProofServerEndpoint as x, assertProofServerRouting as y };

package/dist/{const-BY8B3_0_.cjs → const-iwzZEE_w.cjs}

@@ -4,7 +4,7 @@
 * `'testnet'`, or `{ networkType }` with either. The default is `'mainnet'`;
 * once the wallet persists a network type, that one applies.
 */
-const FEATURE_FLAG_NETWORK_TYPE = require("./feature-flag-key.vo-BPz-ZAp6.cjs").FeatureFlagKey("INITIAL_NETWORK_TYPE");
+const FEATURE_FLAG_NETWORK_TYPE = require("./feature-flag-key.vo-RlfHL3hq.cjs").FeatureFlagKey("INITIAL_NETWORK_TYPE");
 //#endregion
 Object.defineProperty(exports, "FEATURE_FLAG_NETWORK_TYPE", {
 	enumerable: true,

package/dist/contract-1R86jhSw.js

@@ -0,0 +1,171 @@
+import { A as ContractName, D as storageDependencyContract, O as combineStore, _ as walletActiveStateDependencyContract, k as createMixin, v as tokensStoreContract, w as networkStoreContract, y as syncStoreContract } from "./sdk-Cb-gZnS9.js";
+import { a as inferStoreContext, n as combineContracts, r as inferContractContext } from "./store-DuBG8qh5.js";
+import { t as createSelector } from "./reselect-CGoLzEPv.js";
+import { r as tokensSelectors } from "./slice-DBpJ2QGf.js";
+import { r as addressBookSelectors, t as addressBookActions } from "./slice-obCSLm1x.js";
+import { c as FIAT_CURRENCIES, s as DEFAULT_CURRENCY_PREFERENCE, t as calculatePortfolioValueOverTime } from "./utils-BfBEUvWA.js";
+import { n as tokenPricingActions, t as slice } from "./slice-Da426sf9.js";
+//#region src/lazy-wallet-mismatch-error.ts
+/**
+* The recovery words a lazy vault supplied derive another account key than
+* the one the signing account stores, so nothing was signed.
+*/
+var LazyWalletMismatchError = class extends Error {
+	constructor() {
+		super("Mnemonic does not match the selected lazy wallet account.");
+		this.name = "LazyWalletMismatchError";
+	}
+};
+//#endregion
+//#region ../../packages/contract/address-book/src/store/index.ts
+var store_default$1 = inferStoreContext({
+	load: async () => import("./init-Y3mkB4XS.js"),
+	context: {
+		actions: addressBookActions,
+		selectors: addressBookSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/address-book/src/contract.ts
+const addressBookAddressValidatorAddonContract = inferContractContext({
+	name: ContractName("address-book-address-validator-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadAddressBookAddressValidators"] }
+});
+inferContractContext({
+	name: ContractName("address-book-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default$1) }))
+});
+//#endregion
+//#region ../../packages/contract/token-pricing/src/store/selectors.ts
+const EMPTY_PRICE_DATA_POINTS = [];
+const selectHasActivePricingError = createSelector([slice.selectors.selectError, slice.selectors.selectIsPricingStale], (error, isPricingStale) => !!error && isPricingStale);
+const selectTokenPriceHistoryForRange = createSelector(slice.selectors.selectPriceHistory, (_, params) => params, (priceHistory, { priceId, timeRange }) => {
+	if (!priceId) return EMPTY_PRICE_DATA_POINTS;
+	const points = priceHistory[priceId]?.[timeRange];
+	if (!points || points.length === 0) return EMPTY_PRICE_DATA_POINTS;
+	return points;
+});
+/**
+* Select portfolio value history for a given time range
+* This is a cross-slice selector that combines price history with token data
+*/
+const selectPortfolioValueHistory = createSelector([
+	slice.selectors.selectPriceHistory,
+	slice.selectors.selectPrices,
+	tokensSelectors.tokens.selectAggregatedFungibleTokensForVisibleAccounts,
+	(_, timeRange) => timeRange
+], (priceHistory, prices, tokens, timeRange) => {
+	if (!tokens || tokens.length === 0) return EMPTY_PRICE_DATA_POINTS;
+	const priceHistoryMap = /* @__PURE__ */ new Map();
+	let hasAnyData = false;
+	for (const [priceId, history] of Object.entries(priceHistory)) {
+		const data = history[timeRange];
+		if (data && data.length > 0) {
+			priceHistoryMap.set(priceId, data);
+			hasAnyData = true;
+		}
+	}
+	if (!hasAnyData) return EMPTY_PRICE_DATA_POINTS;
+	return calculatePortfolioValueOverTime(priceHistoryMap, tokens, prices);
+});
+/**
+* The currencies the user can actually pick, in allowlist display order.
+*
+* While the supported-currencies list is unavailable (not yet fetched,
+* testnet, or offline) the full allowlist is shown.
+*
+* Never empty: the default currency always stays selectable (even when excluded
+* or dropped by CoinGecko), so a corrected user is never left on a currency
+* that is missing from the sheet.
+*
+* Inputs are raw slice fields (stable references); the intersection/filter and
+* allocation happen in the result function, per reselect input-stability rules.
+*/
+const selectSupportedCurrencyPreferences = createSelector([slice.selectors.selectSupportedVsCurrencies, slice.selectors.selectCurrencyChoiceExclusions], (supportedVsCurrencies, exclusions) => {
+	const exclusionSet = new Set(exclusions.map((code) => code.toLowerCase()));
+	const supportedSet = supportedVsCurrencies?.length ? new Set(supportedVsCurrencies.map((code) => code.toLowerCase())) : null;
+	const defaultCode = DEFAULT_CURRENCY_PREFERENCE.name.toLowerCase();
+	return FIAT_CURRENCIES.filter((currency) => {
+		const code = currency.name.toLowerCase();
+		if (code === defaultCode) return true;
+		if (exclusionSet.has(code)) return false;
+		if (supportedSet && !supportedSet.has(code)) return false;
+		return true;
+	});
+});
+const NO_CURRENCY_FALLBACK = { fallback: false };
+const CURRENCY_FALLBACK = { fallback: true };
+const selectCurrencyFallback = createSelector([slice.selectors.selectCurrencyPreference, selectSupportedCurrencyPreferences], (preference, selectableCurrencies) => {
+	if (preference.name === DEFAULT_CURRENCY_PREFERENCE.name) return NO_CURRENCY_FALLBACK;
+	if (selectableCurrencies.some((c) => c.name === preference.name)) return NO_CURRENCY_FALLBACK;
+	return CURRENCY_FALLBACK;
+});
+/**
+* USD → selected-currency conversion rate, for values that are inherently
+* USD-denominated (e.g. USD-pegged stablecoin positions). Every cached price
+* carries both `price` (in the user's currency) and `priceInUsd`, so their
+* ratio is the live exchange rate. Undefined while no fresh price in the
+* selected currency is cached — callers should then fall back to displaying
+* USD rather than mislabeling an unconverted value.
+*/
+const selectUsdToCurrencyRate = createSelector([slice.selectors.selectPrices, slice.selectors.selectCurrencyPreference], (prices, preference) => {
+	const preferred = preference.name.toLowerCase();
+	if (preferred === "usd") return 1;
+	for (const price of Object.values(prices)) if (!price.isStale && price.fiatCurrency.toLowerCase() === preferred && price.priceInUsd > 0 && price.price > 0) return price.price / price.priceInUsd;
+});
+//#endregion
+//#region ../../packages/contract/token-pricing/src/store/index.ts
+var store_default = inferStoreContext({
+	load: async () => import("./init-DFjT8YvT.js"),
+	context: {
+		actions: tokenPricingActions,
+		selectors: { tokenPricing: {
+			...slice.selectors,
+			selectHasActivePricingError,
+			selectTokenPriceHistoryForRange,
+			selectPortfolioValueHistory,
+			selectSupportedCurrencyPreferences,
+			selectCurrencyFallback,
+			selectUsdToCurrencyRate
+		} }
+	}
+});
+//#endregion
+//#region ../../packages/contract/token-pricing/src/contract.ts
+const tokenPricingProviderDependencyContract = inferContractContext({
+	contractType: "sideEffectDependency",
+	name: ContractName("token-pricing-provider-dependency"),
+	instance: "zero-or-more"
+});
+/**
+* Addon contract for blockchain-specific token ID mappers.
+* Each blockchain module implements this to provide its own token-to-price-id mapping.
+*/
+const tokenIdMapperAddonContract = inferContractContext({
+	name: ContractName("token-id-mapper-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadTokenIdMapper"] }
+});
+inferContractContext({
+	name: ContractName("token-pricing-store"),
+	contractType: "store",
+	dependsOn: combineContracts([
+		storageDependencyContract,
+		networkStoreContract,
+		tokensStoreContract,
+		syncStoreContract,
+		tokenPricingProviderDependencyContract,
+		tokenIdMapperAddonContract,
+		walletActiveStateDependencyContract
+	]),
+	mixin: createMixin((laceModule) => ({ store: combineStore(laceModule, store_default) })),
+	instance: "zero-or-more"
+});
+//#endregion
+export { addressBookAddressValidatorAddonContract as n, LazyWalletMismatchError as r, tokenIdMapperAddonContract as t };

package/dist/contract-MKLzYVkW.cjs

@@ -0,0 +1,189 @@
+const require_sdk = require("./sdk-DffwmX8b.cjs");
+const require_store = require("./store-B1Lq3cEf.cjs");
+const require_reselect = require("./reselect-Bd94u0K-.cjs");
+const require_slice = require("./slice-C9TT5KhY.cjs");
+const require_slice$1 = require("./slice-Dqw1ecum.cjs");
+const require_utils = require("./utils-DsElZgCI.cjs");
+const require_slice$2 = require("./slice-DayJvMRD.cjs");
+//#region src/lazy-wallet-mismatch-error.ts
+/**
+* The recovery words a lazy vault supplied derive another account key than
+* the one the signing account stores, so nothing was signed.
+*/
+var LazyWalletMismatchError = class extends Error {
+	constructor() {
+		super("Mnemonic does not match the selected lazy wallet account.");
+		this.name = "LazyWalletMismatchError";
+	}
+};
+//#endregion
+//#region ../../packages/contract/address-book/src/store/index.ts
+var store_default$1 = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-rmt7-fQE.cjs")),
+	context: {
+		actions: require_slice$1.addressBookActions,
+		selectors: require_slice$1.addressBookSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/address-book/src/contract.ts
+const addressBookAddressValidatorAddonContract = require_store.inferContractContext({
+	name: require_sdk.ContractName("address-book-address-validator-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	provides: { addons: ["loadAddressBookAddressValidators"] }
+});
+require_store.inferContractContext({
+	name: require_sdk.ContractName("address-book-store"),
+	contractType: "store",
+	instance: "exactly-one",
+	mixin: require_sdk.createMixin((laceModule) => ({ store: require_sdk.combineStore(laceModule, store_default$1) }))
+});
+//#endregion
+//#region ../../packages/contract/token-pricing/src/store/selectors.ts
+const EMPTY_PRICE_DATA_POINTS = [];
+const selectHasActivePricingError = require_reselect.createSelector([require_slice$2.slice.selectors.selectError, require_slice$2.slice.selectors.selectIsPricingStale], (error, isPricingStale) => !!error && isPricingStale);
+const selectTokenPriceHistoryForRange = require_reselect.createSelector(require_slice$2.slice.selectors.selectPriceHistory, (_, params) => params, (priceHistory, { priceId, timeRange }) => {
+	if (!priceId) return EMPTY_PRICE_DATA_POINTS;
+	const points = priceHistory[priceId]?.[timeRange];
+	if (!points || points.length === 0) return EMPTY_PRICE_DATA_POINTS;
+	return points;
+});
+/**
+* Select portfolio value history for a given time range
+* This is a cross-slice selector that combines price history with token data
+*/
+const selectPortfolioValueHistory = require_reselect.createSelector([
+	require_slice$2.slice.selectors.selectPriceHistory,
+	require_slice$2.slice.selectors.selectPrices,
+	require_slice.tokensSelectors.tokens.selectAggregatedFungibleTokensForVisibleAccounts,
+	(_, timeRange) => timeRange
+], (priceHistory, prices, tokens, timeRange) => {
+	if (!tokens || tokens.length === 0) return EMPTY_PRICE_DATA_POINTS;
+	const priceHistoryMap = /* @__PURE__ */ new Map();
+	let hasAnyData = false;
+	for (const [priceId, history] of Object.entries(priceHistory)) {
+		const data = history[timeRange];
+		if (data && data.length > 0) {
+			priceHistoryMap.set(priceId, data);
+			hasAnyData = true;
+		}
+	}
+	if (!hasAnyData) return EMPTY_PRICE_DATA_POINTS;
+	return require_utils.calculatePortfolioValueOverTime(priceHistoryMap, tokens, prices);
+});
+/**
+* The currencies the user can actually pick, in allowlist display order.
+*
+* While the supported-currencies list is unavailable (not yet fetched,
+* testnet, or offline) the full allowlist is shown.
+*
+* Never empty: the default currency always stays selectable (even when excluded
+* or dropped by CoinGecko), so a corrected user is never left on a currency
+* that is missing from the sheet.
+*
+* Inputs are raw slice fields (stable references); the intersection/filter and
+* allocation happen in the result function, per reselect input-stability rules.
+*/
+const selectSupportedCurrencyPreferences = require_reselect.createSelector([require_slice$2.slice.selectors.selectSupportedVsCurrencies, require_slice$2.slice.selectors.selectCurrencyChoiceExclusions], (supportedVsCurrencies, exclusions) => {
+	const exclusionSet = new Set(exclusions.map((code) => code.toLowerCase()));
+	const supportedSet = supportedVsCurrencies?.length ? new Set(supportedVsCurrencies.map((code) => code.toLowerCase())) : null;
+	const defaultCode = require_utils.DEFAULT_CURRENCY_PREFERENCE.name.toLowerCase();
+	return require_utils.FIAT_CURRENCIES.filter((currency) => {
+		const code = currency.name.toLowerCase();
+		if (code === defaultCode) return true;
+		if (exclusionSet.has(code)) return false;
+		if (supportedSet && !supportedSet.has(code)) return false;
+		return true;
+	});
+});
+const NO_CURRENCY_FALLBACK = { fallback: false };
+const CURRENCY_FALLBACK = { fallback: true };
+const selectCurrencyFallback = require_reselect.createSelector([require_slice$2.slice.selectors.selectCurrencyPreference, selectSupportedCurrencyPreferences], (preference, selectableCurrencies) => {
+	if (preference.name === require_utils.DEFAULT_CURRENCY_PREFERENCE.name) return NO_CURRENCY_FALLBACK;
+	if (selectableCurrencies.some((c) => c.name === preference.name)) return NO_CURRENCY_FALLBACK;
+	return CURRENCY_FALLBACK;
+});
+/**
+* USD → selected-currency conversion rate, for values that are inherently
+* USD-denominated (e.g. USD-pegged stablecoin positions). Every cached price
+* carries both `price` (in the user's currency) and `priceInUsd`, so their
+* ratio is the live exchange rate. Undefined while no fresh price in the
+* selected currency is cached — callers should then fall back to displaying
+* USD rather than mislabeling an unconverted value.
+*/
+const selectUsdToCurrencyRate = require_reselect.createSelector([require_slice$2.slice.selectors.selectPrices, require_slice$2.slice.selectors.selectCurrencyPreference], (prices, preference) => {
+	const preferred = preference.name.toLowerCase();
+	if (preferred === "usd") return 1;
+	for (const price of Object.values(prices)) if (!price.isStale && price.fiatCurrency.toLowerCase() === preferred && price.priceInUsd > 0 && price.price > 0) return price.price / price.priceInUsd;
+});
+const tokenPricingSliceSelectors = { tokenPricing: {
+	...require_slice$2.slice.selectors,
+	selectHasActivePricingError,
+	selectTokenPriceHistoryForRange,
+	selectPortfolioValueHistory,
+	selectSupportedCurrencyPreferences,
+	selectCurrencyFallback,
+	selectUsdToCurrencyRate
+} };
+//#endregion
+//#region ../../packages/contract/token-pricing/src/store/index.ts
+var store_default = require_store.inferStoreContext({
+	load: async () => Promise.resolve().then(() => require("./init-Dv3zKj0r.cjs")),
+	context: {
+		actions: require_slice$2.tokenPricingActions,
+		selectors: tokenPricingSliceSelectors
+	}
+});
+//#endregion
+//#region ../../packages/contract/token-pricing/src/contract.ts
+const tokenPricingProviderDependencyContract = require_store.inferContractContext({
+	contractType: "sideEffectDependency",
+	name: require_sdk.ContractName("token-pricing-provider-dependency"),
+	instance: "zero-or-more"
+});
+/**
+* Addon contract for blockchain-specific token ID mappers.
+* Each blockchain module implements this to provide its own token-to-price-id mapping.
+*/
+const tokenIdMapperAddonContract = require_store.inferContractContext({
+	name: require_sdk.ContractName("token-id-mapper-addon"),
+	instance: "zero-or-more",
+	contractType: "addon",
+	preloadInServiceWorker: true,
+	provides: { addons: ["loadTokenIdMapper"] }
+});
+require_store.inferContractContext({
+	name: require_sdk.ContractName("token-pricing-store"),
+	contractType: "store",
+	dependsOn: require_store.combineContracts([
+		require_sdk.storageDependencyContract,
+		require_sdk.networkStoreContract,
+		require_sdk.tokensStoreContract,
+		require_sdk.syncStoreContract,
+		tokenPricingProviderDependencyContract,
+		tokenIdMapperAddonContract,
+		require_sdk.walletActiveStateDependencyContract
+	]),
+	mixin: require_sdk.createMixin((laceModule) => ({ store: require_sdk.combineStore(laceModule, store_default) })),
+	instance: "zero-or-more"
+});
+//#endregion
+Object.defineProperty(exports, "LazyWalletMismatchError", {
+	enumerable: true,
+	get: function() {
+		return LazyWalletMismatchError;
+	}
+});
+Object.defineProperty(exports, "addressBookAddressValidatorAddonContract", {
+	enumerable: true,
+	get: function() {
+		return addressBookAddressValidatorAddonContract;
+	}
+});
+Object.defineProperty(exports, "tokenIdMapperAddonContract", {
+	enumerable: true,
+	get: function() {
+		return tokenIdMapperAddonContract;
+	}
+});