@midnight-ntwrk/wallet-sdk-dust-wallet 1.0.0-beta.8 → 1.0.0

package/README.md

@@ -1,3 +1,98 @@
-# Wallet SDK Dust Wallet
+# @midnight-ntwrk/wallet-sdk-dust-wallet
 
-TBD
+Manages dust tokens (transaction fees) on the Midnight network.
+
+## Installation
+
+```bash
+npm install @midnight-ntwrk/wallet-sdk-dust-wallet
+```
+
+## Overview
+
+The Dust Wallet handles dust operations on the Midnight network. Dust tokens are required to pay transaction fees. This
+package provides:
+
+- Dust coin management and tracking
+- Balance synchronization with the network
+- Transaction fee calculation
+- Dust generation from Night UTXOs
+- Fee balancing for transactions
+
+## Usage
+
+### Starting the Wallet
+
+```typescript
+import { DustWallet } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+
+await dustWallet.start(dustSecretKey);
+```
+
+### Observing State
+
+```typescript
+dustWallet.state.subscribe((state) => {
+  console.log('Progress:', state.state.progress);
+  console.log('Balance:', state.state.balance);
+  console.log('Dust Address:', state.dustAddress);
+});
+
+// Or wait for sync
+const syncedState = await dustWallet.waitForSyncedState();
+```
+
+### Balancing Transaction Fees
+
+```typescript
+// Add fee balancing to a transaction
+const feeBalancingTx = await dustWallet.balanceTransactions(dustSecretKey, [transactionToBalance], ttl);
+```
+
+### Calculating Fees
+
+```typescript
+const fee = await dustWallet.calculateFee([transaction]);
+```
+
+### Dust Generation
+
+Register Night UTXOs to generate dust:
+
+```typescript
+const dustGenerationTx = await dustWallet.createDustGenerationTransaction(
+  previousState,
+  ttl,
+  nightUtxos,
+  nightVerifyingKey,
+  dustReceiverAddress,
+);
+
+// Add signature for dust registration
+const signedTx = await dustWallet.addDustGenerationSignature(dustGenerationTx, signature);
+```
+
+## Exports
+
+- `DustWallet` - Main wallet class
+- `DustWalletState` - Wallet state type
+- `DustCoreWallet` - Core wallet implementation
+- `Keys` - Key management utilities
+- `Simulator` - Dust simulation utilities
+- `SyncService` - Synchronization service
+- `Transacting` - Transaction utilities
+- `CoinsAndBalances` - Coin and balance management
+
+## V1 Builder
+
+Use the V1 builder pattern for wallet construction:
+
+```typescript
+import { V1Builder, RunningV1Variant } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+
+// Build a V1 dust wallet variant
+```
+
+## License
+
+Apache-2.0

package/dist/CoinsAndBalances.d.ts

@@ -1,10 +1,15 @@
 import { DustCoreWallet } from './DustCoreWallet.js';
-import { DustGenerationInfo, DustToken, DustTokenFullInfo } from './types/Dust.js';
+import { KeysCapability } from './Keys.js';
+import { DustGenerationDetails, DustGenerationInfo, DustToken, DustTokenFullInfo, UtxoWithMeta } from './types/Dust.js';
 export type Balance = bigint;
 export type CoinWithValue<TToken> = {
     token: TToken;
     value: Balance;
 };
