@laceio/sdk 0.1.0 → 0.1.1-canary.1

package/dist/{init-DbZ5byj42.js → init-TbB38KNt2.js}

@@ -1,18 +1,24 @@
 import "./chunk-D6g4UhsZ.js";
 import "./_polyfill-buffer-patch-JcrfT1gU.js";
-import { F as RewardAddress, kt as BaseAddress, r as CredentialType, t as Address } from "./Address-_VPkf7Xh.js";
-import { a as extractUniqueStakeKeys, c as nativeScriptPolicyId, i as getTopOnChainActivity, o as UtxoCacheKey, r as groupCardanoAddressesByAccount, s as autoDismissFailureOnSuccess } from "./group-cardano-addresses-by-account-p4dXmCoj.js";
-import { t as AddressType } from "./types-B61DQoFW.js";
-import { a as isCardanoAccount, g as CardanoPaymentAddress, o as isCardanoAddress } from "./util-CQSJU0wT.js";
-import { s as Timestamp } from "./time.vo-Xln4yGBU.js";
-import { t as Err } from "./asyncoption-CzIVH5Y1.js";
-import { i as isThoroughAddressDiscoveryOperation, n as createSyncOperationId, o as parseTipHashFromOperationId, r as isAddressDiscoveryOperation, s as CardanoSyncFailureId, t as CardanoSyncOperationType } from "./sync-operation-utils-CAaCGvEN.js";
-import { t as toEmpty } from "./toEmpty-DzLd-ZCi.js";
-import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-VdbuqBsI.js";
-import { t as CardanoNetworkId } from "./cardano-network-id.vo-CTYe-Oix.js";
-import { t as CardanoTxId } from "./cardano-tx-id.vo-BMwemq5x.js";
-import { t as whileActive } from "./while-active-CNXeLxre.js";
-import { EMPTY, catchError, combineLatest, concat, distinctUntilChanged, exhaustMap, filter, forkJoin, from, ignoreElements, interval, map, merge, mergeMap, of, race, switchMap, take, takeUntil, tap, timer, toArray, withLatestFrom } from "rxjs";
+import "./dist-B00GN41m.js";
+import { Ft as BaseAddress, I as RewardAddress, r as CredentialType, t as Address } from "./Address-_c_-9hLC.js";
+import "./_web-crypto-random-bytes-BvzwTYPG.js";
+import { a as extractUniqueStakeKeys, i as getTopOnChainActivity, o as UtxoCacheKey, r as groupCardanoAddressesByAccount, s as nativeScriptPolicyId } from "./group-cardano-addresses-by-account-TqvESg9x.js";
+import { t as AddressType } from "./types-By-XeXWg.js";
+import { a as isCardanoAccount, g as CardanoPaymentAddress, o as isCardanoAddress, u as toContractAddress } from "./util-DHxtzUzY.js";
+import { s as Timestamp } from "./time.vo-C17-tYq3.js";
+import { t as Err } from "./asyncoption-DZQGfznq.js";
+import { t as autoDismissFailureOnSuccess } from "./auto-dismiss-failure-on-success-Bpod-v4r.js";
+import { t as AccountId } from "./account-id.vo-KDTWJ-W5.js";
+import { t as toEmpty } from "./toEmpty-Djj-QbpI.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Bu5Yn5ua.js";
+import { t as CardanoNetworkId } from "./cardano-network-id.vo-CeLJqmb_.js";
+import { t as CardanoTxId } from "./cardano-tx-id.vo-DJ70NC0-.js";
+import { i as isThoroughAddressDiscoveryOperation, n as createSyncOperationId, o as parseTipHashFromOperationId, r as isAddressDiscoveryOperation, s as CardanoSyncFailureId, t as CardanoSyncOperationType } from "./sync-operation-utils-BimBpvI3.js";
+import { o as isCardanoCustodyAccount, t as verifyCardanoCustodyAccountIdentity } from "./identity-DxPhxkZs.js";
+import { t as whileActive } from "./while-active-CDBnUlQA.js";
+import { t as cardanoCustodyActivityMetadataOf } from "./pending-operation-Ljijb1Uh.js";
+import { EMPTY, catchError, combineLatest, concat, distinctUntilChanged, exhaustMap, filter, forkJoin, from, ignoreElements, interval, map, merge, mergeMap, of, race, scan, switchMap, take, takeUntil, tap, throwError, timer, toArray, withLatestFrom } from "rxjs";
 //#region ../../packages/lib/core/src/address.ts
 /**
 * CIP-19 Cardano address encoding — credentials → bech32, via `@cardano-sdk/core`'s
@@ -173,46 +179,6 @@ 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) => EMPTY;
-/** The UTxO fetch of an account of a kind a feature adds: none exists. */
-const extensionAccountUtxos = (_params) => EMPTY;
-/** The sync side effects the features add: none. */
-const extensionSyncSideEffects = [];
-//#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 = nativeScriptPolicyId(paymentScript);
-	const stakingScriptHash = nativeScriptPolicyId(stakingScript);
-	const paymentScriptCredential = {
-		hash: paymentScriptHash,
-		type: CredentialType.ScriptHash
-	};
-	const stakeScriptCredential = {
-		hash: stakingScriptHash,
-		type: CredentialType.ScriptHash
-	};
-	return {
-		accountIndex: 0,
-		address: encodeBaseAddress(networkId, paymentScriptCredential, stakeScriptCredential),
-		index: 0,
-		networkId,
-		rewardAccount: encodeRewardAddress(networkId, stakeScriptCredential),
-		type: AddressType.External
-	};
-};
-//#endregion
 //#region ../../packages/module/cardano-sync/src/store/side-effects/chain-account-state-operations.ts
 /**
 * Builds the `addSyncOperation` actions that chain account-state operations
@@ -256,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 = verifyCardanoCustodyAccountIdentity(account.blockchainSpecific);
+	if (!identity.ok) {
+		logger.error(`Address discovery refused custody account ${accountId}: ${identity.error.code}`, identity.error);
+		return of(actions.sync.failSyncOperation({
+			accountId,
+			operationId,
+			error: "sync.error.address-discovery-failed"
+		}));
+	}
+	return of(actions.sync.updateSyncOperation({
+		accountId,
+		operationId,
+		update: {
+			status: "InProgress",
+			type: "Indeterminate"
+		}
+	}), actions.addresses.upsertAddresses({
+		blockchainName: "Cardano",
+		accountId,
+		addresses: [toContractAddress({
+			accountIndex: 0,
+			address: identity.value.address,
+			index: 0,
+			networkId: chainId.networkId,
+			rewardAccount: identity.value.rewardAccount,
+			type: 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 = verifyCardanoCustodyAccountIdentity(blockchainSpecific);
+	if (!identity.ok) return throwError(() => new CardanoCustodyUtxoSyncRefusedError(accountId, identity.error));
+	const { address } = identity.value;
+	const strayEntry = params.accountAddresses.find((entry) => entry.address !== CardanoPaymentAddress(address));
+	if (strayEntry) return throwError(() => new CardanoCustodyUtxoSyncRefusedError(accountId, {
+		code: "address-entry-mismatch",
+		entry: strayEntry.address,
+		derived: address
+	}));
+	return params.getUtxosAtAddress({
+		address: CardanoPaymentAddress(address),
+		withReferenceScripts: true
+	}, { chainId: blockchainSpecific.chainId }).pipe(map(throwOnError), retryBackoff(PROVIDER_REQUEST_RETRY_CONFIG), 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 = 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 = 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 = 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$ }) => combineLatest([
+	combineLatest([selectTip$, selectSyncStatusByAccount$]).pipe(scan(trackRounds, {
+		hasSeenState: false,
+		accounts: {}
+	})),
+	selectPendingActivitiesByAccount$,
+	selectAccountUtxos$,
+	selectTransactionHistoryGroupedByAccount$
+]).pipe(map(([rounds, pendingByAccount, utxosByAccount, historyByAccount]) => findExpired({
+	rounds,
+	pendingByAccount,
+	utxosByAccount,
+	historyByAccount
+})), mergeMap((expired) => from(expired.map(({ accountId, activityIds }) => actions.activities.removeActivities({
+	accountId,
+	activityIds
+})))), 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 = 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 = nativeScriptPolicyId(paymentScript);
+	const stakingScriptHash = nativeScriptPolicyId(stakingScript);
+	const paymentScriptCredential = {
+		hash: paymentScriptHash,
+		type: CredentialType.ScriptHash
+	};
+	const stakeScriptCredential = {
+		hash: stakingScriptHash,
+		type: CredentialType.ScriptHash
+	};
+	return {
+		accountIndex: 0,
+		address: encodeBaseAddress(networkId, paymentScriptCredential, stakeScriptCredential),
+		index: 0,
+		networkId,
+		rewardAccount: encodeRewardAddress(networkId, stakeScriptCredential),
+		type: 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.
@@ -458,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

package/dist/{init-BgrY29gW.js → init-dsYkC_0B.js}

@@ -1,7 +1,7 @@
-import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-VdbuqBsI.js";
-import { t as whileActive } from "./while-active-CNXeLxre.js";
-import { c as POLLING_INTERVAL_MS, i as shouldFetchPriceHistory, l as SUPPORTED_CURRENCIES_FEATURE_FLAG, o as DEFAULT_CURRENCY_PREFERENCE, r as shouldFetchPrice, u as TOKEN_PRICING_NETWORK_TYPE } from "./utils-DrtzChYN.js";
-import { r as tokenPricingReducers } from "./slice-KiNoGwD9.js";
+import { n as retryBackoff, t as PROVIDER_REQUEST_RETRY_CONFIG } from "./retry-config-Bu5Yn5ua.js";
+import { t as whileActive } from "./while-active-CDBnUlQA.js";
+import { d as TOKEN_PRICING_NETWORK_TYPE, i as shouldFetchPriceHistory, l as POLLING_INTERVAL_MS, r as shouldFetchPrice, s as DEFAULT_CURRENCY_PREFERENCE, u as SUPPORTED_CURRENCIES_FEATURE_FLAG } from "./utils-DcnoETEP.js";
+import { r as tokenPricingReducers } from "./slice-DlTEqIoI.js";
 import { EMPTY, catchError, concat, distinctUntilChanged, exhaustMap, filter, interval, map, merge, of, startWith, switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/lib/util-store/src/by-blockchain-name.ts

package/dist/{init-DvVgKCaP2.cjs → init-kVOOiU0-.cjs}

@@ -1,7 +1,7 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-const require_serializable = require("./serializable-DWgkHhv_.cjs");
-const require_key_value_store = require("./key-value-store-B-XRIwaM.cjs");
+const require_serializable = require("./serializable-n3UoxbZc.cjs");
+const require_key_value_store = require("./key-value-store-Htj4RgMe.cjs");
 //#region ../../packages/module/storage-web-indexeddb/src/storage-api-adapter.ts
 const DB_NAME = "lace-storage";
 const OBJECT_STORE_NAME = "key-value";

package/dist/{init-B5BsI3DR.cjs → init-kvn5FlPS.cjs}

@@ -1,10 +1,10 @@
 require("./chunk-9hOWP6kD.cjs");
 require("./_polyfill-buffer-patch-BycQkEkK.cjs");
-require("./serializable-DWgkHhv_.cjs");
-const require_is_redux_persist_state = require("./is-redux-persist-state-DxJSsvxB.cjs");
-const require_account_id_vo = require("./account-id.vo-Xpgnu-av.cjs");
-const require_activity_type_stable = require("./activity-type.stable-ClO9j_PH.cjs");
-const require_slice = require("./slice-exhhmucR.cjs");
+require("./serializable-n3UoxbZc.cjs");
+const require_is_redux_persist_state = require("./is-redux-persist-state-C5luvPEH.cjs");
+const require_account_id_vo = require("./account-id.vo-DYZBZQsz.cjs");
+const require_activity_type = require("./activity-type-BPXxdHBP.cjs");
+const require_slice = require("./slice-DtitVc9L.cjs");
 let redux_persist = require("redux-persist");
 //#region ../../packages/contract/activities/src/store/migrations/reset-reward-activity-dates.ts
 /**
@@ -29,7 +29,7 @@ const resetRewardActivities = (state) => {
 		const list = activitiesMap[key];
 		if (!Array.isArray(list)) continue;
 		desiredLoadedActivitiesCountPerAccount[accountId] = list.length;
-		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type_stable.ActivityType.Rewards);
+		activitiesMap[key] = list.filter((activity) => activity.type !== require_activity_type.ActivityType.Rewards);
 	}
 	return {
 		...typedState,
@@ -49,7 +49,7 @@ const rewardEpochDisplay = (state) => {
 	const activitiesMap = typedState.activities ?? {};
 	for (const list of Object.values(activitiesMap)) {
 		if (!Array.isArray(list)) continue;
-		for (const activity of list) if (activity.type === require_activity_type_stable.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
+		for (const activity of list) if (activity.type === require_activity_type.ActivityType.Rewards && activity.blockchainSpecific && typeof activity.blockchainSpecific.epoch === "number") {
 			const meta = activity.blockchainSpecific;
 			meta.epoch = meta.epoch + REWARD_EPOCH_DISPLAY_OFFSET;
 		}

package/dist/init-vfy9DW_E.js

@@ -0,0 +1,119 @@
+import { t as contextLogger } from "./logging-BAMMfn5j.js";
+import { n as Ok, t as Err } from "./asyncoption-DZQGfznq.js";
+import { i as toProviderError } from "./error-CvEYL98P.js";
+import { t as HttpClient } from "./http-client-B7_kBTYn.js";
+import { n as BitcoinNetwork } from "./types-DXSxXGz0.js";
+import { from } from "rxjs";
+import memoize from "lodash/memoize.js";
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/mempool/mempool-fee-market-provider.ts
+const MIN_FEE_RATE = 11e-6;
+const DEFAULT_MARKETS = {
+	fast: {
+		feeRate: 25e-6,
+		targetConfirmationTime: 1
+	},
+	standard: {
+		feeRate: 15e-6,
+		targetConfirmationTime: 3
+	},
+	slow: {
+		feeRate: 11e-6,
+		targetConfirmationTime: 6
+	}
+};
+/**
+* Converts a fee rate in satoshis per vbyte to BTC per kilobyte.
+* @param satsPerVByte - The fee rate in satoshis per vbyte.
+*/
+const satsPerVByteToBtcPerKB = (satsPerVByte) => satsPerVByte * 1e3 / 1e8;
+/**
+* High-level REST wrapper around Mempool.space's Bitcoin feemarket API API.
+*/
+var MempoolFeeMarketProvider = class {
+	logger;
+	#client;
+	/**
+	* Creates a new instance of the Mempool FeeMarket provider.
+	*
+	* @param client - Pre-configured HTTP client.
+	* @param logger - Any ts-log compatible logger implementation.
+	*/
+	constructor(client, logger) {
+		this.#client = client;
+		this.logger = contextLogger(logger, this.constructor.name);
+	}
+	/**
+	* Estimates the transaction fee in BTC per kilobyte based on the desired confirmation time and fee estimation mode.
+	*
+	* This method queries a blockchain fee estimation service to determine the appropriate fee
+	* rate required for a transaction to be confirmed within the specified number of blocks.
+	*
+	* @returns A promise that resolves to the estimated fee in satoshis per byte.
+	*                            This value can be used to calculate the total transaction fee
+	*                            based on the size of the transaction in bytes.
+	*/
+	async getFeeMarket(network) {
+		try {
+			if (network === BitcoinNetwork.Testnet) return DEFAULT_MARKETS;
+			const feeData = await this.request("/api/v1/fees/recommended");
+			const fastEstimate = feeData.fastestFee;
+			const standardEstimate = feeData.halfHourFee;
+			const slowEstimate = feeData.hourFee;
+			return {
+				fast: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(fastEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 600
+				},
+				standard: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(standardEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 1800
+				},
+				slow: {
+					feeRate: Math.max(satsPerVByteToBtcPerKB(slowEstimate), MIN_FEE_RATE),
+					targetConfirmationTime: 3600
+				}
+			};
+		} catch (error) {
+			this.logger.error("Failed to fetch fee market:", error);
+		}
+		return DEFAULT_MARKETS;
+	}
+	/**
+	* Performs a generic HTTP request to the Mempool.space API.
+	*/
+	async request(endpoint, options) {
+		try {
+			this.logger.debug("request", endpoint);
+			const response = await this.#client.request(endpoint, options);
+			this.logger.debug("response", JSON.stringify(response));
+			return response.data;
+		} catch (error) {
+			this.logger.debug("error", error);
+			throw toProviderError(error);
+		}
+	}
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/dependencies.ts
+const computeMaestroConfigIdentifier = ({ url }) => `${url}`;
+const getMempoolSpaceClient = memoize(({ url }) => {
+	return new HttpClient({ baseUrl: url });
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceApiProvider = memoize((config, logger) => {
+	return new MempoolFeeMarketProvider(getMempoolSpaceClient(config), logger);
+}, computeMaestroConfigIdentifier);
+const getMempoolSpaceConfig = (context, configs) => {
+	const config = configs[context.network];
+	if (!config) throw new Error(`Assertion failed: no blockfrost config found (${context.network}`);
+	return config;
+};
+const initializeDependencies = async ({ runtime: { config: { bitcoinFeeMarketProvider: { mempoolSpaceConfig } } } }, { logger }) => {
+	return { bitcoinFeeMarketProvider: { getFeeMarket: (context) => {
+		return from(getMempoolSpaceApiProvider(getMempoolSpaceConfig(context, mempoolSpaceConfig), logger).getFeeMarket(context.network).then(Ok).catch(Err));
+	} } };
+};
+//#endregion
+//#region ../../packages/module/bitcoin-mempool-fee-market/src/store/init.ts
+const redux = async (props, dependencies) => ({ sideEffectDependencies: await initializeDependencies(props, dependencies) });
+//#endregion
+export { redux as default };

package/dist/{init-BE_6Jyc4.js → init-w7xl6LsP.js}

@@ -1,6 +1,6 @@
-import { n as v4, t as init_esm_browser } from "./esm-browser-BBVQuyQv.js";
-import { a as FolderId, t as reducers } from "./slice-DaNVz7_l.js";
-import { t as firstStateOfStatus } from "./first-state-of-status-D7XzEuSa.js";
+import { n as v4, t as init_esm_browser } from "./esm-browser-DpAD_RKv.js";
+import { a as FolderId, t as reducers } from "./slice-ByNWnxKS.js";
+import { t as firstStateOfStatus } from "./first-state-of-status-BscbKj_t.js";
 import { switchMap, withLatestFrom } from "rxjs";
 import { createMigrate } from "redux-persist";
 //#region ../../packages/contract/tokens/src/store/side-effects.ts

package/dist/{init-DEsWVyn5.cjs → init-wgiBUmyW.cjs}

@@ -1,5 +1,5 @@
 require("./chunk-9hOWP6kD.cjs");
-const require_composite_signer_factory = require("./composite-signer-factory-BizuNPP7.cjs");
+const require_composite_signer_factory = require("./composite-signer-factory-v4Pxn8bA.cjs");
 //#region ../../packages/contract/signer/src/store/dependencies.ts
 const initializeSignerSideEffectDependencies = async ({ loadModules }) => {
 	return { signerFactory: new require_composite_signer_factory.CompositeSignerFactory(await loadModules("addons.loadSignerFactory")) };

package/dist/{is-retriable-error-DWv_ob-f.js → is-retriable-error-CmFR20pe.js}

@@ -1,5 +1,5 @@
 import { r as ProviderFailure } from "./errors-CAOTqN4_.js";
-import { n as errorHasReason } from "./error-DHKO2iS4.js";
+import { n as errorHasReason } from "./error-CvEYL98P.js";
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**
 * Determines if a ProviderError should be retried based on its failure type.

package/dist/{is-retriable-error-Dtb4JGjd.cjs → is-retriable-error-D2yo0_lS.cjs}

@@ -1,5 +1,5 @@
 const require_errors = require("./errors-lg3enbYs.cjs");
-const require_error = require("./error-ggOihIfv.cjs");
+const require_error = require("./error-B6wj9nPv.cjs");
 //#region ../../packages/lib/util-provider/src/is-retriable-error.ts
 /**
 * Determines if a ProviderError should be retried based on its failure type.

package/dist/jubjub-authoriser-BBJcD2uC.js

@@ -0,0 +1,85 @@
+import "./_polyfill-buffer-patch-JcrfT1gU.js";
+import { n as HexBytes, t as ByteArray } from "./bytes.vo-CziaOsba.js";
+import { t as DeviceCommitmentHex } from "./device-commitment-hex.vo-D9FsYLn7.js";
+import { t as UnknownCircuitError } from "./artefact-loader-nlsYFjxU.js";
+import { n as ROTATE_ENC_KEY_CIRCUIT, t as APPEND_INBOX_CIRCUIT } from "./enc-key-circuits-0Dud78IB.js";
+import { i as REVOKE_GRANT_CIRCUIT, n as ISSUE_GRANT_CIRCUIT, r as REVOKE_ALL_GRANTS_CIRCUIT } from "./grant-circuits-D53wmGyr.js";
+import { a as pureCircuits } from "./acc-module-ur8CkBd1.js";
+import { r as issueGrantBinding } from "./grants-ngFtS52g.js";
+//#region ../../packages/module/passport-account/src/acc/challenges.ts
+const address = (context) => ({ bytes: context.contractAddress });
+/**
+* Per-circuit challenge builders for the jubjub-gated circuits this module
+* calls. The preimage layout is produced by the contract's own exported
+* pure circuits: a per-circuit domain separation tag, the account address,
+* the signature announcement, the device public key, the circuit's
+* arguments in declaration order, the auth nonce, and the grind nonce.
+* The grant lifecycle circuits sit in the same tag family as the device
+* circuits; the issue challenge carries the grant id and the scope digest
+* rather than the scope's fields. The encryption key circuits bind the
+* key `enc_key` is replaced with and the entry appended to the inbox.
+* `activate_initial_device_with_jubjub` is permissionless and has no
+* challenge.
+*/
+const jubjubChallenges = {
+	addDevice: (context, pk, newEntry) => (sigR, grindNonce) => pureCircuits.challenge_add_device_with_jubjub(address(context), sigR, pk, newEntry, context.authNonce, grindNonce),
+	removeDevice: (context, pk, entry) => (sigR, grindNonce) => pureCircuits.challenge_remove_device_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	issueGrant: (context, pk, binding) => (sigR, grindNonce) => pureCircuits.challenge_issue_grant_with_jubjub(address(context), sigR, pk, binding.grantId, binding.scopeDigest, context.authNonce, grindNonce),
+	revokeGrant: (context, pk, grantId) => (sigR, grindNonce) => pureCircuits.challenge_revoke_grant_with_jubjub(address(context), sigR, pk, grantId, context.authNonce, grindNonce),
+	rotateEncKey: (context, pk, newKey) => (sigR, grindNonce) => pureCircuits.challenge_rotate_enc_key_with_jubjub(address(context), sigR, pk, newKey, context.authNonce, grindNonce),
+	appendInbox: (context, pk, entry) => (sigR, grindNonce) => pureCircuits.challenge_append_inbox_with_jubjub(address(context), sigR, pk, entry, context.authNonce, grindNonce),
+	revokeAllGrants: (context, pk) => (sigR, grindNonce) => pureCircuits.challenge_revoke_all_grants_with_jubjub(address(context), sigR, pk, context.authNonce, grindNonce)
+};
+//#endregion
+//#region ../../packages/module/passport-account/src/acc/jubjub-authoriser.ts
+const HEX_BYTE_PATTERN = /^(?:[0-9a-f]{2})*$/;
+const accountToBytes = (account) => {
+	if (!HEX_BYTE_PATTERN.test(account)) throw new Error(`AccAddress is not lowercase hex of whole bytes: "${account}"`);
+	return ByteArray.fromHex(HexBytes(account));
+};
+const bytesArgument = (request) => {
+	const [entry] = request.args;
+	if (!(entry instanceof Uint8Array)) throw new Error(`Circuit ${request.circuit} expects a byte-array entry as its first argument`);
+	return entry;
+};
+const noArguments = (request) => {
+	if (request.args.length > 0) throw new Error(`Circuit ${request.circuit} takes no argument`);
+};
+const challengeBuilders = {
+	add_device_with_jubjub: (context, pk, request) => jubjubChallenges.addDevice(context, pk, bytesArgument(request)),
+	remove_device_with_jubjub: (context, pk, request) => jubjubChallenges.removeDevice(context, pk, bytesArgument(request)),
+	[ISSUE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.issueGrant(context, pk, issueGrantBinding(request.args)),
+	[REVOKE_GRANT_CIRCUIT]: (context, pk, request) => jubjubChallenges.revokeGrant(context, pk, bytesArgument(request)),
+	[REVOKE_ALL_GRANTS_CIRCUIT]: (context, pk, request) => {
+		noArguments(request);
+		return jubjubChallenges.revokeAllGrants(context, pk);
+	},
+	[ROTATE_ENC_KEY_CIRCUIT]: (context, pk, request) => jubjubChallenges.rotateEncKey(context, pk, bytesArgument(request)),
+	[APPEND_INBOX_CIRCUIT]: (context, pk, request) => jubjubChallenges.appendInbox(context, pk, bytesArgument(request))
+};
+/**
+* A PassportAuthoriser over any JubJub device key source. Authorises the
+* device-management, grant lifecycle and encryption key circuits this
+* module calls and rejects everything else, including the permissionless
+* `activate_initial_device_with_jubjub`, which needs no authorisation.
+*/
+const createJubjubAuthoriser = (runWithDevice) => ({
+	scheme: "jubjub-schnorr",
+	deviceCommitment: async (account, epoch, counter) => runWithDevice((device) => DeviceCommitmentHex(HexBytes.fromByteArray(device.entryAt(accountToBytes(account), epoch, counter)))),
+	deviceCommitments: async (account, epoch, counters) => runWithDevice((device) => {
+		const accountBytes = accountToBytes(account);
+		return counters.map((counter) => DeviceCommitmentHex(HexBytes.fromByteArray(device.entryAt(accountBytes, epoch, counter))));
+	}),
+	devicePublicKey: async () => runWithDevice((device) => device.pk),
+	authorise: async (request) => runWithDevice((device) => {
+		const toBuilder = challengeBuilders[request.circuit];
+		if (!toBuilder) throw new UnknownCircuitError(request.circuit);
+		const context = {
+			contractAddress: accountToBytes(request.account),
+			authNonce: request.authNonce
+		};
+		return device.sign(toBuilder(context, device.pk, request), request.useCounter);
+	})
+});
+//#endregion
+export { createJubjubAuthoriser };