@midnight-ntwrk/wallet-sdk-dust-wallet 3.0.0 → 4.1.0

package/dist/DustWallet.d.ts

@@ -1,61 +1,77 @@
-import { type DustParameters, type DustPublicKey, DustSecretKey, type Signature, type SignatureVerifyingKey, type UnprovenTransaction } from '@midnight-ntwrk/ledger-v8';
-import { type ProtocolState, ProtocolVersion, SyncProgress } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { type Variant, type WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { type DustParameters, type DustPublicKey, DustSecretKey, type FinalizedTransaction, type Signature, type SignatureVerifyingKey, type UnprovenTransaction } from '@midnight-ntwrk/ledger-v8';
+import { type ProtocolState, ProtocolVersion, type SyncProgress } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type Variant, type VariantBuilder, type WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import * as rx from 'rxjs';
 import { type Balance, type CoinsAndBalancesCapability, type UtxoWithFullDustDetails } from './v1/CoinsAndBalances.js';
 import { CoreWallet } from './v1/CoreWallet.js';
 import { type KeysCapability } from './v1/Keys.js';
 import { type SerializationCapability } from './v1/Serialization.js';
-import { type Dust, type DustFullInfo, type UtxoWithMeta } from './v1/types/Dust.js';
+import { type NightUtxoSplitForDustRegistration } from './v1/Transacting.js';
+import { type DustFullInfo, type UtxoWithMeta } from './v1/types/Dust.js';
 import { type AnyTransaction } from './v1/types/ledger.js';
-import { type DefaultV1Configuration, type DefaultV1Variant } from './v1/V1Builder.js';
-export type DustWalletCapabilities = {
-    serialization: SerializationCapability<CoreWallet, null, string>;
+import { type BaseV1Configuration, type DefaultV1Configuration, type V1Variant } from './v1/V1Builder.js';
+import { type WalletSyncUpdate } from './v1/Sync.js';
+import { type TransactionHistoryService } from './v1/TransactionHistory.js';
+export type DustWalletCapabilities<TSerialized = string> = {
+    serialization: SerializationCapability<CoreWallet, null, TSerialized>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
 };
-export declare class DustWalletState {
-    static readonly mapState: (capabilities: DustWalletCapabilities) => (state: ProtocolState.ProtocolState<CoreWallet>) => DustWalletState;
+export type DustWalletServices = {
+    transactionHistory: TransactionHistoryService;
+};
+export declare class DustWalletState<TSerialized = string> {
+    static readonly mapState: <TSerialized_1 = string>(variant: DustWalletCapabilities<TSerialized_1> & DustWalletServices) => (state: ProtocolState.ProtocolState<CoreWallet>) => DustWalletState<TSerialized_1>;
     readonly protocolVersion: ProtocolVersion.ProtocolVersion;
     readonly state: CoreWallet;
-    readonly capabilities: DustWalletCapabilities;
-    get totalCoins(): readonly Dust[];
-    get availableCoins(): readonly Dust[];
-    get pendingCoins(): readonly Dust[];
+    readonly capabilities: DustWalletCapabilities<TSerialized>;
+    readonly services: DustWalletServices;
+    get totalCoins(): readonly DustFullInfo[];
+    get availableCoins(): readonly DustFullInfo[];
+    get pendingCoins(): readonly DustFullInfo[];
     get publicKey(): DustPublicKey;
     get address(): DustAddress;
     get progress(): SyncProgress.SyncProgress;
-    /**
-     * Transaction history for the wallet.
-     * @throws Error - Not yet implemented
-     */
-    get transactionHistory(): never;
-    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: DustWalletCapabilities);
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: DustWalletCapabilities<TSerialized>, services: DustWalletServices);
     balance(time: Date): Balance;
-    availableCoinsWithFullInfo(time: Date): readonly DustFullInfo[];
     estimateDustGeneration(nightUtxos: ReadonlyArray<UtxoWithMeta>, currentTime: Date): ReadonlyArray<UtxoWithFullDustDetails>;
-    serialize(): string;
+    serialize(): TSerialized;
 }
-export type DustWalletAPI = {
-    readonly state: rx.Observable<DustWalletState>;
-    start(secretKey: DustSecretKey): Promise<void>;
+export type DustWalletAPI<TStartAux = DustSecretKey, TSerialized = string> = {
+    readonly state: rx.Observable<DustWalletState<TSerialized>>;
+    start(secretKey: TStartAux): Promise<void>;
     createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: Array<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: DustAddress | undefined): Promise<UnprovenTransaction>;
+    splitNightUtxosForDustRegistration(currentTime: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, isRegistration: boolean): Promise<NightUtxoSplitForDustRegistration>;
+    attachDustRegistration(transaction: UnprovenTransaction, currentTime: Date, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: DustAddress | undefined, feePayment: bigint): Promise<UnprovenTransaction>;
     addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Promise<UnprovenTransaction>;
+    /**
+     * Attaches a signature to the DustRegistration in segment 1's `dustActions` only. Unlike
+     * {@link addDustGenerationSignature}, this does NOT touch the unshielded offers — those should be signed separately
+     * via the unshielded-wallet signing path. Use this when the caller orchestrates signing across both packages (e.g.
+     * the facade's `signRecipe`).
+     */
+    addDustRegistrationSignature(transaction: UnprovenTransaction, signature: Signature): Promise<UnprovenTransaction>;
     calculateFee(transactions: ReadonlyArray<AnyTransaction>): Promise<bigint>;
     estimateFee(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl?: Date, currentTime?: Date): Promise<bigint>;
     balanceTransactions(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime?: Date): Promise<UnprovenTransaction>;
-    serializeState(): Promise<string>;
-    waitForSyncedState(allowedGap?: bigint): Promise<DustWalletState>;
+    serializeState(): Promise<TSerialized>;
+    waitForSyncedState(allowedGap?: bigint): Promise<DustWalletState<TSerialized>>;
     revertTransaction(transaction: AnyTransaction): Promise<void>;
     getAddress(): Promise<DustAddress>;
     stop(): Promise<void>;
 };
-export type DustWallet = DustWalletAPI & WalletLike.WalletLike<[Variant.VersionedVariant<DefaultV1Variant>]>;
-export interface DustWalletClass extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<DefaultV1Variant>]> {
-    startWithSeed(seed: Uint8Array, dustParameters: DustParameters): DustWallet;
-    startWithSecretKey(secretKey: DustSecretKey, dustParameters: DustParameters): DustWallet;
-    restore(serializedState: string): DustWallet;
-}
+export type CustomizedDustWallet<TStartAux = DustSecretKey, TTransaction = FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> = DustWalletAPI<TStartAux, TSerialized> & WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>]>;
 export type DefaultDustConfiguration = DefaultV1Configuration;