+export type UtxoWithFullDustDetails = Readonly<{
+    utxo: UtxoWithMeta;
+    dust: DustGenerationDetails;
+}>;
 export type CoinSelection<TInput> = (coins: readonly CoinWithValue<TInput>[], amountNeeded: Balance) => CoinWithValue<TInput>[];
 export declare const chooseCoin: <TInput>(coins: readonly CoinWithValue<TInput>[], amountNeeded: Balance) => CoinWithValue<TInput>[];
 export type CoinsAndBalancesCapability<TState> = {
@@ -15,5 +20,24 @@ export type CoinsAndBalancesCapability<TState> = {
     getAvailableCoinsWithGeneratedDust(state: TState, currentTime: Date): ReadonlyArray<CoinWithValue<DustToken>>;
     getAvailableCoinsWithFullInfo(state: TState, blockTime: Date): readonly DustTokenFullInfo[];
     getGenerationInfo(state: TState, token: DustToken): DustGenerationInfo | undefined;
+    /**
+     * 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.
+     * @param state Current state of the wallet
+     * @param nightUtxos Existing Night utxos
+     * @param currentTime Current time
+     * @returns Estimated Dust generation per Utxo
+     */
+    estimateDustGeneration(state: TState, nightUtxos: ReadonlyArray<UtxoWithMeta>, currentTime: Date): ReadonlyArray<UtxoWithFullDustDetails>;
 };
-export declare const makeDefaultCoinsAndBalancesCapability: () => CoinsAndBalancesCapability<DustCoreWallet>;
+export type DefaultCoinsAndBalancesContext = {
+    keysCapability: KeysCapability<DustCoreWallet>;
+};
+export declare const makeDefaultCoinsAndBalancesCapability: (config: object, getContext: () => DefaultCoinsAndBalancesContext) => CoinsAndBalancesCapability<DustCoreWallet>;

package/dist/CoinsAndBalances.js

@@ -1,6 +1,18 @@
-import { Array, pipe } from 'effect';
-import { updatedValue } from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { DateOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { pipe, Array as Arr, Order } from 'effect';
 export const chooseCoin = (coins, amountNeeded) => {
     let sum = 0n;
     const sorted = coins.toSorted((a, b) => Number(a.value - b.value));
@@ -13,13 +25,14 @@ export const chooseCoin = (coins, amountNeeded) => {
     }
     return result;
 };
-export const makeDefaultCoinsAndBalancesCapability = () => {
+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.pendingDustTokens.values()].map((coin) => coin.nonce));
-        return pipe(state.state.utxos, Array.filter((coin) => !pendingSpends.has(coin.nonce)));
+        return pipe(state.state.utxos, Arr.filter((coin) => !pendingSpends.has(coin.nonce)));
     };
     const getPendingCoins = (state) => state.pendingDustTokens;
     const getTotalCoins = (state) => [
@@ -41,7 +54,7 @@ export const makeDefaultCoinsAndBalancesCapability = () => {
         for (const coin of available) {
             const genInfo = getGenerationInfo(state, coin);
             if (genInfo) {
-                const generatedValue = updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, state.state.params);
+                const generatedValue = ledger.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, state.state.params);
                 result.push({ token: coin, value: generatedValue });
             }
         }
@@ -53,19 +66,60 @@ export const makeDefaultCoinsAndBalancesCapability = () => {
         for (const coin of available) {
             const genInfo = getGenerationInfo(state, coin);
             if (genInfo) {
-                const generatedValue = updatedValue(coin.ctime, coin.initialValue, genInfo, blockTime, state.state.params);
                 result.push({
                     token: coin,
-                    dtime: genInfo.dtime,
-                    maxCap: genInfo.value * state.state.params.nightDustRatio,
-                    maxCapReachedAt: DateOps.addSeconds(coin.ctime, state.state.params.timeToCapSeconds),
-                    generatedNow: generatedValue,
-                    rate: genInfo.value * state.state.params.generationDecayRate,
+                    ...getFullDustInfo(state.state.params, genInfo, coin, blockTime),
                 });
             }
         }
         return result;
     };
