@laceio/sdk 0.1.0 → 0.1.1-canary.0

package/dist/{const-DVW6DGkZ.js → const-xGSNCtwQ.js}

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

package/dist/contract-BsIGhsYa.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-BneJm7ey.js";
+import { a as inferStoreContext, n as combineContracts, r as inferContractContext } from "./store-AUlTfcI_.js";
+import { t as createSelector } from "./reselect-JIgawvPe.js";
+import { r as tokensSelectors } from "./slice-ByNWnxKS.js";
+import { r as addressBookSelectors, t as addressBookActions } from "./slice-5dGBAz6w.js";
+import { c as FIAT_CURRENCIES, s as DEFAULT_CURRENCY_PREFERENCE, t as calculatePortfolioValueOverTime } from "./utils-DcnoETEP.js";
+import { n as tokenPricingActions, t as slice } from "./slice-DlTEqIoI.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-BAWMHL1k.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-dsYkC_0B.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-DD6CGnpB.cjs

@@ -0,0 +1,189 @@
+const require_sdk = require("./sdk-1SRu8Ype.cjs");
+const require_store = require("./store-C7AneHEY.cjs");
+const require_reselect = require("./reselect-kP4DaAII.cjs");
+const require_slice = require("./slice-Bf4enJKZ.cjs");
+const require_slice$1 = require("./slice-BzJgg9FS.cjs");
+const require_utils = require("./utils-DYf4iZKX.cjs");
+const require_slice$2 = require("./slice-C8YVv4Qn.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-BewG6swt.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-CqqmtAIK.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;
+	}
+});

package/dist/create-add-accounts-2mQA0ST2.js

@@ -0,0 +1,102 @@
+import { n as import_buffer, r as init__polyfill_buffer_patch } from "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { t as SecretBox } from "./secret-box-CSmRp6Tt.js";
+import { CustomError } from "ts-custom-error";
+//#region ../../packages/contract/network/src/resolve-blockchain-network-targets.ts
+/**
+* Returns a function that resolves an optional set of Lace
+* {@link BlockchainNetworkId} values to chain-specific representations using a
+* lookup map, with the same semantics as the in-memory wallet integrations:
+*
+* - `targets` undefined → all supported targets (the provided default list)
+* - empty set → throws
+* - non-empty set → each id must exist in the map or throws
+*/
+const createBlockchainNetworkTargetResolver = (supportedByBlockchainNetworkId, defaultForAllSupported) => (targets) => {
+	if (targets === void 0) return [...defaultForAllSupported];
+	if (targets.size === 0) throw new Error("Empty target networks");
+	return Array.from(targets, (id) => {
+		const resolved = supportedByBlockchainNetworkId.get(id);
+		if (resolved === void 0) throw new Error(`Invalid network id: ${id}`);
+		return resolved;
+	});
+};
+//#endregion
+//#region ../../packages/contract/in-memory/src/create-add-accounts.ts
+init__polyfill_buffer_patch();
+/**
+* Thrown when adding an account on a new blockchain requires deriving a
+* root key from the mnemonic, but the wallet has none (Nami-imported).
+*/
+var RecoveryPhraseUnavailableError = class extends CustomError {
+	constructor() {
+		super("Cannot derive a new blockchain root key: this wallet has no mnemonic stored");
+	}
+};
+/**
+* Creates a type-safe function to get blockchain-specific data from a wallet.
+*/
+const createGetBlockchainData = (blockchainName) => (wallet) => {
+	return wallet.blockchainSpecific[blockchainName];
+};
+/**
+* Factory function that creates a standardized `addAccounts` implementation.
+*
+* Handles both scenarios:
+* - Existing blockchain: uses wallet's blockchainSpecific data to derive the accounts
+* - New blockchain: decrypts wallet's recoveryPhrase, creates blockchain data, creates accounts
+*
+* Returns a wallet with merged accounts and blockchainSpecific data.
+*
+* @example
+* ```typescript
+* export const addAccounts = createAddAccounts({
+*   blockchainName: 'Cardano',
+*   createAccounts,
+*   createBlockchainSpecificWalletData,
+* });
+* ```
+*/
+const createAddAccounts = ({ blockchainName, createAccounts, createBlockchainSpecificWalletData }) => {
+	const getBlockchainData = createGetBlockchainData(blockchainName);
+	return async (props, dependencies) => {
+		const { wallet, accountIndex, password, accountName, targetNetworks } = props;
+		let blockchainSpecificData = getBlockchainData(wallet);
+		let newBlockchainSpecificWalletData;
+		if (!blockchainSpecificData) {
+			if (!wallet.encryptedRecoveryPhrase) throw new RecoveryPhraseUnavailableError();
+			const recoveryPhraseBytes = await SecretBox.open(import_buffer.Buffer.from(wallet.encryptedRecoveryPhrase, "hex"), password);
+			const recoveryPhraseBuffer = import_buffer.Buffer.from(recoveryPhraseBytes);
+			try {
+				const recoveryPhrase = recoveryPhraseBuffer.toString("utf8").split(" ");
+				blockchainSpecificData = await createBlockchainSpecificWalletData({
+					walletId: wallet.walletId,
+					password,
+					recoveryPhrase
+				}, dependencies);
+				newBlockchainSpecificWalletData = blockchainSpecificData;
+			} finally {
+				recoveryPhraseBytes.fill(0);
+				recoveryPhraseBuffer.fill(0);
+			}
+		}
+		const newAccounts = await createAccounts({
+			blockchainSpecific: blockchainSpecificData,
+			accountIndex,
+			walletId: wallet.walletId,
+			blockchainName,
+			password,
+			accountName,
+			targetNetworks
+		}, dependencies);
+		return { wallet: {
+			...wallet,
+			accounts: [...wallet.accounts, ...newAccounts],
+			...newBlockchainSpecificWalletData && { blockchainSpecific: {
+				...wallet.blockchainSpecific,
+				[blockchainName]: newBlockchainSpecificWalletData
+			} }
+		} };
+	};
+};
+//#endregion
+export { createBlockchainNetworkTargetResolver as n, createAddAccounts as t };