+export interface CustomizedDustWalletClass<TStartAux = DustSecretKey, TTransaction = FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultDustConfiguration> extends WalletLike.BaseWalletClass<[
+    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
+]> {
+    configuration: TConfig;
+    startWithSeed(seed: Uint8Array, dustParameters: DustParameters): CustomizedDustWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    startWithSecretKey(secretKey: DustSecretKey, dustParameters: DustParameters): CustomizedDustWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedDustWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+}
+export type DustWallet = CustomizedDustWallet<DustSecretKey, FinalizedTransaction, WalletSyncUpdate, string>;
+export type DustWalletClass = CustomizedDustWalletClass<DustSecretKey, FinalizedTransaction, WalletSyncUpdate, string>;
 export declare function DustWallet(configuration: DefaultDustConfiguration): DustWalletClass;
+export declare function CustomDustWallet<TConfig extends BaseV1Configuration = DefaultDustConfiguration, TStartAux = DustSecretKey, TTransaction = FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TConfig>): CustomizedDustWalletClass<TStartAux, TTransaction, TSyncUpdate, TSerialized, TConfig>;

package/dist/DustWallet.js

@@ -19,12 +19,15 @@ import { CoreWallet } from './v1/CoreWallet.js';
 import { V1Tag } from './v1/RunningV1Variant.js';
 import { V1Builder } from './v1/V1Builder.js';
 export class DustWalletState {
-    static mapState = (capabilities) => (state) => {
-        return new DustWalletState(state, capabilities);
+    static mapState = (variant) => (state) => {
+        const { serialization, coinsAndBalances, keys } = variant;
+        const { transactionHistory } = variant;
+        return new DustWalletState(state, { serialization, coinsAndBalances, keys }, { transactionHistory });
     };
     protocolVersion;
     state;
     capabilities;
+    services;
     get totalCoins() {
         return this.capabilities.coinsAndBalances.getTotalCoins(this.state);
     }
@@ -43,24 +46,15 @@ export class DustWalletState {
     get progress() {
         return this.state.progress;
     }
-    /**
-     * Transaction history for the wallet.
-     * @throws Error - Not yet implemented
-     */
-    get transactionHistory() {
-        throw new Error('Transaction history is not yet implemented for DustWallet');
-    }
-    constructor(state, capabilities) {
+    constructor(state, capabilities, services) {
         this.protocolVersion = state.version;
         this.state = state.state;
         this.capabilities = capabilities;
+        this.services = services;
     }
     balance(time) {
         return this.capabilities.coinsAndBalances.getWalletBalance(this.state, time);
     }
-    availableCoinsWithFullInfo(time) {
-        return this.capabilities.coinsAndBalances.getAvailableCoinsWithFullInfo(this.state, time);
-    }
     estimateDustGeneration(nightUtxos, currentTime) {
         return this.capabilities.coinsAndBalances.estimateDustGeneration(this.state, nightUtxos, currentTime);
     }
@@ -69,26 +63,30 @@ export class DustWalletState {
     }
 }
 export function DustWallet(configuration) {
+    return CustomDustWallet(configuration, new V1Builder().withDefaults());
+}
+export function CustomDustWallet(configuration, builder) {
+    const buildArgs = [configuration];
     const BaseWallet = WalletBuilder.init()
-        .withVariant(ProtocolVersion.MinSupportedVersion, new V1Builder().withDefaults())
-        .build(configuration);
-    return class DustWalletImplementation extends BaseWallet {
+        .withVariant(ProtocolVersion.MinSupportedVersion, builder)
+        .build(...buildArgs);
+    return class CustomDustWalletImplementation extends BaseWallet {
         static startWithSeed(seed, dustParameters) {
             const dustSecretKey = DustSecretKey.fromSeed(seed);
-            return DustWalletImplementation.startFirst(DustWalletImplementation, CoreWallet.initEmpty(dustParameters, dustSecretKey, configuration.networkId));
+            return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet.initEmpty(dustParameters, dustSecretKey, CustomDustWalletImplementation.configuration.networkId));
         }
         static startWithSecretKey(secretKey, dustParameters) {
-            return DustWalletImplementation.startFirst(DustWalletImplementation, CoreWallet.initEmpty(dustParameters, secretKey, configuration.networkId));
+            return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, CoreWallet.initEmpty(dustParameters, secretKey, CustomDustWalletImplementation.configuration.networkId));
         }
         static restore(serializedState) {
-            const deserialized = DustWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
+            const deserialized = CustomDustWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
                 .pipe(Either.getOrThrow);
-            return DustWalletImplementation.startFirst(DustWalletImplementation, deserialized);
+            return CustomDustWalletImplementation.startFirst(CustomDustWalletImplementation, deserialized);
         }
         state;
         constructor(runtime, scope) {
             super(runtime, scope);
-            this.state = this.rawState.pipe(rx.map(DustWalletState.mapState(DustWalletImplementation.allVariantsRecord()[V1Tag].variant)), rx.shareReplay({ refCount: true, bufferSize: 1 }));
+            this.state = this.rawState.pipe(rx.map(DustWalletState.mapState(CustomDustWalletImplementation.allVariantsRecord()[V1Tag].variant)), rx.shareReplay({ refCount: true, bufferSize: 1 }));
         }
         start(secretKey) {
             return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground(secretKey) }).pipe(Effect.runPromise);
@@ -100,6 +98,20 @@ export function DustWallet(configuration) {
             })
                 .pipe(Effect.runPromise);
         }
+        async splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration),
+            })
+                .pipe(Effect.runPromise);
+        }
+        async attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment),
+            })
+                .pipe(Effect.runPromise);
+        }
         addDustGenerationSignature(transaction, signature) {
             return this.runtime
                 .dispatch({
@@ -107,6 +119,13 @@ export function DustWallet(configuration) {
             })
                 .pipe(Effect.runPromise);
         }
+        addDustRegistrationSignature(transaction, signature) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.addDustRegistrationSignature(transaction, signature),
+            })
+                .pipe(Effect.runPromise);
+        }
         calculateFee(transactions) {
             return this.runtime
                 .dispatch({
@@ -139,10 +158,6 @@ export function DustWallet(configuration) {
         waitForSyncedState(allowedGap = 0n) {
             return rx.firstValueFrom(this.state.pipe(rx.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
         }
-        /**
-         * Serializes the most recent state
-         * It's preferable to use [[DustWalletState.serialize]] instead, to know exactly, which state is serialized
-         */
         serializeState() {
             return rx.firstValueFrom(this.state).then((state) => state.serialize());
         }

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './DustWallet.js';
+export { type DustTransactionHistoryEntry, DustSectionSchema, mergeDustSections } from './v1/TransactionHistory.js';

package/dist/index.js

@@ -11,3 +11,4 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 export * from './DustWallet.js';
+export { DustSectionSchema, mergeDustSections } from './v1/TransactionHistory.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -1,39 +1,39 @@
-import { CoreWallet } from './CoreWallet.js';
-import { KeysCapability } from './Keys.js';
-import { DustGenerationDetails, DustGenerationInfo, Dust, DustFullInfo, UtxoWithMeta } from './types/Dust.js';
+import { type CoinRecipe } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { type CoreWallet } from './CoreWallet.js';
+import { type KeysCapability } from './Keys.js';
+import { type DustGenerationDetails, type DustGenerationInfo, type Dust, type DustFullInfo, type UtxoWithMeta } from './types/Dust.js';
 export type Balance = bigint;
 export type CoinWithValue<TToken> = {
     token: TToken;
     value: Balance;
 };
 /**
- * Type describing a Night UTxO together with details of estimated Dust generation.
- * It is meant to be primarily used for fee estimation of Dust registration transaction
+ * Type describing a Night UTxO together with details of estimated Dust generation. It is meant to be primarily used for
+ * fee estimation of Dust registration transaction
  */
 export type UtxoWithFullDustDetails = Readonly<{
     utxo: UtxoWithMeta;
     dust: DustGenerationDetails;
 }>;
-export type CoinSelection<TInput> = (coins: readonly CoinWithValue<TInput>[]) => CoinWithValue<TInput> | undefined;
-export declare const chooseCoin: <TInput>(coins: readonly CoinWithValue<TInput>[]) => CoinWithValue<TInput> | undefined;
+export type CoinSelection = <TCoin extends CoinRecipe>(coins: readonly TCoin[]) => TCoin | undefined;
+export declare const chooseCoin: CoinSelection;
 export type CoinsAndBalancesCapability<TState> = {
     getWalletBalance(state: TState, time: Date): Balance;
-    getAvailableCoins(state: TState): readonly Dust[];
-    getPendingCoins(state: TState): readonly Dust[];
-    getTotalCoins(state: TState): ReadonlyArray<Dust>;
+    getAvailableCoins(state: TState, time?: Date): readonly DustFullInfo[];
+    getPendingCoins(state: TState, time?: Date): readonly DustFullInfo[];
+    getTotalCoins(state: TState, time?: Date): ReadonlyArray<DustFullInfo>;
     getAvailableCoinsWithGeneratedDust(state: TState, currentTime: Date): ReadonlyArray<CoinWithValue<Dust>>;
-    getAvailableCoinsWithFullInfo(state: TState, blockTime: Date): readonly DustFullInfo[];
     getGenerationInfo(state: TState, coin: Dust): DustGenerationInfo | undefined;
-    /**
-     * Splits provided Night utxos into the ones that will be used as inputs in the guaranteed and fallible sections
-     */
+    /** Splits provided Night utxos into the ones that will be used as inputs in the guaranteed and fallible sections */
     splitNightUtxos(nightUtxos: ReadonlyArray<UtxoWithFullDustDetails>): {
         guaranteed: ReadonlyArray<UtxoWithFullDustDetails>;
         fallible: ReadonlyArray<UtxoWithFullDustDetails>;
     };
     /**
-     * Estimate how much Dust would be available to use if the Utxos provided were used for Dust generation from their beginning.
-     * This function is particularly useful for the purpose of registering for Dust generation and selecting the Utxo to be used for paying fees and approving the registration itself.
+     * Estimate how much Dust would be available to use if the Utxos provided were used for Dust generation from their
+     * beginning. This function is particularly useful for the purpose of registering for Dust generation and selecting
+     * the Utxo to be used for paying fees and approving the registration itself.
+     *
      * @param state Current state of the wallet
      * @param nightUtxos Existing Night utxos
      * @param currentTime Current time

package/dist/v1/CoinsAndBalances.js

@@ -13,18 +13,15 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
 import { DateOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { pipe, Array as Arr, Order } from 'effect';
-export const chooseCoin = (coins) => coins.toSorted((a, b) => Number(a.value - b.value)).at(0);
+export const chooseCoin = (coins) => coins
+    .filter((coin) => coin.value > 0n)
+    .toSorted((a, b) => Number(a.value - b.value))
+    .at(0);
 const FAKE_NONCE = '0'.repeat(64);
 export const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
     const getWalletBalance = (state, time) => {
         return state.state.walletBalance(time);
     };
-    const getAvailableCoins = (state) => {
-        const pendingSpends = new Set([...state.pendingDust.values()].map((coin) => coin.nonce));
-        return pipe(state.state.utxos, Arr.filter((coin) => !pendingSpends.has(coin.nonce)));
-    };
-    const getPendingCoins = (state) => state.pendingDust;
-    const getTotalCoins = (state) => [...getAvailableCoins(state), ...getPendingCoins(state)];
     const getGenerationInfo = (state, coin) => {
         const info = state.state.generationInfo(coin);
         return info && info.dtime
@@ -34,32 +31,22 @@ export const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
             }
             : info;
     };
-    const getAvailableCoinsWithGeneratedDust = (state, currentTime) => {
-        const result = [];
-        const available = getAvailableCoins(state);
-        for (const coin of available) {
-            const genInfo = getGenerationInfo(state, coin);
-            if (genInfo) {
-                const generatedValue = ledger.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, state.state.params);
-                result.push({ token: coin, value: generatedValue });
-            }
-        }
-        return result;
+    const resolveTime = (state, time) => time ?? state.state.syncTime;
+    const toFullInfo = (state, coins, time) => coins.flatMap((coin) => {
+        const genInfo = getGenerationInfo(state, coin);
+        return genInfo ? [{ token: coin, ...getFullDustInfo(state.state.params, genInfo, coin, time) }] : [];
+    });
+    const availableDustTokens = (state) => {
+        const pendingSpends = new Set([...state.pendingDust.values()].map((coin) => coin.nonce));
+        return pipe(state.state.utxos, Arr.filter((coin) => !pendingSpends.has(coin.nonce)));
     };
-    const getAvailableCoinsWithFullInfo = (state, blockTime) => {
-        const result = [];
-        const available = getAvailableCoins(state);
-        for (const coin of available) {
-            const genInfo = getGenerationInfo(state, coin);
-            if (genInfo) {
-                result.push({
-                    token: coin,
-                    ...getFullDustInfo(state.state.params, genInfo, coin, blockTime),
-                });
-            }
-        }
-        return result;
+    const getAvailableCoins = (state, time) => toFullInfo(state, availableDustTokens(state), resolveTime(state, time));
+    const getPendingCoins = (state, time) => toFullInfo(state, state.pendingDust, resolveTime(state, time));
+    const getTotalCoins = (state, time) => {
+        const effectiveTime = resolveTime(state, time);
+        return [...getAvailableCoins(state, effectiveTime), ...getPendingCoins(state, effectiveTime)];
     };
+    const getAvailableCoinsWithGeneratedDust = (state, currentTime) => getAvailableCoins(state, currentTime).map((info) => ({ token: info.token, value: info.generatedNow }));
     const getFullDustInfo = (parameters, genInfo, coin, currentTime) => {
         const generatedValue = ledger.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, parameters);
         return {
@@ -79,9 +66,7 @@ export const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
             return { utxo, dust: details };
         }));
     };
-    /**
-     * Create a fake generation info for a given Utxo. It allows to estimate the Dust generation from it
-     */
+    /** Create a fake generation info for a given Utxo. It allows to estimate the Dust generation from it */
     const fakeGenerationInfo = (utxo, dustPublicKey) => {
         return {
             value: utxo.value,
@@ -90,9 +75,7 @@ export const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
             dtime: undefined,
         };
     };
-    /**
-     * Create a fake dust coin for a given Utxo. It allows to estimate full details of the Dust generation from it
-     */
+    /** Create a fake dust coin for a given Utxo. It allows to estimate full details of the Dust generation from it */
     const fakeDustToken = (dustPublicKey, utxo) => ({
         initialValue: 0n,
         owner: dustPublicKey,
@@ -112,7 +95,6 @@ export const makeDefaultCoinsAndBalancesCapability = (_config, getContext) => {
         getPendingCoins,
         getTotalCoins,
         getAvailableCoinsWithGeneratedDust,
-        getAvailableCoinsWithFullInfo,
         getGenerationInfo,
         estimateDustGeneration,
         splitNightUtxos,

package/dist/v1/CoreWallet.d.ts

@@ -1,8 +1,8 @@
-import { Bindingish, DustLocalState, DustNullifier, DustParameters, DustPublicKey, DustSecretKey, Proofish, Signaturish, Transaction, Event } from '@midnight-ntwrk/ledger-v8';
+import { type Bindingish, DustLocalState, type DustNullifier, type DustParameters, type DustPublicKey, type DustSecretKey, type DustStateChanges, type Proofish, type Signaturish, type Transaction, type Event } from '@midnight-ntwrk/ledger-v8';
 import { ProtocolVersion, SyncProgress } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { Dust, DustWithNullifier } from './types/Dust.js';
-import { CoinWithValue } from './CoinsAndBalances.js';
-import { NetworkId, UnprovenDustSpend } from './types/ledger.js';
+import { type Dust, type DustWithNullifier } from './types/Dust.js';
+import { type CoinWithValue } from './CoinsAndBalances.js';
+import { type NetworkId, type UnprovenDustSpend } from './types/ledger.js';
 export type PublicKey = {
     publicKey: DustPublicKey;
 };
@@ -22,7 +22,7 @@ export declare const CoreWallet: {
     initEmpty(dustParameters: DustParameters, secretKey: DustSecretKey, networkId: NetworkId): CoreWallet;
     empty(localState: DustLocalState, publicKey: PublicKey, networkId: NetworkId): CoreWallet;
     restore(localState: DustLocalState, publicKey: PublicKey, pendingTokens: Array<DustWithNullifier>, syncProgress: Omit<SyncProgress.SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: NetworkId): CoreWallet;
-    applyEvents(wallet: CoreWallet, secretKey: DustSecretKey, events: Event[], currentTime: Date): CoreWallet;
+    applyEventsWithChanges(wallet: CoreWallet, secretKey: DustSecretKey, events: Event[], currentTime: Date): [CoreWallet, DustStateChanges[]];
     applyFailed(wallet: CoreWallet, tx: Transaction<Signaturish, Proofish, Bindingish>): CoreWallet;
     revertTransaction<TTransaction extends Transaction<Signaturish, Proofish, Bindingish>>(wallet: CoreWallet, tx: TTransaction): CoreWallet;
     updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgress.SyncProgressData>): CoreWallet;

package/dist/v1/CoreWallet.js

@@ -48,15 +48,19 @@ export const CoreWallet = {
             protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
         };
     },
-    applyEvents(wallet, secretKey, events, currentTime) {
+    applyEventsWithChanges(wallet, secretKey, events, currentTime) {
         // TODO: replace currentTime with `updatedState.syncTime` introduced in ledger-6.2.0-rc.1
-        const updatedState = wallet.state.replayEvents(secretKey, events).processTtls(currentTime);
+        const stateWithChanges = wallet.state.replayEventsWithChanges(secretKey, events);
+        const updatedState = stateWithChanges.state.processTtls(currentTime);
         const availableNonces = updatedState.utxos.map((utxo) => utxo.nonce);
-        return {
-            ...wallet,
-            state: updatedState,
-            pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce)),
-        };
+        return [
+            {
+                ...wallet,
+                state: updatedState,
+                pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce)),
+            },
+            stateWithChanges.changes,
+        ];
     },
     applyFailed(wallet, tx) {
         const pendingSpendsMap = CoreWallet.pendingDustToMap(wallet.pendingDust);

package/dist/v1/Keys.d.ts

@@ -1,6 +1,6 @@
-import { DustPublicKey } from '@midnight-ntwrk/ledger-v8';
+import { type DustPublicKey } from '@midnight-ntwrk/ledger-v8';
 import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { CoreWallet } from './CoreWallet.js';
+import { type CoreWallet } from './CoreWallet.js';
 export type KeysCapability<TState> = {
     getPublicKey(state: TState): DustPublicKey;
     getAddress(state: TState): DustAddress;

package/dist/v1/RunningV1Variant.d.ts

@@ -1,26 +1,28 @@
 import { Effect, Stream, Scope } from 'effect';
+import { type TransactionHistoryService } from './TransactionHistory.js';
 import { type DustSecretKey, type Signature, type SignatureVerifyingKey, type FinalizedTransaction, type UnprovenTransaction } from '@midnight-ntwrk/ledger-v8';
-import { WalletError } from './WalletError.js';
+import { type WalletError } from './WalletError.js';
 import { type WalletRuntimeError, type Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
-import { type Dust, type UtxoWithMeta } from './types/Dust.js';
+import { type UtxoWithMeta } from './types/Dust.js';
 import { type KeysCapability } from './Keys.js';
-import { type SyncCapability, type SyncService } from './Sync.js';
-import { type SimulatorState } from './Simulator.js';
+import { type ChangesResult, type SyncCapability, type SyncService } from './Sync.js';
+import { type SimulatorState } from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
 import { type CoinsAndBalancesCapability, type CoinSelection } from './CoinsAndBalances.js';
-import { type TransactingCapability } from './Transacting.js';
+import { type NightUtxoSplitForDustRegistration, type TransactingCapability } from './Transacting.js';
 import { type CoreWallet } from './CoreWallet.js';
 import { type SerializationCapability } from './Serialization.js';
 import { type AnyTransaction } from './types/ledger.js';
-import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 export declare namespace RunningV1Variant {
     type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
         serializationCapability: SerializationCapability<CoreWallet, null, TSerialized>;
         syncService: SyncService<CoreWallet, TStartAux, TSyncUpdate>;
-        syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
+        syncCapability: SyncCapability<CoreWallet, TSyncUpdate, ChangesResult>;
         transactingCapability: TransactingCapability<DustSecretKey, CoreWallet, TTransaction>;
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
-        coinSelection: CoinSelection<Dust>;
+        coinSelection: CoinSelection;
+        transactionHistoryService: TransactionHistoryService;
     };
     type AnyContext = Context<any, any, any, any>;
 }
@@ -34,7 +36,10 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError, Scope.Scope>;
     createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: DustAddress | undefined): Effect.Effect<UnprovenTransaction, WalletError>;
+    splitNightUtxosForDustRegistration(currentTime: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, isRegistration: boolean): Effect.Effect<NightUtxoSplitForDustRegistration, WalletError>;
+    attachDustRegistration(transaction: UnprovenTransaction, currentTime: Date, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: DustAddress | undefined, feePayment: bigint): Effect.Effect<UnprovenTransaction, WalletError>;
     addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Effect.Effect<UnprovenTransaction, WalletError>;
+    addDustRegistrationSignature(transaction: UnprovenTransaction, signature: Signature): Effect.Effect<UnprovenTransaction, WalletError>;
     calculateFee(transactions: ReadonlyArray<AnyTransaction>): Effect.Effect<bigint, WalletError>;
     estimateFee(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime?: Date): Effect.Effect<bigint, WalletError>;
     balanceTransactions(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime?: Date): Effect.Effect<UnprovenTransaction, WalletError>;

package/dist/v1/RunningV1Variant.js

@@ -62,15 +62,16 @@ export class RunningV1Variant {
         return this.startSync(startAux).pipe(Stream.runScoped(Sink.drain), Effect.forkScoped, Effect.provideService(Scope.Scope, this.#scope));
     }
     startSync(startAux) {
-        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), Stream.mapEffect((update) => {
-            return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => Effect.try({
-                try: () => this.#v1Context.syncCapability.applyUpdate(state, update),
-                catch: (err) => new OtherWalletError({
-                    message: 'Error while applying sync update',
-                    cause: err,
-                }),
-            }));
-        }), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
+        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state, startAux)), Stream.mapEffect((update) => SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => Effect.try({
+            try: () => {
+                const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update);
+                return [changesResult, newState];
+            },
+            catch: (err) => new OtherWalletError({
+                message: 'Error while applying sync update',
+                cause: err,
+            }),
+        })).pipe(Effect.flatMap(({ changes, protocolVersion }) => pipe(Effect.forEach(changes, (change) => pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), Effect.flatMap((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)), Effect.catchAllCause((cause) => Console.error('Error processing tx history metadata', cause))), { discard: true, concurrency: 'unbounded' }), Effect.forkScoped)), Effect.provideService(Scope.Scope, this.#scope))), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
             const maxDelay = Duration.minutes(2);
             const jitter = Duration.millis(Math.floor(Math.random() * 1000));
             const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);
@@ -81,19 +82,41 @@ export class RunningV1Variant {
         if (nightUtxos.some((utxo) => utxo.type !== nativeToken().raw)) {
             return Effect.fail(new OtherWalletError({ message: 'Token of a non-Night type received' }));
         }
-        return Effect.Do.pipe(Effect.bind('currentState', () => SubscriptionRef.get(this.#context.stateRef)), Effect.bind('blockData', () => this.#v1Context.syncService.blockData()), Effect.let('currentTime', ({ blockData }) => currentTime ?? blockData.timestamp), Effect.let('utxosWithDustValue', ({ currentState, currentTime }) => {
-            return this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
-        }), Effect.flatMap(({ utxosWithDustValue, currentTime }) => {
-            return this.#v1Context.transactingCapability
-                .createDustGenerationTransaction(currentTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
+        return Effect.gen(this, function* () {
+            const currentState = yield* SubscriptionRef.get(this.#context.stateRef);
+            const blockData = yield* this.#v1Context.syncService.blockData();
+            const resolvedTime = currentTime ?? blockData.timestamp;
+            const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, resolvedTime);
+            return yield* this.#v1Context.transactingCapability
+                .createDustGenerationTransaction(resolvedTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
                 .pipe(EitherOps.toEffect);
-        }));
+        });
+    }
+    splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+        if (nightUtxos.some((utxo) => utxo.type !== nativeToken().raw)) {
+            return Effect.fail(new OtherWalletError({ message: 'Token of a non-Night type received' }));
+        }
+        return Effect.gen(this, function* () {
+            const currentState = yield* SubscriptionRef.get(this.#context.stateRef);
+            const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
+            return this.#v1Context.transactingCapability.splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration);
+        });
+    }
+    attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+        return this.#v1Context.transactingCapability
+            .attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment)
+            .pipe(EitherOps.toEffect);
     }
     addDustGenerationSignature(transaction, signature) {
         return this.#v1Context.transactingCapability
             .addDustGenerationSignature(transaction, signature)
             .pipe(EitherOps.toEffect);
     }
+    addDustRegistrationSignature(transaction, signature) {
+        return this.#v1Context.transactingCapability
+            .addDustRegistrationSignature(transaction, signature)
+            .pipe(EitherOps.toEffect);
+    }
     calculateFee(transactions) {
         return pipe(this.#v1Context.syncService.blockData(), Effect.map((blockData) => pipe(transactions, Arr.map((transaction) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)), ArrayOps.sumBigInt)));
     }

package/dist/v1/Serialization.d.ts

@@ -1,5 +1,5 @@
 import { Either, Schema } from 'effect';
-import { WalletError } from './WalletError.js';
+import { type WalletError } from './WalletError.js';
 import { CoreWallet } from './CoreWallet.js';
 export type SerializationCapability<TWallet, TAux, TSerialized> = {
     serialize(wallet: TWallet): TSerialized;