+    const getFullDustInfo = (parameters, genInfo, coin, currentTime) => {
+        const generatedValue = ledger.updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, parameters);
+        return {
+            dtime: genInfo.dtime,
+            maxCap: genInfo.value * parameters.nightDustRatio,
+            maxCapReachedAt: DateOps.addSeconds(coin.ctime, parameters.timeToCapSeconds),
+            generatedNow: generatedValue,
+            rate: genInfo.value * parameters.generationDecayRate,
+        };
+    };
+    const estimateDustGeneration = (state, nightUtxos, currentTime) => {
+        const dustPublicKey = getContext().keysCapability.getDustPublicKey(state);
+        return pipe(nightUtxos, Arr.map((utxo) => {
+            const genInfo = fakeGenerationInfo(utxo, dustPublicKey);
+            const fakeDustCoin = fakeDustToken(dustPublicKey, utxo);
+            const details = getFullDustInfo(state.state.params, genInfo, fakeDustCoin, currentTime);
+            return { utxo, dust: details };
+        }));
+    };
+    /**
+     * 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,
+            owner: dustPublicKey,
+            nonce: FAKE_NONCE,
+            dtime: undefined,
+        };
+    };
+    /**
+     * 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,
+        nonce: 0n,
+        seq: 0,
+        ctime: utxo.ctime,
+        backingNight: '',
+        mtIndex: 0n,
+    });
+    const splitNightUtxos = (utxos) => {
+        const [guaranteed, fallible] = pipe(utxos, Arr.sort(pipe(Order.bigint, Order.reverse, Order.mapInput((coin) => coin.dust.generatedNow))), Arr.splitAt(1));
+        return { guaranteed, fallible };
+    };
     return {
         getWalletBalance,
         getAvailableCoins,
@@ -74,5 +128,7 @@ export const makeDefaultCoinsAndBalancesCapability = () => {
         getAvailableCoinsWithGeneratedDust,
         getAvailableCoinsWithFullInfo,
         getGenerationInfo,
+        estimateDustGeneration,
+        splitNightUtxos,
     };
 };

package/dist/DustCoreWallet.d.ts

@@ -1,4 +1,4 @@
-import { Bindingish, DustLocalState, DustNullifier, DustParameters, DustPublicKey, DustSecretKey, Proofish, Signaturish, Transaction, Event } from '@midnight-ntwrk/ledger-v6';
+import { Bindingish, DustLocalState, DustNullifier, DustParameters, DustPublicKey, DustSecretKey, Proofish, Signaturish, Transaction, Event } from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { SyncProgress } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { DustToken, DustTokenWithNullifier } from './types/Dust.js';

package/dist/DustCoreWallet.js

@@ -1,4 +1,16 @@
-import { DustLocalState, } from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { DustLocalState, } from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { SyncProgress } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { DateOps } from '@midnight-ntwrk/wallet-sdk-utilities';
@@ -40,6 +52,7 @@ export class DustCoreWallet {
     applyEvents(secretKey, events, currentTime) {
         if (!events.length)
             return this;
+        // TODO: replace currentTime with `updatedState.syncTime` introduced in ledger-6.2.0-rc.1
         const updatedState = this.state.replayEvents(secretKey, events).processTtls(currentTime);
         let updatedPending = this.pendingDustTokens;
         if (updatedPending.length) {

package/dist/DustWallet.d.ts

@@ -1,15 +1,15 @@
-import { DustParameters, DustPublicKey, DustSecretKey, FinalizedTransaction, Signature, SignatureVerifyingKey, UnprovenTransaction } from '@midnight-ntwrk/ledger-v6';
+import { DustParameters, DustPublicKey, DustSecretKey, FinalizedTransaction, Signature, SignatureVerifyingKey, UnprovenTransaction } from '@midnight-ntwrk/ledger-v7';
 import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Variant, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
-import { ProvingRecipe, TransactionHistory } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { TransactionHistory } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import * as rx from 'rxjs';
-import { Balance, CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { Balance, CoinsAndBalancesCapability, UtxoWithFullDustDetails } from './CoinsAndBalances.js';
 import { DustCoreWallet } from './DustCoreWallet.js';
 import { KeysCapability } from './Keys.js';
 import { SerializationCapability } from './Serialization.js';
 import { SubmitTransactionMethod } from './Submission.js';
 import { DustToken, DustTokenFullInfo, UtxoWithMeta } from './types/Dust.js';
-import { AnyTransaction, NetworkId } from './types/ledger.js';
+import { AnyTransaction } from './types/ledger.js';
 import { DefaultV1Configuration, DefaultV1Variant } from './V1Builder.js';
 export type DustWalletCapabilities = {
     serialization: SerializationCapability<DustCoreWallet, null, string>;
@@ -30,22 +30,24 @@ export declare class DustWalletState {
     constructor(state: ProtocolState.ProtocolState<DustCoreWallet>, capabilities: DustWalletCapabilities);
     walletBalance(time: Date): Balance;
     availableCoinsWithFullInfo(time: Date): readonly DustTokenFullInfo[];
+    estimateDustGeneration(nightUtxos: ReadonlyArray<UtxoWithMeta>, currentTime: Date): ReadonlyArray<UtxoWithFullDustDetails>;
     serialize(): string;
 }
 export interface DustWallet extends WalletLike.WalletLike<[Variant.VersionedVariant<DefaultV1Variant>]> {
     readonly state: rx.Observable<DustWalletState>;
     start(secretKey: DustSecretKey): Promise<void>;
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: Array<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Promise<UnprovenTransaction>;
-    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
-    calculateFee(transaction: AnyTransaction): Promise<bigint>;
-    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, currentTime: Date, ttl: Date): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
-    finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>): Promise<FinalizedTransaction>;
+    createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: Array<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Promise<UnprovenTransaction>;
+    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Promise<UnprovenTransaction>;
+    calculateFee(transactions: ReadonlyArray<AnyTransaction>): Promise<bigint>;
+    balanceTransactions(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime?: Date): Promise<UnprovenTransaction>;
+    proveTransaction(transaction: UnprovenTransaction): Promise<FinalizedTransaction>;
     readonly submitTransaction: SubmitTransactionMethod<FinalizedTransaction>;
     serializeState(): Promise<string>;
     waitForSyncedState(allowedGap?: bigint): Promise<DustWalletState>;
 }
 export interface DustWalletClass extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<DefaultV1Variant>]> {
-    startWithSeed(seed: Uint8Array, dustParameters: DustParameters, networkId: NetworkId): DustWallet;
+    startWithSeed(seed: Uint8Array, dustParameters: DustParameters): DustWallet;
+    startWithSecretKey(secretKey: DustSecretKey, dustParameters: DustParameters): DustWallet;
     restore(serializedState: string): DustWallet;
 }
 export declare function DustWallet(configuration: DefaultV1Configuration): DustWalletClass;

package/dist/DustWallet.js

@@ -1,7 +1,19 @@
-import { DustSecretKey, } from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { DustSecretKey, } from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
 import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
 import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { DustCoreWallet } from './DustCoreWallet.js';
@@ -48,6 +60,9 @@ export class DustWalletState {
     availableCoinsWithFullInfo(time) {
         return this.capabilities.coinsAndBalances.getAvailableCoinsWithFullInfo(this.state, time);
     }
+    estimateDustGeneration(nightUtxos, currentTime) {
+        return this.capabilities.coinsAndBalances.estimateDustGeneration(this.state, nightUtxos, currentTime);
+    }
     serialize() {
         return this.capabilities.serialization.serialize(this.state);
     }
@@ -57,9 +72,12 @@ export function DustWallet(configuration) {
         .withVariant(ProtocolVersion.MinSupportedVersion, new V1Builder().withDefaults())
         .build(configuration);
     return class DustWalletImplementation extends BaseWallet {
-        static startWithSeed(seed, dustParameters, networkId) {
+        static startWithSeed(seed, dustParameters) {
             const dustSecretKey = DustSecretKey.fromSeed(seed);
-            return DustWalletImplementation.startFirst(DustWalletImplementation, DustCoreWallet.initEmpty(dustParameters, dustSecretKey, networkId));
+            return DustWalletImplementation.startFirst(DustWalletImplementation, DustCoreWallet.initEmpty(dustParameters, dustSecretKey, configuration.networkId));
+        }
+        static startWithSecretKey(secretKey, dustParameters) {
+            return DustWalletImplementation.startFirst(DustWalletImplementation, DustCoreWallet.initEmpty(dustParameters, secretKey, configuration.networkId));
         }
         static restore(serializedState) {
             const deserialized = DustWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
@@ -88,24 +106,24 @@ export function DustWallet(configuration) {
             })
                 .pipe(Effect.runPromise);
         }
-        calculateFee(transaction) {
+        calculateFee(transactions) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.calculateFee(transaction),
+                [V1Tag]: (v1) => v1.calculateFee(transactions),
             })
                 .pipe(Effect.runPromise);
         }
-        addFeePayment(secretKey, transaction, currentTime, ttl) {
+        balanceTransactions(secretKey, transactions, ttl, currentTime) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.addFeePayment(secretKey, transaction, currentTime, ttl),
+                [V1Tag]: (v1) => v1.balanceTransactions(secretKey, transactions, ttl, currentTime),
             })
                 .pipe(Effect.runPromise);
         }
-        finalizeTransaction(recipe) {
+        proveTransaction(transaction) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.finalizeTransaction(recipe),
+                [V1Tag]: (v1) => v1.proveTransaction(transaction),
             })
                 .pipe(Effect.runPromise);
         }

package/dist/Keys.d.ts

@@ -1,4 +1,4 @@
-import { DustPublicKey } from '@midnight-ntwrk/ledger-v6';
+import { DustPublicKey } from '@midnight-ntwrk/ledger-v7';
 import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { DustCoreWallet } from './DustCoreWallet.js';
 export type KeysCapability<TState> = {

package/dist/RunningV1Variant.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Stream, Scope } from 'effect';
-import { DustSecretKey, Signature, SignatureVerifyingKey, FinalizedTransaction, UnprovenTransaction } from '@midnight-ntwrk/ledger-v6';
-import { Proving, ProvingRecipe, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { DustSecretKey, Signature, SignatureVerifyingKey, FinalizedTransaction, UnprovenTransaction } from '@midnight-ntwrk/ledger-v7';
+import { Proving, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import { DustToken, UtxoWithMeta } from './types/Dust.js';
 import { KeysCapability } from './Keys.js';
@@ -35,10 +35,10 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     constructor(scope: Scope.Scope, context: Variant.VariantContext<DustCoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>);
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError.WalletError, Scope.Scope>;
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
-    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
-    calculateFee(transaction: AnyTransaction): Effect.Effect<bigint, WalletError.WalletError>;
-    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, currentTime: Date, ttl: Date): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
-    finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError.WalletError>;
+    createDustGenerationTransaction(currentTime: Date | undefined, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
+    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
+    calculateFee(transactions: ReadonlyArray<AnyTransaction>): Effect.Effect<bigint, WalletError.WalletError>;
+    balanceTransactions(secretKey: DustSecretKey, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime?: Date): Effect.Effect<UnprovenTransaction, WalletError.WalletError>;
+    proveTransaction(transaction: UnprovenTransaction): Effect.Effect<TTransaction, WalletError.WalletError>;
     submitTransaction: SubmitTransactionMethod<TTransaction>;
 }

package/dist/RunningV1Variant.js

@@ -1,8 +1,20 @@
-import { Effect, SubscriptionRef, Stream, pipe, Scope, Sink, Console, Duration, Schedule } from 'effect';
-import { nativeToken, updatedValue, } from '@midnight-ntwrk/ledger-v6';
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect, SubscriptionRef, Stream, pipe, Scope, Sink, Console, Duration, Schedule, Array as Arr } from 'effect';
+import { nativeToken, } from '@midnight-ntwrk/ledger-v7';
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
-import { EitherOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { ArrayOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { StateChange, VersionChangeType, } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 const progress = (state) => {
     const appliedIndex = state.progress?.appliedIndex ?? 0n;
@@ -69,19 +81,9 @@ export class RunningV1Variant {
         if (nightUtxos.some((utxo) => utxo.type !== nativeToken().raw)) {
             return Effect.fail(WalletError.WalletError.other('Token of a non-Night type received'));
         }
-        return Effect.Do.pipe(Effect.bind('currentState', () => SubscriptionRef.get(this.#context.stateRef)), Effect.bind('utxosWithDustValue', ({ currentState }) => LedgerOps.ledgerTry(() => {
-            const dustPublicKey = this.#v1Context.keysCapability.getDustPublicKey(currentState);
-            return nightUtxos.map((utxo) => {
-                const genInfo = {
-                    value: utxo.value,
-                    owner: dustPublicKey,
-                    nonce: LedgerOps.randomNonce(),
-                    dtime: undefined,
-                };
-                const dustValue = updatedValue(utxo.ctime, 0n, genInfo, currentTime, currentState.state.params);
-                return { token: utxo, value: dustValue };
-            });
-        })), Effect.flatMap(({ utxosWithDustValue }) => {
+        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)
                 .pipe(EitherOps.toEffect);
@@ -92,22 +94,22 @@ export class RunningV1Variant {
             .addDustGenerationSignature(transaction, signature)
             .pipe(EitherOps.toEffect);
     }
-    calculateFee(transaction) {
-        return pipe(this.#v1Context.syncService.ledgerParameters(), Effect.map((params) => this.#v1Context.transactingCapability.calculateFee(transaction, params)));
+    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)));
     }
-    addFeePayment(secretKey, transaction, currentTime, ttl) {
+    balanceTransactions(secretKey, transactions, ttl, currentTime) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.syncService.ledgerParameters(), Effect.flatMap((params) => this.#v1Context.transactingCapability.addFeePayment(secretKey, state, transaction, currentTime, ttl, params)), Effect.map(({ recipe, newState }) => [recipe, newState]));
+            return pipe(this.#v1Context.syncService.blockData(), Effect.flatMap((blockData) => this.#v1Context.transactingCapability.balanceTransactions(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)));
         });
     }
-    finalizeTransaction(recipe) {
+    proveTransaction(transaction) {
         return this.#v1Context.provingService
-            .prove(recipe)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertRecipe(state, recipe)))));
+            .prove(transaction)
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     }
     submitTransaction = ((transaction, waitForStatus = 'InBlock') => {
         return this.#v1Context.submissionService
             .submitTransaction(transaction, waitForStatus)
-            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revert(state, transaction)))));
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertTransaction(state, transaction)))));
     });
 }

package/dist/Serialization.js

@@ -1,5 +1,17 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { Effect, ParseResult, Either, pipe, Schema } from 'effect';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
 import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { DustCoreWallet } from './DustCoreWallet.js';
 const StateSchema = Schema.declare((input) => input instanceof ledger.DustLocalState).annotations({

package/dist/Simulator.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Either, Scope, Stream, SubscriptionRef } from 'effect';
-import { LedgerState, BlockContext, UserAddress, SignatureVerifyingKey, WellFormedStrictness, TransactionResult, ProofErasedTransaction, SyntheticCost } from '@midnight-ntwrk/ledger-v6';
+import { LedgerState, BlockContext, UserAddress, SignatureVerifyingKey, WellFormedStrictness, TransactionResult, ProofErasedTransaction, SyntheticCost } from '@midnight-ntwrk/ledger-v7';
 import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { NetworkId } from './types/ledger.js';
 export type SimulatorState = Readonly<{
@@ -11,6 +11,7 @@ export type SimulatorState = Readonly<{
 }>;
 export declare class Simulator {
     #private;
+    static blockHash: (blockTime: Date) => Effect.Effect<string>;
     static nextBlockContext: (blockTime: Date) => Effect.Effect<BlockContext>;
     static init(networkId: NetworkId): Effect.Effect<Simulator, never, Scope.Scope>;
     static apply(simulatorState: SimulatorState, tx: ProofErasedTransaction, strictness: WellFormedStrictness, blockContext: BlockContext, blockFullness?: SyntheticCost): Either.Either<[{

package/dist/Simulator.js

@@ -1,12 +1,25 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 import { Effect, Encoding, pipe, Stream, SubscriptionRef } from 'effect';
-import { LedgerState, ClaimRewardsTransaction, SignatureErased, Transaction, WellFormedStrictness, TransactionContext, } from '@midnight-ntwrk/ledger-v6';
+import { LedgerState, ClaimRewardsTransaction, SignatureErased, Transaction, WellFormedStrictness, TransactionContext, } from '@midnight-ntwrk/ledger-v7';
 import { DateOps, EitherOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import * as crypto from 'crypto';
 const simpleHash = (input) => {
     return Encoding.decodeHex(input).pipe(EitherOps.toEffect, Effect.andThen((parsed) => Effect.promise(() => crypto.subtle.digest('SHA-256', parsed))), Effect.andThen((out) => Encoding.encodeHex(new Uint8Array(out))), Effect.orDie);
 };
 export class Simulator {
-    static nextBlockContext = (blockTime) => pipe(DateOps.dateToSeconds(blockTime).toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash, Effect.map((hash) => ({
+    static blockHash = (blockTime) => pipe(DateOps.dateToSeconds(blockTime).toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash);
+    static nextBlockContext = (blockTime) => pipe(Simulator.blockHash(blockTime), Effect.map((hash) => ({
         parentBlockHash: hash,
         secondsSinceEpoch: DateOps.dateToSeconds(blockTime),
         secondsSinceEpochErr: 1,
@@ -32,6 +45,8 @@ export class Simulator {
     static apply(simulatorState, tx, strictness, blockContext, blockFullness) {
         return LedgerOps.ledgerTry(() => {
             blockFullness = blockFullness ?? tx.cost(simulatorState.ledger.parameters);
+            const detailedBlockFullness = simulatorState.ledger.parameters.normalizeFullness(blockFullness);
+            const computedBlockFullness = Math.max(detailedBlockFullness.readTime, detailedBlockFullness.computeTime, detailedBlockFullness.blockUsage, detailedBlockFullness.bytesWritten, detailedBlockFullness.bytesChurned);
             const blockNumber = blockContext.secondsSinceEpoch;
             const blockTime = DateOps.secondsToDate(blockNumber);
             const verifiedTransaction = tx.wellFormed(simulatorState.ledger, strictness, blockTime);
@@ -39,7 +54,7 @@ export class Simulator {
             const [newLedgerState, txResult] = simulatorState.ledger.apply(verifiedTransaction, transactionContext);
             const newSimulatorState = {
                 ...simulatorState,
-                ledger: newLedgerState.postBlockUpdate(blockTime, blockFullness),
+                ledger: newLedgerState.postBlockUpdate(blockTime, detailedBlockFullness, computedBlockFullness),
                 lastTx: tx,
                 lastTxResult: txResult,
                 lastTxNumber: blockNumber,

package/dist/Submission.d.ts

@@ -1,6 +1,6 @@
 import { Effect } from 'effect';
 import { SubmissionEvent as SubmissionEventImported } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
-import { FinalizedTransaction, ProofErasedTransaction } from '@midnight-ntwrk/ledger-v6';
+import { FinalizedTransaction, ProofErasedTransaction } from '@midnight-ntwrk/ledger-v7';
 import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { Simulator } from './Simulator.js';
 import { NetworkId } from './types/ledger.js';