@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/{init-BTYLMF9F2.cjs → init-DexLSprL2.cjs}

@@ -1,17 +1,22 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_Address = require("./Address-4KjeDt_x.cjs");
-const require_group_cardano_addresses_by_account = require("./group-cardano-addresses-by-account-C-1GHUu8.cjs");
-const require_types = require("./types-CUC-Kcqh.cjs");
-const require_util = require("./util-P4PX2muj.cjs");
-const require_time_vo = require("./time.vo-rwWwJzmP.cjs");
-const require_asyncoption = require("./asyncoption-po7-RiA5.cjs");
-const require_sync_operation_utils = require("./sync-operation-utils-BrQyWFS_.cjs");
-const require_toEmpty = require("./toEmpty-CzmoZVLN.cjs");
-const require_retry_config = require("./retry-config-oNtfdyrG.cjs");
-const require_cardano_network_id_vo = require("./cardano-network-id.vo-CbNNKd-k.cjs");
-const require_cardano_tx_id_vo = require("./cardano-tx-id.vo-NY-gCOWJ.cjs");
-const require_while_active = require("./while-active-BsDWSNrO.cjs");
+require("./dist-MJof_Ky1.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_group_cardano_addresses_by_account = require("./group-cardano-addresses-by-account-BGOtPV-Y.cjs");
+const require_types = require("./types-Cn6WlQV6.cjs");
+const require_util = require("./util-D1YlKzrc.cjs");
+const require_time_vo = require("./time.vo-TmYE-_Y2.cjs");
+const require_asyncoption = require("./asyncoption-CYcZNBRM.cjs");
+const require_auto_dismiss_failure_on_success = require("./auto-dismiss-failure-on-success-BWJceNXd.cjs");
+const require_account_id_vo = require("./account-id.vo-DYZBZQsz.cjs");
+const require_toEmpty = require("./toEmpty-Db6V94Mf.cjs");
+const require_retry_config = require("./retry-config-BGv5q5QM.cjs");
+const require_cardano_network_id_vo = require("./cardano-network-id.vo-C5VuBXT3.cjs");
+const require_cardano_tx_id_vo = require("./cardano-tx-id.vo-lnyO9XaW.cjs");
+const require_sync_operation_utils = require("./sync-operation-utils--Z_IQfyW.cjs");
+const require_identity = require("./identity-y41Yle03.cjs");
+const require_while_active = require("./while-active-I2TlHtm7.cjs");
+const require_pending_operation = require("./pending-operation-CfTUNQVD.cjs");
 let rxjs = require("rxjs");
 //#region ../../packages/lib/core/src/address.ts
 /**
@@ -173,48 +178,8 @@ const filterFrankenUtxos = (utxos, ownedCredentials) => {
 	};
 };
 //#endregion
-//#region ../../packages/module/cardano-sync/src/store/side-effects/account-extensions.stable.ts
-/** Whether the account is of a kind a feature adds: never. */
-const isExtensionAccount = (_account) => false;
-/** Address discovery for an account of a kind a feature adds: none exists. */
-const extensionAccountAddressDiscovery = (_params) => rxjs.EMPTY;
-/** The UTxO fetch of an account of a kind a feature adds: none exists. */
-const extensionAccountUtxos = (_params) => rxjs.EMPTY;
-/** The sync side effects the features add: none. */
-const extensionSyncSideEffects = [];
-//#endregion
-//#region ../../packages/module/cardano-sync/src/store/get-script-address.ts
-var import_dist = require_retry_config.require_dist();
-/**
-* Method to derive the wallet's grouped address from the script and network ID.
-*
-* @param paymentScript - The native script to be used for the payment credential.
-* @param stakingScript - The native script to be used for the staking credential.
-* @param networkId - The network identifier.
-* @returns The derived grouped address.
-*/
-const getScriptAddress = (paymentScript, stakingScript, networkId) => {
-	const paymentScriptHash = require_group_cardano_addresses_by_account.nativeScriptPolicyId(paymentScript);
-	const stakingScriptHash = require_group_cardano_addresses_by_account.nativeScriptPolicyId(stakingScript);
-	const paymentScriptCredential = {
-		hash: paymentScriptHash,
-		type: require_Address.CredentialType.ScriptHash
-	};
-	const stakeScriptCredential = {
-		hash: stakingScriptHash,
-		type: require_Address.CredentialType.ScriptHash
-	};
-	return {
-		accountIndex: 0,
-		address: encodeBaseAddress(networkId, paymentScriptCredential, stakeScriptCredential),
-		index: 0,
-		networkId,
-		rewardAccount: encodeRewardAddress(networkId, stakeScriptCredential),
-		type: require_types.AddressType.External
-	};
-};
-//#endregion
 //#region ../../packages/module/cardano-sync/src/store/side-effects/chain-account-state-operations.ts
+var import_dist = require_retry_config.require_dist();
 /**
 * Builds the `addSyncOperation` actions that chain account-state operations
 * (currently transaction-polling) after a successful address discovery. The
@@ -257,6 +222,245 @@ const chainAccountStateOperations = (params) => {
 	}));
 };
 //#endregion
+//#region ../../packages/module/cardano-sync/src/store/side-effects/throw-on-error.ts
+/** The value of a provider result, or its error thrown. */
+const throwOnError = (result) => {
+	if (result.isErr()) throw result.unwrapErr();
+	return result.unwrap();
+};
+//#endregion
+//#region ../../packages/module/cardano-sync/src/store/side-effects/custody-accounts.ts
+/**
+* Discovers the one address of a Cardano custody account: its base address,
+* re-derived from the stored identity. The sync fails when the stored
+* address, reward account or stake script hash differs from the derived one,
+* so funds are never shown at an address the custody contract does not
+* govern for this account.
+*
+* The entry carries the `type`, `index` and `accountIndex` every address
+* entry needs, but no key derives it. It must never reach a signer as a
+* known address: a key agent would sign every custody input with the key at
+* that path. No signer factory accepts a custody account, so signing never
+* reads its addresses.
+*/
+const handleCustodyAccount = (params) => {
+	const { account, accountId, operationId, actions, logger } = params;
+	const { chainId } = account.blockchainSpecific;
+	const identity = require_identity.verifyCardanoCustodyAccountIdentity(account.blockchainSpecific);
+	if (!identity.ok) {
+		logger.error(`Address discovery refused custody account ${accountId}: ${identity.error.code}`, identity.error);
+		return (0, rxjs.of)(actions.sync.failSyncOperation({
+			accountId,
+			operationId,
+			error: "sync.error.address-discovery-failed"
+		}));
+	}
+	return (0, rxjs.of)(actions.sync.updateSyncOperation({
+		accountId,
+		operationId,
+		update: {
+			status: "InProgress",
+			type: "Indeterminate"
+		}
+	}), actions.addresses.upsertAddresses({
+		blockchainName: "Cardano",
+		accountId,
+		addresses: [require_util.toContractAddress({
+			accountIndex: 0,
+			address: identity.value.address,
+			index: 0,
+			networkId: chainId.networkId,
+			rewardAccount: identity.value.rewardAccount,
+			type: require_types.AddressType.External
+		}, chainId.networkMagic)]
+	}), ...chainAccountStateOperations({
+		accountId,
+		discoveryOperationId: operationId,
+		actions
+	}), actions.sync.completeSyncOperation({
+		accountId,
+		operationId
+	}));
+};
+/**
+* A custody account's UTxOs are not fetched: the account no longer matches
+* the identity its contract derives.
+*/
+var CardanoCustodyUtxoSyncRefusedError = class extends Error {
+	constructor(accountId, reason) {
+		super(`Refused the UTxO sync of custody account ${accountId}: ${reason.code}`);
+		this.accountId = accountId;
+		this.reason = reason;
+		this.name = "CardanoCustodyUtxoSyncRefusedError";
+	}
+};
+/**
+* A custody account's UTxOs: exactly those whose full address is the
+* account's base address, the only outputs the custody contract lets the
+* account spend.
+*
+* Discovery verifies the identity only once, when it stores the address
+* entry, so every fetch verifies it again: an identity changed since then,
+* or an entry that no longer matches it, fails the fetch.
+*
+* Fetched by address rather than by stake key. The stake credential also
+* gathers outputs under any other payment credential, which anyone can
+* create at no cost to inflate the fetch, and none of which belong to the
+* account. The key-hash franken filter does not apply: every custody output
+* has the script's payment credential.
+*
+* Reference scripts are read too: classification counts a reserve that
+* carries one as foreign.
+*/
+const fetchCustodyAccountUtxos = (params) => {
+	const { accountId, blockchainSpecific } = params.account;
+	const identity = require_identity.verifyCardanoCustodyAccountIdentity(blockchainSpecific);
+	if (!identity.ok) return (0, rxjs.throwError)(() => new CardanoCustodyUtxoSyncRefusedError(accountId, identity.error));
+	const { address } = identity.value;
+	const strayEntry = params.accountAddresses.find((entry) => entry.address !== require_util.CardanoPaymentAddress(address));
+	if (strayEntry) return (0, rxjs.throwError)(() => new CardanoCustodyUtxoSyncRefusedError(accountId, {
+		code: "address-entry-mismatch",
+		entry: strayEntry.address,
+		derived: address
+	}));
+	return params.getUtxosAtAddress({
+		address: require_util.CardanoPaymentAddress(address),
+		withReferenceScripts: true
+	}, { chainId: blockchainSpecific.chainId }).pipe((0, rxjs.map)(throwOnError), (0, import_dist.retryBackoff)(require_retry_config.PROVIDER_REQUEST_RETRY_CONFIG), (0, rxjs.map)((utxos) => {
+		const own = utxos.filter(([, output]) => output.address === address);
+		if (own.length < utxos.length) params.logger.warn(`Dropped ${utxos.length - own.length} UTxOs not at the address of custody account ${accountId}`);
+		return own;
+	}));
+};
+//#endregion
+//#region ../../packages/module/cardano-sync/src/store/side-effects/expire-custody-pending-activities.ts
+/**
+* Advances one account's round record. A round starts when `startedAt`
+* changes and completes when it clears with a newer `lastSuccessfulSync`.
+*/
+const advanceRounds = (previous, status, tipSlot) => {
+	const roundStartedAt = status.pendingSync?.startedAt;
+	const isSameRound = previous !== void 0 && roundStartedAt === previous.roundStartedAt;
+	const roundTipSlot = roundStartedAt === void 0 || previous === void 0 ? void 0 : isSameRound ? previous.roundTipSlot : tipSlot;
+	const hasCompleted = previous?.roundStartedAt !== void 0 && !isSameRound && status.lastSuccessfulSync !== previous.lastSuccessfulSync;
+	return {
+		roundStartedAt,
+		roundTipSlot,
+		lastSuccessfulSync: status.lastSuccessfulSync,
+		syncedFromSlot: hasCompleted ? previous.roundTipSlot ?? previous.syncedFromSlot : previous?.syncedFromSlot
+	};
+};
+const trackRounds = ({ hasSeenState, accounts }, [tip, statuses]) => ({
+	hasSeenState: true,
+	accounts: Object.fromEntries(Object.entries(statuses).map(([id, status]) => {
+		const accountId = require_account_id_vo.AccountId(id);
+		return [accountId, advanceRounds(accounts[accountId] ?? (hasSeenState ? {} : void 0), status, tip?.slot)];
+	}))
+});
+/**
+* Whether a custody operation's pending activity can no longer settle: a
+* round that started once the tip was past its upper validity bound, by
+* the depth the wallet allows its provider to lag, synced the account's
+* history, and neither that history nor the synced UTxOs show the
+* transaction.
+*/
+const isExpired = (activity, { syncedFromSlot, utxos, history }) => {
+	const invalidHereafter = require_pending_operation.cardanoCustodyActivityMetadataOf(activity)?.invalidHereafter;
+	if (invalidHereafter === void 0 || syncedFromSlot === void 0) return false;
+	if (syncedFromSlot <= invalidHereafter + 60) return false;
+	const txId = activity.activityId;
+	return !history.some((item) => item.txId === txId) && !utxos.some(([input]) => input.txId === txId);
+};
+const findExpired = ({ rounds, pendingByAccount, utxosByAccount, historyByAccount }) => Object.entries(pendingByAccount).flatMap(([id, pending]) => {
+	const accountId = require_account_id_vo.AccountId(id);
+	const context = {
+		syncedFromSlot: rounds.accounts[accountId]?.syncedFromSlot,
+		utxos: utxosByAccount[accountId] ?? [],
+		history: historyByAccount[accountId] ?? []
+	};
+	const activityIds = pending.filter((activity) => isExpired(activity, context)).map(({ activityId }) => activityId);
+	return activityIds.length > 0 ? [{
+		accountId,
+		activityIds
+	}] : [];
+});
+/**
+* Drops the pending activity of a custody operation that can no longer
+* settle, so an account does not stay blocked as operation-in-progress when
+* no one waits for the operation (R5.3: state reconciles with the network).
+*
+* A custody submission records its upper validity bound on the pending
+* activity (`blockchainSpecific.Cardano.custody`). Past that bound the
+* transaction can never apply. The chain tip alone does not prove that the
+* wallet saw the outcome: the tip poll updates the tip before the next sync
+* round fetches the history. So the activity is dropped only once a sync
+* round that started with the tip past the bound by
+* `UTXO_SYNC_CONFIRMATION_DEPTH` completed successfully, and neither the
+* account's history nor its synced UTxOs show the transaction. Other
+* pending activities carry no bound and are left alone.
+*
+* It reads state only and makes no provider call. `whileActive` (ADR 29)
+* keeps it off while the wallet is locked. Each activation starts with no
+* completed round, so a round that ran before unlock never counts.
+*/
+const expireCustodyPendingActivities = (_, { cardanoContext: { selectTip$, selectAccountUtxos$, selectTransactionHistoryGroupedByAccount$ }, activities: { selectPendingActivitiesByAccount$ }, sync: { selectSyncStatusByAccount$ } }, { actions, isWalletActive$ }) => (0, rxjs.combineLatest)([
+	(0, rxjs.combineLatest)([selectTip$, selectSyncStatusByAccount$]).pipe((0, rxjs.scan)(trackRounds, {
+		hasSeenState: false,
+		accounts: {}
+	})),
+	selectPendingActivitiesByAccount$,
+	selectAccountUtxos$,
+	selectTransactionHistoryGroupedByAccount$
+]).pipe((0, rxjs.map)(([rounds, pendingByAccount, utxosByAccount, historyByAccount]) => findExpired({
+	rounds,
+	pendingByAccount,
+	utxosByAccount,
+	historyByAccount
+})), (0, rxjs.mergeMap)((expired) => (0, rxjs.from)(expired.map(({ accountId, activityIds }) => actions.activities.removeActivities({
+	accountId,
+	activityIds
+})))), require_while_active.whileActive(isWalletActive$));
+//#endregion
+//#region ../../packages/module/cardano-sync/src/store/side-effects/account-extensions.ts
+/** Whether the account is of a kind a feature adds: a custody account. */
+const isExtensionAccount = require_identity.isCardanoCustodyAccount;
+/** Address discovery for an account of a kind a feature adds. */
+const extensionAccountAddressDiscovery = handleCustodyAccount;
+/** The UTxO fetch of an account of a kind a feature adds. */
+const extensionAccountUtxos = fetchCustodyAccountUtxos;
+/** The sync side effects the features add. */
+const extensionSyncSideEffects = [expireCustodyPendingActivities];
+//#endregion
+//#region ../../packages/module/cardano-sync/src/store/get-script-address.ts
+/**
+* Method to derive the wallet's grouped address from the script and network ID.
+*
+* @param paymentScript - The native script to be used for the payment credential.
+* @param stakingScript - The native script to be used for the staking credential.
+* @param networkId - The network identifier.
+* @returns The derived grouped address.
+*/
+const getScriptAddress = (paymentScript, stakingScript, networkId) => {
+	const paymentScriptHash = require_group_cardano_addresses_by_account.nativeScriptPolicyId(paymentScript);
+	const stakingScriptHash = require_group_cardano_addresses_by_account.nativeScriptPolicyId(stakingScript);
+	const paymentScriptCredential = {
+		hash: paymentScriptHash,
+		type: require_Address.CredentialType.ScriptHash
+	};
+	const stakeScriptCredential = {
+		hash: stakingScriptHash,
+		type: require_Address.CredentialType.ScriptHash
+	};
+	return {
+		accountIndex: 0,
+		address: encodeBaseAddress(networkId, paymentScriptCredential, stakeScriptCredential),
+		index: 0,
+		networkId,
+		rewardAccount: encodeRewardAddress(networkId, stakeScriptCredential),
+		type: require_types.AddressType.External
+	};
+};
+//#endregion
 //#region ../../packages/module/cardano-sync/src/store/side-effects/address-discovery-sync.ts
 /**
 * Handles MultiSig account address discovery by generating script address.
@@ -459,13 +663,6 @@ const submitTxSideEffect = ({ cardanoContext: { submitTx$ } }, { cardanoContext:
 	})));
 }));
 //#endregion
-//#region ../../packages/module/cardano-sync/src/store/side-effects/throw-on-error.ts
-/** The value of a provider result, or its error thrown. */
-const throwOnError = (result) => {
-	if (result.isErr()) throw result.unwrapErr();
-	return result.unwrap();
-};
-//#endregion
 //#region ../../packages/module/cardano-sync/src/store/side-effects/track-account-utxos.ts
 /**
 * Sentinel `topOnChainActivityId` for the cache key when an account has no
@@ -675,7 +872,7 @@ const trackAccountUtxos = ({ cardanoContext: { retrySyncRound$ } }, { wallets: {
 				accountId,
 				cacheKey
 			})));
-			emissions.push((0, rxjs.of)(CardanoUtxoFetchFailureId(accountId)).pipe(require_group_cardano_addresses_by_account.autoDismissFailureOnSuccess(selectFailureById$)));
+			emissions.push((0, rxjs.of)(CardanoUtxoFetchFailureId(accountId)).pipe(require_auto_dismiss_failure_on_success.autoDismissFailureOnSuccess(selectFailureById$)));
 			return (0, rxjs.merge)(...emissions);
 		}), (0, rxjs.catchError)((error) => {
 			logger.error(`Utxo fetch failed for account ${accountId}`, error);

package/dist/init-DfKPgD21.js

@@ -0,0 +1,106 @@
+import "./_polyfill-buffer-patch-JcrfT1gU.js";
+import "./serializable-F7OtYl8d.js";
+import { v as TEMENOS_PROOF_SERVER_MODES } from "./const-BB3MccLt.js";
+import { r as midnightContextReducers, t as initialState } from "./slice-bRASyM-m.js";
+import { createMigrate } from "redux-persist";
+//#region ../../packages/contract/midnight-context/src/store/side-effects.ts
+const initializeSideEffects = () => [];
+//#endregion
+//#region ../../packages/contract/midnight-context/src/store/init.ts
+const store = async (props) => ({
+	sideEffects: initializeSideEffects(),
+	reducers: midnightContextReducers,
+	preloadedState: { midnightContext: {
+		...initialState,
+		defaultTestNetNetworkId: props.runtime.config.defaultMidnightTestnetNetworkId
+	} },
+	persistConfig: { midnightContext: {
+		version: 14,
+		whitelist: [
+			"userNetworksConfigOverrides",
+			"proofServerDisclosureAcknowledgements",
+			"isActivityPageHeaderBannerDismissed",
+			"isPortfolioBannerDismissed",
+			"dustBalanceByAccount",
+			"dustGenerationDetailsByAccount"
+		],
+		migrate: createMigrate({
+			3: (state) => {
+				const typedState = state;
+				delete typedState.networkId;
+				return typedState;
+			},
+			4: (state) => {
+				return state;
+			},
+			5: (state) => {
+				const typedState = state;
+				delete typedState.dustParameters;
+				return typedState;
+			},
+			6: (state) => {
+				return state;
+			},
+			7: (state) => {
+				const typedState = state;
+				delete typedState.dustBalance;
+				delete typedState.dustGenerationDetails;
+				typedState.dustBalanceByAccount = {};
+				typedState.dustGenerationDetailsByAccount = {};
+				return typedState;
+			},
+			8: (state) => {
+				const typedState = state;
+				delete typedState.featureFlagsNetworksConfigOverrides;
+				return typedState;
+			},
+			9: (state) => {
+				const typedState = state;
+				typedState.publicKeysByAccount = {};
+				return typedState;
+			},
+			10: (state) => {
+				const typedState = state;
+				const overrides = typedState.userNetworksConfigOverrides;
+				for (const networkId in overrides) {
+					const networkOverrides = overrides[networkId];
+					if (!networkOverrides) continue;
+					delete networkOverrides.nodeAddress;
+					delete networkOverrides.indexerAddress;
+				}
+				return typedState;
+			},
+			11: (state) => {
+				const typedState = state;
+				delete typedState.shouldAcknowledgeMidnightDisclaimer;
+				return typedState;
+			},
+			12: (state) => {
+				const typedState = state;
+				const userOverrides = typedState.userNetworksConfigOverrides;
+				if (userOverrides) for (const networkId in userOverrides) {
+					const override = userOverrides[networkId];
+					if (override) delete override.proofServerAddress;
+				}
+				return typedState;
+			},
+			13: (state) => {
+				const typedState = state;
+				for (const override of Object.values(typedState.userNetworksConfigOverrides ?? {})) if (override) delete override.proofServerAddress;
+				return typedState;
+			},
+			14: (state) => {
+				const typedState = state;
+				for (const networkId of ["mainnet", "preview"]) {
+					const override = typedState.userNetworksConfigOverrides?.[networkId];
+					const previousMode = override?.proofServer;
+					const mode = TEMENOS_PROOF_SERVER_MODES[networkId];
+					if (override && mode && previousMode?.kind === "tee-delegated" && previousMode.url === "https://api.proofserver.wastedp.io") override.proofServer = { ...mode };
+				}
+				return typedState;
+			}
+		})
+	} }
+});
+//#endregion
+export { store as default };

package/dist/init-DgzRsI-C.js

@@ -0,0 +1,141 @@
+import { t as BlockchainNetworkId } from "./blockchain-network-id.vo-C6Jowh8t.js";
+import { n as repositorySlice } from "./repo-slice-BQlssw9M.js";
+import { t as AccountId } from "./account-id.vo-KDTWJ-W5.js";
+import { createMigrate } from "redux-persist";
+//#region ../../packages/lib/util-hw/src/device-identity.ts
+const LEDGER_USB_VENDOR_ID = 11415;
+/**
+* Stable USB product identity. Ledger encodes the model in the high byte and
+* app/firmware-dependent interface flags in the low byte, so the same device
+* can report different productIds across firmware updates or open apps.
+* Masks the flag bits for Ledger (mirrors `@ledgerhq/devices`, which resolves
+* models via `productId >> 8`); other vendors keep the full productId.
+*/
+const canonicalUsbProductId = (vendorId, productId) => vendorId === LEDGER_USB_VENDOR_ID ? productId & 65280 : productId;
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/value-objects/hardware-wallet-id.vo.ts
+const USB_HW_PATTERN = /^usb-hw-(\d+)-(\d+)-(.+)$/;
+const BLE_HW_PATTERN = /^ble-(ledger|trezor)-(.+)$/;
+const USB_NO_SERIAL_SENTINEL = "no-serial";
+/**
+* The wallet ID of the hardware device a descriptor describes.
+* `HardwareWalletId.parse` reads the descriptor back from a wallet ID, or
+* returns `null` for an ID of another form.
+*/
+const HardwareWalletId = (descriptor) => {
+	switch (descriptor.kind) {
+		case "usb": return `usb-hw-${descriptor.vendorId}-${canonicalUsbProductId(descriptor.vendorId, descriptor.productId)}-${descriptor.serialNumber ?? USB_NO_SERIAL_SENTINEL}`;
+		case "ble": return `ble-${descriptor.vendorName}-${descriptor.id}`;
+	}
+};
+HardwareWalletId.parse = (walletId) => {
+	const usbMatch = USB_HW_PATTERN.exec(walletId);
+	if (usbMatch) {
+		const serialSegment = usbMatch[3];
+		return {
+			kind: "usb",
+			vendorId: Number(usbMatch[1]),
+			productId: Number(usbMatch[2]),
+			serialNumber: serialSegment === USB_NO_SERIAL_SENTINEL ? null : serialSegment
+		};
+	}
+	const bleMatch = BLE_HW_PATTERN.exec(walletId);
+	if (bleMatch) return {
+		kind: "ble",
+		vendorName: bleMatch[1],
+		id: bleMatch[2],
+		name: null
+	};
+	return null;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/3-set-blockchain-network-id.ts
+const migrateBlockchainNetworkId = (blockchainName) => {
+	switch (blockchainName) {
+		case "Cardano": return BlockchainNetworkId("cardano-1");
+		case "Midnight": return BlockchainNetworkId("midnight-preview");
+		case "Bitcoin": return BlockchainNetworkId("bitcoin-testnet4");
+	}
+};
+const setBlockchainNetworkId = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	for (const wallet of Object.values(typedState.entities)) for (const account of wallet.accounts) account.blockchainNetworkId = migrateBlockchainNetworkId(account.blockchainName);
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/4-update-midnight-account-ids.ts
+const updateMidnightAccountIds = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	for (const wallet of Object.values(typedState.entities)) for (const account of wallet.accounts) if (account.blockchainName === "Midnight") {
+		const networkId = account.blockchainSpecific.networkId;
+		account.accountId = AccountId(`${wallet.walletId}-mn-0-${networkId}`);
+	}
+	if (typedState.activeAccountContext?.accountId.endsWith("-mn")) typedState.activeAccountContext = null;
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/migrations/5-normalize-hardware-wallet-ids.ts
+/**
+* Rewrites hardware wallet ids to the canonical descriptor encoding (Ledger
+* USB productIds carry app/firmware-dependent interface bits that are now
+* masked at id construction) and merges wallet entities that collapse into
+* the same id, so devices that were duplicated by a productId drift become a
+* single wallet again. Account ids embed the wallet id as their prefix, so
+* they are rewritten along with the walletId fields.
+*/
+const normalizeHardwareWalletIds = (state) => {
+	const typedState = state;
+	if (!typedState.entities) return typedState;
+	const renames = /* @__PURE__ */ new Map();
+	for (const oldId of Object.keys(typedState.entities)) {
+		const descriptor = HardwareWalletId.parse(oldId);
+		if (!descriptor) continue;
+		const newId = HardwareWalletId(descriptor);
+		if (newId === oldId) continue;
+		renames.set(oldId, newId);
+		const wallet = typedState.entities[oldId];
+		for (const account of wallet.accounts) {
+			account.walletId = newId;
+			account.accountId = AccountId(account.accountId.replace(oldId, newId));
+		}
+		const target = typedState.entities[newId];
+		typedState.entities[newId] = target ? {
+			...target,
+			accounts: [...target.accounts, ...wallet.accounts.filter((account) => target.accounts.every((existing) => existing.accountId !== account.accountId))]
+		} : {
+			...wallet,
+			walletId: newId
+		};
+		delete typedState.entities[oldId];
+		if (typedState.activeAccountContext?.walletId === oldId) typedState.activeAccountContext = {
+			walletId: newId,
+			accountId: AccountId(typedState.activeAccountContext.accountId.replace(oldId, newId))
+		};
+	}
+	if (renames.size > 0) typedState.ids = [...new Set(typedState.ids.map((id) => renames.get(id) ?? id))];
+	return typedState;
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/persisted-migrations.ts
+/** The migrations of the persisted `wallets` state, by the version they reach. */
+const walletsMigrations = {
+	3: setBlockchainNetworkId,
+	4: updateMidnightAccountIds,
+	5: normalizeHardwareWalletIds
+};
+//#endregion
+//#region ../../packages/contract/wallet-repo/src/store/init.ts
+const walletsReducers = { wallets: repositorySlice.reducer };
+const storeExports = async () => {
+	return {
+		reducers: walletsReducers,
+		persistConfig: { wallets: {
+			version: 5,
+			migrate: createMigrate(walletsMigrations)
+		} }
+	};
+};
+//#endregion
+export { storeExports as default, walletsReducers };