package/dist/create-add-accounts-B6mR2NMn.cjs

@@ -0,0 +1,114 @@
+require("./chunk-9hOWP6kD.cjs");
+const require__polyfill_buffer_patch = require("./_polyfill-buffer-patch-BycQkEkK.cjs");
+const require_secret_box = require("./secret-box-ZfbYwBgS.cjs");
+let ts_custom_error = require("ts-custom-error");
+//#region ../../packages/contract/network/src/resolve-blockchain-network-targets.ts
+/**
+* Returns a function that resolves an optional set of Lace
+* {@link BlockchainNetworkId} values to chain-specific representations using a
+* lookup map, with the same semantics as the in-memory wallet integrations:
+*
+* - `targets` undefined → all supported targets (the provided default list)
+* - empty set → throws
+* - non-empty set → each id must exist in the map or throws
+*/
+const createBlockchainNetworkTargetResolver = (supportedByBlockchainNetworkId, defaultForAllSupported) => (targets) => {
+	if (targets === void 0) return [...defaultForAllSupported];
+	if (targets.size === 0) throw new Error("Empty target networks");
+	return Array.from(targets, (id) => {
+		const resolved = supportedByBlockchainNetworkId.get(id);
+		if (resolved === void 0) throw new Error(`Invalid network id: ${id}`);
+		return resolved;
+	});
+};
+//#endregion
+//#region ../../packages/contract/in-memory/src/create-add-accounts.ts
+require__polyfill_buffer_patch.init__polyfill_buffer_patch();
+/**
+* Thrown when adding an account on a new blockchain requires deriving a
+* root key from the mnemonic, but the wallet has none (Nami-imported).
+*/
+var RecoveryPhraseUnavailableError = class extends ts_custom_error.CustomError {
+	constructor() {
+		super("Cannot derive a new blockchain root key: this wallet has no mnemonic stored");
+	}
+};
+/**
+* Creates a type-safe function to get blockchain-specific data from a wallet.
+*/
+const createGetBlockchainData = (blockchainName) => (wallet) => {
+	return wallet.blockchainSpecific[blockchainName];
+};
+/**
+* Factory function that creates a standardized `addAccounts` implementation.
+*
+* Handles both scenarios:
+* - Existing blockchain: uses wallet's blockchainSpecific data to derive the accounts
+* - New blockchain: decrypts wallet's recoveryPhrase, creates blockchain data, creates accounts
+*
+* Returns a wallet with merged accounts and blockchainSpecific data.
+*
+* @example
+* ```typescript
+* export const addAccounts = createAddAccounts({
+*   blockchainName: 'Cardano',
+*   createAccounts,
+*   createBlockchainSpecificWalletData,
+* });
+* ```
+*/
+const createAddAccounts = ({ blockchainName, createAccounts, createBlockchainSpecificWalletData }) => {
+	const getBlockchainData = createGetBlockchainData(blockchainName);
+	return async (props, dependencies) => {
+		const { wallet, accountIndex, password, accountName, targetNetworks } = props;
+		let blockchainSpecificData = getBlockchainData(wallet);
+		let newBlockchainSpecificWalletData;
+		if (!blockchainSpecificData) {
+			if (!wallet.encryptedRecoveryPhrase) throw new RecoveryPhraseUnavailableError();
+			const recoveryPhraseBytes = await require_secret_box.SecretBox.open(require__polyfill_buffer_patch.import_buffer.Buffer.from(wallet.encryptedRecoveryPhrase, "hex"), password);
+			const recoveryPhraseBuffer = require__polyfill_buffer_patch.import_buffer.Buffer.from(recoveryPhraseBytes);
+			try {
+				const recoveryPhrase = recoveryPhraseBuffer.toString("utf8").split(" ");
+				blockchainSpecificData = await createBlockchainSpecificWalletData({
+					walletId: wallet.walletId,
+					password,
+					recoveryPhrase
+				}, dependencies);
+				newBlockchainSpecificWalletData = blockchainSpecificData;
+			} finally {
+				recoveryPhraseBytes.fill(0);
+				recoveryPhraseBuffer.fill(0);
+			}
+		}
+		const newAccounts = await createAccounts({
+			blockchainSpecific: blockchainSpecificData,
+			accountIndex,
+			walletId: wallet.walletId,
+			blockchainName,
+			password,
+			accountName,
+			targetNetworks
+		}, dependencies);
+		return { wallet: {
+			...wallet,
+			accounts: [...wallet.accounts, ...newAccounts],
+			...newBlockchainSpecificWalletData && { blockchainSpecific: {
+				...wallet.blockchainSpecific,
+				[blockchainName]: newBlockchainSpecificWalletData
+			} }
+		} };
+	};
+};
+//#endregion
+Object.defineProperty(exports, "createAddAccounts", {
+	enumerable: true,
+	get: function() {
+		return createAddAccounts;
+	}
+});
+Object.defineProperty(exports, "createBlockchainNetworkTargetResolver", {
+	enumerable: true,
+	get: function() {
+		return createBlockchainNetworkTargetResolver;
+	}
+});

