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

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

@@ -10,9 +10,9 @@
 // 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 { Array, pipe } from 'effect';
-import { updatedValue } from '@midnight-ntwrk/ledger-v7';
+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));
@@ -25,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) => [
@@ -53,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 });
             }
         }
@@ -65,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,
@@ -86,5 +128,7 @@ export const makeDefaultCoinsAndBalancesCapability = () => {
         getAvailableCoinsWithGeneratedDust,
         getAvailableCoinsWithFullInfo,
         getGenerationInfo,
+        estimateDustGeneration,
+        splitNightUtxos,
     };
 };

package/dist/DustWallet.d.ts

@@ -1,9 +1,9 @@
 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';
@@ -30,16 +30,17 @@ 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 | undefined, 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, ttl: Date, currentTime?: Date): Promise<ProvingRecipe.ProvingRecipe<FinalizedTransaction>>;
-    finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>): Promise<FinalizedTransaction>;
+    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>;

package/dist/DustWallet.js

@@ -60,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);
     }
@@ -103,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, ttl, currentTime) {
+        balanceTransactions(secretKey, transactions, ttl, currentTime) {
             return this.runtime
                 .dispatch({
-                [V1Tag]: (v1) => v1.addFeePayment(secretKey, transaction, ttl, currentTime),
+                [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/RunningV1Variant.d.ts

@@ -1,6 +1,6 @@
 import { Effect, Stream, Scope } from 'effect';
 import { DustSecretKey, Signature, SignatureVerifyingKey, FinalizedTransaction, UnprovenTransaction } from '@midnight-ntwrk/ledger-v7';
-import { Proving, ProvingRecipe, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+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';
@@ -36,9 +36,9 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TS
     startSyncInBackground(startAux: TStartAux): Effect.Effect<void>;
     startSync(startAux: TStartAux): Stream.Stream<void, WalletError.WalletError, Scope.Scope>;
     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<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
-    calculateFee(transaction: AnyTransaction): Effect.Effect<bigint, WalletError.WalletError>;
-    addFeePayment(secretKey: DustSecretKey, transaction: UnprovenTransaction, ttl: Date, currentTime?: Date): Effect.Effect<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
-    finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, 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

@@ -10,11 +10,11 @@
 // 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 } from 'effect';
-import { nativeToken, updatedValue, } from '@midnight-ntwrk/ledger-v7';
+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;
@@ -81,21 +81,11 @@ 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('blockData', () => this.#v1Context.syncService.blockData()), Effect.bind('utxosWithDustValue', ({ currentState, blockData }) => 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 ?? blockData.timestamp, currentState.state.params);
-                return { token: utxo, value: dustValue };
-            });
-        })), Effect.flatMap(({ utxosWithDustValue, blockData }) => {
+        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 ?? blockData.timestamp, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
+                .createDustGenerationTransaction(currentTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
                 .pipe(EitherOps.toEffect);
         }));
     }
@@ -104,22 +94,22 @@ export class RunningV1Variant {
             .addDustGenerationSignature(transaction, signature)
             .pipe(EitherOps.toEffect);
     }
-    calculateFee(transaction) {
-        return pipe(this.#v1Context.syncService.blockData(), Effect.map((blockData) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)));
+    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, ttl, currentTime) {
+    balanceTransactions(secretKey, transactions, ttl, currentTime) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
-            return pipe(this.#v1Context.syncService.blockData(), Effect.flatMap((blockData) => this.#v1Context.transactingCapability.addFeePayment(secretKey, state, transaction, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)), 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/Sync.d.ts

@@ -45,11 +45,12 @@ export declare const SyncEventsUpdateSchema: Schema.Struct<{
 }>;
 export type WalletSyncSubscription = Schema.Schema.Type<typeof SyncEventsUpdateSchema>;
 export type WalletSyncUpdate = {
-    update: WalletSyncSubscription;
+    updates: WalletSyncSubscription[];
     secretKeys: SecretKeysResource;
+    timestamp: Date;
 };
 export declare const WalletSyncUpdate: {
-    create: (update: WalletSyncSubscription, secretKey: DustSecretKey) => WalletSyncUpdate;
+    create: (updates: WalletSyncSubscription[], secretKey: DustSecretKey, timestamp: Date) => WalletSyncUpdate;
 };
 export declare const makeDefaultSyncService: (config: DefaultSyncConfiguration) => SyncService<DustCoreWallet, DustSecretKey, WalletSyncUpdate>;
 export type IndexerSyncService = {

package/dist/Sync.js

@@ -10,7 +10,7 @@
 // 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, Either, Layer, ParseResult, pipe, Schema, Stream, Duration } from 'effect';
+import { Effect, Either, Layer, ParseResult, pipe, Schema, Stream, Duration, Chunk, Schedule } from 'effect';
 import { Event as LedgerEvent, LedgerParameters } from '@midnight-ntwrk/ledger-v7';
 import { BlockHash, DustLedgerEvents } from '@midnight-ntwrk/wallet-sdk-indexer-client';
 import { WsSubscriptionClient, HttpQueryClient, ConnectionHelper, } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
@@ -58,10 +58,11 @@ export const SyncEventsUpdateSchema = Schema.Struct({
     maxId: Schema.Number,
 });
 export const WalletSyncUpdate = {
-    create: (update, secretKey) => {
+    create: (updates, secretKey, timestamp) => {
         return {
-            update,
+            updates,
             secretKeys: SecretKeysResource.create(secretKey),
+            timestamp,
         };
     },
 };
@@ -69,9 +70,9 @@ export const makeDefaultSyncService = (config) => {
     const indexerSyncService = makeIndexerSyncService(config);
     return {
         updates: (state, secretKey) => {
-            const batchSize = 50;
-            const batchTimeout = Duration.seconds(10);
-            return pipe(indexerSyncService.subscribeWallet(state), Stream.map((data) => WalletSyncUpdate.create(data, secretKey)), Stream.groupedWithin(batchSize, batchTimeout), Stream.flatMap((chunk) => Stream.fromIterable(chunk)), Stream.provideSomeLayer(indexerSyncService.connectionLayer()));
+            const batchSize = 10;
+            const batchTimeout = Duration.millis(1);
+            return pipe(indexerSyncService.subscribeWallet(state), Stream.groupedWithin(batchSize, batchTimeout), Stream.map(Chunk.toArray), Stream.map((data) => WalletSyncUpdate.create(data, secretKey, new Date())), Stream.schedule(Schedule.spaced(Duration.millis(4))), Stream.provideSomeLayer(indexerSyncService.connectionLayer()));
         },
         blockData: () => {
             return Effect.gen(function* () {
@@ -116,17 +117,22 @@ export const makeIndexerSyncService = (config) => {
 export const makeDefaultSyncCapability = () => {
     return {
         applyUpdate(state, wrappedUpdate) {
-            const { update, secretKeys } = wrappedUpdate;
-            const nextIndex = BigInt(update.id);
-            const highestRelevantWalletIndex = BigInt(update.maxId);
+            const { updates, secretKeys } = wrappedUpdate;
+            // Nothing to update yet
+            if (updates.length === 0) {
+                return state;
+            }
+            const lastUpdate = updates.at(-1);
+            const nextIndex = BigInt(lastUpdate.id);
+            const highestRelevantWalletIndex = BigInt(lastUpdate.maxId);
             // in case the nextIndex is less than or equal to the current appliedIndex
             // just update highestRelevantWalletIndex
             if (nextIndex <= state.progress.appliedIndex) {
                 return state.updateProgress({ highestRelevantWalletIndex, isConnected: true });
             }
-            const events = [update.raw].filter((event) => event !== null);
+            const events = updates.map((u) => u.raw).filter((event) => event !== null);
             return secretKeys((keys) => state
-                .applyEvents(keys, events, new Date())
+                .applyEvents(keys, events, wrappedUpdate.timestamp)
                 .updateProgress({ appliedIndex: nextIndex, highestRelevantWalletIndex, isConnected: true }));
         },
     };

package/dist/Transacting.d.ts

@@ -1,22 +1,18 @@
 import { Either } from 'effect';
-import { DustSecretKey, Signature, SignatureVerifyingKey, Utxo, FinalizedTransaction, ProofErasedTransaction, UnprovenTransaction, LedgerParameters } from '@midnight-ntwrk/ledger-v7';
-import { ProvingRecipe, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { DustSecretKey, Signature, SignatureVerifyingKey, FinalizedTransaction, ProofErasedTransaction, UnprovenTransaction, LedgerParameters } from '@midnight-ntwrk/ledger-v7';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { DustCoreWallet } from './DustCoreWallet.js';
 import { AnyTransaction, DustToken, NetworkId, TotalCostParameters } from './types/index.js';
-import { CoinsAndBalancesCapability, CoinSelection, CoinWithValue } from './CoinsAndBalances.js';
+import { CoinsAndBalancesCapability, CoinSelection, UtxoWithFullDustDetails } from './CoinsAndBalances.js';
 import { KeysCapability } from './Keys.js';
 export interface TransactingCapability<TSecrets, TState, TTransaction> {
     readonly networkId: NetworkId;
     readonly costParams: TotalCostParameters;
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<CoinWithValue<Utxo>>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Either.Either<UnprovenTransaction, WalletError.WalletError>;
-    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Either.Either<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
+    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithFullDustDetails>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Either.Either<UnprovenTransaction, WalletError.WalletError>;
+    addDustGenerationSignature(transaction: UnprovenTransaction, signature: Signature): Either.Either<UnprovenTransaction, WalletError.WalletError>;
     calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
-    addFeePayment(secretKey: TSecrets, state: TState, transaction: UnprovenTransaction, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<{
-        recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>;
-        newState: TState;
-    }, WalletError.WalletError>;
-    revert(state: TState, tx: TTransaction): Either.Either<TState, WalletError.WalletError>;
-    revertRecipe(state: TState, recipe: ProvingRecipe.ProvingRecipe<TTransaction>): Either.Either<TState, WalletError.WalletError>;
+    balanceTransactions(secretKey: TSecrets, state: TState, transactions: ReadonlyArray<AnyTransaction>, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<[UnprovenTransaction, TState], WalletError.WalletError>;
+    revertTransaction(state: TState, transaction: UnprovenTransaction | TTransaction): Either.Either<TState, WalletError.WalletError>;
 }
 export type DefaultTransactingConfiguration = {
     networkId: NetworkId;
@@ -37,14 +33,10 @@ export declare class TransactingCapabilityImplementation<TTransaction extends An
     readonly getCoins: () => CoinsAndBalancesCapability<DustCoreWallet>;
     readonly getKeys: () => KeysCapability<DustCoreWallet>;
     constructor(networkId: NetworkId, costParams: TotalCostParameters, getCoinSelection: () => CoinSelection<DustToken>, getCoins: () => CoinsAndBalancesCapability<DustCoreWallet>, getKeys: () => KeysCapability<DustCoreWallet>);
-    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<CoinWithValue<Utxo>>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Either.Either<UnprovenTransaction, WalletError.WalletError>;
-    addDustGenerationSignature(transaction: UnprovenTransaction, signatureData: Signature): Either.Either<ProvingRecipe.ProvingRecipe<FinalizedTransaction>, WalletError.WalletError>;
+    createDustGenerationTransaction(currentTime: Date, ttl: Date, nightUtxos: ReadonlyArray<UtxoWithFullDustDetails>, nightVerifyingKey: SignatureVerifyingKey, dustReceiverAddress: string | undefined): Either.Either<UnprovenTransaction, WalletError.WalletError>;
+    addDustGenerationSignature(transaction: UnprovenTransaction, signatureData: Signature): Either.Either<UnprovenTransaction, WalletError.WalletError>;
     calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
     static feeImbalance(transaction: AnyTransaction, totalFee: bigint): bigint;
-    addFeePayment(secretKey: DustSecretKey, state: DustCoreWallet, transaction: UnprovenTransaction, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<{
-        recipe: ProvingRecipe.ProvingRecipe<FinalizedTransaction>;
-        newState: DustCoreWallet;
-    }, WalletError.WalletError>;
-    revert(state: DustCoreWallet, tx: TTransaction): Either.Either<DustCoreWallet, WalletError.WalletError>;
-    revertRecipe(state: DustCoreWallet, recipe: ProvingRecipe.ProvingRecipe<TTransaction>): Either.Either<DustCoreWallet, WalletError.WalletError>;
+    balanceTransactions(secretKey: DustSecretKey, state: DustCoreWallet, transactions: ReadonlyArray<FinalizedTransaction | UnprovenTransaction>, ttl: Date, currentTime: Date, ledgerParams: LedgerParameters): Either.Either<[UnprovenTransaction, DustCoreWallet], WalletError.WalletError>;
+    revertTransaction(state: DustCoreWallet, transaction: UnprovenTransaction | TTransaction): Either.Either<DustCoreWallet, WalletError.WalletError>;
 }

package/dist/Transacting.js

@@ -10,10 +10,10 @@
 // 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 { Either } from 'effect';
-import { DustActions, DustRegistration, Intent, SignatureEnabled, Transaction, UnshieldedOffer, addressFromKey, } from '@midnight-ntwrk/ledger-v7';
+import { Either, pipe, BigInt as BigIntOps, Iterable as IterableOps, Option } from 'effect';
+import { DustActions, DustRegistration, Intent, SignatureEnabled, Transaction, UnshieldedOffer, addressFromKey, nativeToken, } from '@midnight-ntwrk/ledger-v7';
 import { MidnightBech32m, DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { ProvingRecipe, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
 import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { BindingMarker, ProofMarker, SignatureMarker } from './Utils.js';
 export const makeDefaultTransactingCapability = (config, getContext) => {
@@ -36,24 +36,48 @@ export class TransactingCapabilityImplementation {
         this.getKeys = getKeys;
     }
     createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+        const makeOffer = (utxos) => {
+            if (utxos.length === 0) {
+                return Option.none();
+            }
+            const totalValue = pipe(utxos, IterableOps.map((coin) => coin.utxo.value), BigIntOps.sumAll);
+            const inputs = utxos.map(({ utxo }) => ({
+                ...utxo,
+                owner: nightVerifyingKey,
+            }));
+            const output = {
+                owner: addressFromKey(nightVerifyingKey),
+                type: nativeToken().raw,
+                value: totalValue,
+            };
+            return Option.some(UnshieldedOffer.new(inputs, [output], []));
+        };
         return Either.gen(this, function* () {
             const receiver = dustReceiverAddress ? yield* this.#parseAddress(dustReceiverAddress) : undefined;
             return yield* LedgerOps.ledgerTry(() => {
                 const network = this.networkId;
-                const intent = Intent.new(ttl);
-                const totalDustValue = nightUtxos.reduce((total, { value }) => total + value, 0n);
-                const inputs = nightUtxos.map(({ token: utxo }) => ({
-                    ...utxo,
-                    owner: nightVerifyingKey,
-                }));
-                const outputs = inputs.map((input) => ({
-                    owner: addressFromKey(nightVerifyingKey),
-                    type: input.type,
-                    value: input.value,
-                }));
-                intent.guaranteedUnshieldedOffer = UnshieldedOffer.new(inputs, outputs, []);
+                const splitResult = this.getCoins().splitNightUtxos(nightUtxos);
+                const totalDustValue = pipe(splitResult.guaranteed, IterableOps.map((coin) => coin.dust.generatedNow), BigIntOps.sumAll);
+                const maybeGuaranteedOffer = makeOffer(splitResult.guaranteed);
+                const maybeFallibleOffer = makeOffer(splitResult.fallible);
                 const dustRegistration = new DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, dustReceiverAddress !== undefined ? totalDustValue : 0n);
-                intent.dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+                const dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+                const intent = pipe(Intent.new(ttl), (intent) => Option.match(maybeGuaranteedOffer, {
+                    onNone: () => intent,
+                    onSome: (guaranteedOffer) => {
+                        intent.guaranteedUnshieldedOffer = guaranteedOffer;
+                        return intent;
+                    },
+                }), (intent) => Option.match(maybeFallibleOffer, {
+                    onNone: () => intent,
+                    onSome: (fallibleOffer) => {
+                        intent.fallibleUnshieldedOffer = fallibleOffer;
+                        return intent;
+                    },
+                }), (intent) => {
+                    intent.dustActions = dustActions;
+                    return intent;
+                });
                 return Transaction.fromParts(network, undefined, undefined, intent);
             });
         });
@@ -64,7 +88,7 @@ export class TransactingCapabilityImplementation {
             if (!intent) {
                 return yield* Either.left(new WalletError.TransactingError({ message: 'No intent found in the transaction intents with segment = 1' }));
             }
-            const { dustActions, guaranteedUnshieldedOffer } = intent;
+            const { dustActions, guaranteedUnshieldedOffer, fallibleUnshieldedOffer } = intent;
             if (!dustActions) {
                 return yield* Either.left(new WalletError.TransactingError({ message: 'No dustActions found in intent' }));
             }
@@ -88,13 +112,18 @@ export class TransactingCapabilityImplementation {
                     signatures.push(guaranteedUnshieldedOffer.signatures.at(i) ?? signatureData);
                 }
                 newIntent.guaranteedUnshieldedOffer = guaranteedUnshieldedOffer.addSignatures(signatures);
+                if (fallibleUnshieldedOffer) {
+                    const inputsLen = fallibleUnshieldedOffer.inputs.length;
+                    const signatures = [];
+                    for (let i = 0; i < inputsLen; ++i) {
+                        signatures.push(fallibleUnshieldedOffer.signatures.at(i) ?? signatureData);
+                    }
+                    newIntent.fallibleUnshieldedOffer = fallibleUnshieldedOffer.addSignatures(signatures);
+                }
                 // make a copy of transaction to avoid mutation
                 const newTransaction = Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
                 newTransaction.intents = newTransaction.intents.set(1, newIntent);
-                return {
-                    type: ProvingRecipe.TRANSACTION_TO_PROVE,
-                    transaction: newTransaction,
-                };
+                return newTransaction;
             });
         });
     }
@@ -108,9 +137,10 @@ export class TransactingCapabilityImplementation {
             .find(([tt, _]) => tt.tag === 'dust');
         return dustImbalance ? -dustImbalance[1] : totalFee;
     }
-    addFeePayment(secretKey, state, transaction, ttl, currentTime, ledgerParams) {
+    balanceTransactions(secretKey, state, transactions, ttl, currentTime, ledgerParams) {
         const network = this.networkId;
-        const feeLeft = TransactingCapabilityImplementation.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams));
+        const feeLeft = transactions.reduce((total, transaction) => total +
+            TransactingCapabilityImplementation.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams)), 0n);
         const dustTokens = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
         const selectedTokens = this.getCoinSelection()(dustTokens, feeLeft);
         if (!selectedTokens.length) {
@@ -133,49 +163,22 @@ export class TransactingCapabilityImplementation {
         return LedgerOps.ledgerTry(() => {
             const intent = Intent.new(ttl);
             const [spends, updatedState] = state.spendCoins(secretKey, tokensWithFeeToTake, currentTime);
-            intent.dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, spends, []);
+            intent.dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [...spends], []);
             const feeTransaction = Transaction.fromPartsRandomized(network, undefined, undefined, intent);
-            return {
-                newState: updatedState,
-                recipe: {
-                    type: ProvingRecipe.TRANSACTION_TO_PROVE,
-                    transaction: transaction.merge(feeTransaction),
-                },
-            };
+            return [feeTransaction, updatedState];
         });
     }
-    revert(state, tx) {
+    revertTransaction(state, transaction) {
         return Either.try({
-            try: () => state.revertTransaction(tx),
+            try: () => state.revertTransaction(transaction),
             catch: (err) => {
                 return new WalletError.OtherWalletError({
-                    message: `Error while reverting transaction ${tx.identifiers().at(0)}`,
+                    message: `Error while reverting transaction ${transaction.identifiers().at(0)}`,
                     cause: err,
                 });
             },
         });
     }
-    revertRecipe(state, recipe) {
-        const doRevert = (tx) => {
-            return Either.try({
-                try: () => state.revertTransaction(tx),
-                catch: (err) => {
-                    return new WalletError.OtherWalletError({
-                        message: `Error while reverting transaction ${tx.identifiers().at(0)}`,
-                        cause: err,
-                    });
-                },
-            });
-        };
-        switch (recipe.type) {
-            case ProvingRecipe.TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transaction);
-            case ProvingRecipe.BALANCE_TRANSACTION_TO_PROVE:
-                return doRevert(recipe.transactionToProve);
-            case ProvingRecipe.NOTHING_TO_PROVE:
-                return Either.right(state);
-        }
-    }
     #parseAddress(addr) {
         return Either.try({
             try: () => {

package/dist/V1Builder.d.ts

@@ -6,7 +6,7 @@ import { SyncService, SyncCapability, DefaultSyncConfiguration, WalletSyncUpdate
 import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
 import { DustCoreWallet } from './DustCoreWallet.js';
 import { KeysCapability } from './Keys.js';
-import { CoinsAndBalancesCapability, CoinSelection } from './CoinsAndBalances.js';
+import { CoinsAndBalancesCapability, CoinSelection, DefaultCoinsAndBalancesContext } from './CoinsAndBalances.js';
 import { DefaultTransactingConfiguration, DefaultTransactingContext, TransactingCapability } from './Transacting.js';
 import { NetworkId } from './types/ledger.js';
 import { DefaultSubmissionConfiguration, SubmissionService } from './Submission.js';
@@ -46,7 +46,7 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
     withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withProving<TProvingConfig, TProvingContext extends Partial<RunningV1Variant.AnyContext>>(provingService: (config: TProvingConfig, getContext: () => TProvingContext) => Proving.ProvingService<TTransaction>): V1Builder<TConfig & TProvingConfig, TContext & TProvingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withProvingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>): V1Builder<TConfig & Proving.DefaultProvingConfiguration, TContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>;
-    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext & DefaultCoinsAndBalancesContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<DustCoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<DustCoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export * as Transacting from './Transacting.js';
 export * from './RunningV1Variant.js';
 export * from './V1Builder.js';
 export * from './types/index.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';

package/dist/index.js

@@ -19,3 +19,4 @@ export * as Transacting from './Transacting.js';
 export * from './RunningV1Variant.js';
 export * from './V1Builder.js';
 export * from './types/index.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';

package/dist/types/Dust.d.ts

@@ -11,8 +11,10 @@ export type DustToken = {
 export type DustTokenWithNullifier = DustToken & {
     nullifier: DustNullifier;
 };
-export type DustTokenFullInfo = {
+export type DustTokenFullInfo = DustGenerationDetails & {
     token: DustToken;
+};
+export type DustGenerationDetails = {
     dtime: Date | undefined;
     maxCap: bigint;
     maxCapReachedAt: Date;

package/dist/types/ledger.d.ts

@@ -1,4 +1,4 @@
 import * as ledger from '@midnight-ntwrk/ledger-v7';
-export type AnyTransaction = ledger.UnprovenTransaction | ledger.FinalizedTransaction | ledger.ProofErasedTransaction;
+export type AnyTransaction = ledger.UnprovenTransaction | ledger.FinalizedTransaction | ledger.ProofErasedTransaction | ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
 export type UnprovenDustSpend = ledger.DustSpend<ledger.PreProof>;
 export type NetworkId = string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-dust-wallet",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -31,9 +31,9 @@
     "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.16",
     "@midnight-ntwrk/wallet-sdk-node-client": "1.0.0-beta.12",
     "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.13",
-    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.15",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.16",
     "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.10",
-    "effect": "^3.17.3",
+    "effect": "^3.19.14",
     "rxjs": "^7.5"
   },
   "scripts": {