package/dist/{delegation-tx-builder-CF0VunDW.cjs → delegation-tx-builder-Cp30jtj9.cjs}

@@ -1,12 +1,13 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_Address = require("./Address-4KjeDt_x.cjs");
-const require_PaymentAddress = require("./PaymentAddress-DhbtuYb7.cjs");
-const require_util = require("./util-P4PX2muj.cjs");
-const require_bignum_vo = require("./bignum.vo-CpkrIXjH.cjs");
-const require_const = require("./const-Dy8Ctnpd.cjs");
-const require_TransactionBuilder = require("./TransactionBuilder-CeJTNzm-.cjs");
-const require_account_guards_stable = require("./account-guards.stable-BKyYPj4z.cjs");
+require("./dist-MJof_Ky1.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_PaymentAddress = require("./PaymentAddress-B4n1KZMx.cjs");
+const require_util = require("./util-D1YlKzrc.cjs");
+const require_bignum_vo = require("./bignum.vo-Du-bpvar.cjs");
+const require_const = require("./const-D3mCkwrM.cjs");
+const require_TransactionBuilder = require("./TransactionBuilder-BakTJvsJ.cjs");
+const require_account_guards = require("./account-guards-BeKbV9D1.cjs");
 let rxjs = require("rxjs");
 let rxjs_operators = require("rxjs/operators");
 //#region ../../packages/module/blockchain-cardano/src/tx-executor-implementation/build-delegation-tx.ts
@@ -46,7 +47,7 @@ const makeBuildDelegationTx = (dependencies) => (params) => (0, rxjs.defer)(asyn
 		success: false,
 		error: /* @__PURE__ */ new Error("Protocol parameters not available")
 	};
-	require_account_guards_stable.refuseExtensionAccount(accountId, cardanoAddresses);
+	require_account_guards.refuseExtensionAccount(accountId, cardanoAddresses);
 	const availableUtxo = require_util.filterSpendableUtxos(allAccountUtxos[accountId] ?? [], unspendableAccountUtxos[accountId] ?? []);
 	const accountAddresses = cardanoAddresses.filter((addr) => addr.accountId === accountId && addr.blockchainName === "Cardano");
 	if (!accountAddresses[0]) return {

package/dist/{delegation-tx-builder-C8LQxU2R.js → delegation-tx-builder-DUMikSTg.js}

@@ -1,11 +1,13 @@
 import "./_polyfill-buffer-patch-JcrfT1gU.js";
-import { t as Address } from "./Address-_VPkf7Xh.js";
-import { t as PaymentAddress } from "./PaymentAddress-xSmGUQ-8.js";
-import { n as filterSpendableUtxos } from "./util-CQSJU0wT.js";
-import { t as BigNumber } from "./bignum.vo-DhhZ9HP1.js";
-import { r as LOVELACE_TOKEN_ID } from "./const-DeUA7zYl.js";
-import { t as TransactionBuilder } from "./TransactionBuilder-DGNDM4kt.js";
-import { t as refuseExtensionAccount } from "./account-guards.stable-BdmQ43vC.js";
+import "./dist-B00GN41m.js";
+import { t as Address } from "./Address-_c_-9hLC.js";
+import "./_web-crypto-random-bytes-BvzwTYPG.js";
+import { t as PaymentAddress } from "./PaymentAddress-Cml3EA1n.js";
+import { n as filterSpendableUtxos } from "./util-DHxtzUzY.js";
+import { t as BigNumber } from "./bignum.vo-Co6tMH2q.js";
+import { r as LOVELACE_TOKEN_ID } from "./const-DbuUHSzR.js";
+import { n as TransactionBuilder } from "./TransactionBuilder-D2ErwVWv.js";
+import { t as refuseExtensionAccount } from "./account-guards-qnFXuXSE.js";
 import { defer, firstValueFrom, of } from "rxjs";
 import { catchError as catchError$1 } from "rxjs/operators";
 //#region ../../packages/module/blockchain-cardano/src/tx-executor-implementation/build-delegation-tx.ts

package/dist/{deregistration-tx-builder-DcUXA3Ls.cjs → deregistration-tx-builder-B-ZeY-dR.cjs}

@@ -1,13 +1,14 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_Address = require("./Address-4KjeDt_x.cjs");
-const require_ChainId = require("./ChainId-sdLmlIRk.cjs");
-const require_PaymentAddress = require("./PaymentAddress-DhbtuYb7.cjs");
-const require_util = require("./util-P4PX2muj.cjs");
-const require_bignum_vo = require("./bignum.vo-CpkrIXjH.cjs");
-const require_const = require("./const-Dy8Ctnpd.cjs");
-const require_TransactionBuilder = require("./TransactionBuilder-CeJTNzm-.cjs");
-const require_account_guards_stable = require("./account-guards.stable-BKyYPj4z.cjs");
+require("./dist-MJof_Ky1.cjs");
+const require_Address = require("./Address-AMKTo-dA.cjs");
+const require_ChainId = require("./ChainId-CNPSU9nn.cjs");
+const require_PaymentAddress = require("./PaymentAddress-B4n1KZMx.cjs");
+const require_util = require("./util-D1YlKzrc.cjs");
+const require_bignum_vo = require("./bignum.vo-Du-bpvar.cjs");
+const require_const = require("./const-D3mCkwrM.cjs");
+const require_TransactionBuilder = require("./TransactionBuilder-BakTJvsJ.cjs");
+const require_account_guards = require("./account-guards-BeKbV9D1.cjs");
 let rxjs = require("rxjs");
 let rxjs_operators = require("rxjs/operators");
 //#region ../../packages/module/blockchain-cardano/src/tx-executor-implementation/build-deregistration-tx.ts
@@ -62,7 +63,7 @@ const makeBuildDeregistrationTx = (dependencies) => (params) => (0, rxjs.defer)(
 		success: false,
 		error: /* @__PURE__ */ new Error("Protocol parameters not available")
 	};
-	require_account_guards_stable.refuseExtensionAccount(accountId, cardanoAddresses);
+	require_account_guards.refuseExtensionAccount(accountId, cardanoAddresses);
 	const availableUtxo = require_util.filterSpendableUtxos(allAccountUtxos[accountId] ?? [], unspendableAccountUtxos[accountId] ?? []);
 	const accountAddresses = cardanoAddresses.filter((addr) => addr.accountId === accountId && addr.blockchainName === "Cardano");
 	if (!accountAddresses[0]) return {