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

package/README.md

@@ -0,0 +1,3 @@
+# Wallet SDK Dust Wallet
+
+TBD

package/dist/CoinsAndBalances.d.ts

@@ -0,0 +1,19 @@
+import { DustCoreWallet } from './DustCoreWallet.js';
+import { DustGenerationInfo, DustToken, DustTokenFullInfo } from './types/Dust.js';
+export type Balance = bigint;
+export type CoinWithValue<TToken> = {
+    token: TToken;
+    value: Balance;
+};
+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> = {
+    getWalletBalance(state: TState, time: Date): Balance;
+    getAvailableCoins(state: TState): readonly DustToken[];
+    getPendingCoins(state: TState): readonly DustToken[];
+    getTotalCoins(state: TState): ReadonlyArray<DustToken>;
+    getAvailableCoinsWithGeneratedDust(state: TState, currentTime: Date): ReadonlyArray<CoinWithValue<DustToken>>;
+    getAvailableCoinsWithFullInfo(state: TState, blockTime: Date): readonly DustTokenFullInfo[];
+    getGenerationInfo(state: TState, token: DustToken): DustGenerationInfo | undefined;
+};
+export declare const makeDefaultCoinsAndBalancesCapability: () => CoinsAndBalancesCapability<DustCoreWallet>;

package/dist/CoinsAndBalances.js

@@ -0,0 +1,78 @@
+import { Array, pipe } from 'effect';
+import { updatedValue } from '@midnight-ntwrk/ledger-v6';
+import { DateOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+export const chooseCoin = (coins, amountNeeded) => {
+    let sum = 0n;
+    const sorted = coins.toSorted((a, b) => Number(a.value - b.value));
+    const result = [];
+    for (const coin of sorted) {
+        sum += coin.value;
+        result.push(coin);
+        if (sum >= amountNeeded)
+            break;
+    }
+    return result;
+};
+export const makeDefaultCoinsAndBalancesCapability = () => {
+    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)));
+    };
+    const getPendingCoins = (state) => state.pendingDustTokens;
+    const getTotalCoins = (state) => [
+        ...getAvailableCoins(state),
+        ...getPendingCoins(state),
+    ];
+    const getGenerationInfo = (state, token) => {
+        const info = state.state.generationInfo(token);
+        return info && info.dtime
+            ? {
+                ...info,
+                dtime: new Date(+info.dtime), // TODO: remove when the ledger start to return a date instead of the number
+            }
+            : 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 = updatedValue(coin.ctime, coin.initialValue, genInfo, currentTime, state.state.params);
+                result.push({ token: coin, value: generatedValue });
+            }
+        }
+        return result;
+    };
+    const getAvailableCoinsWithFullInfo = (state, blockTime) => {
+        const result = [];
+        const available = getAvailableCoins(state);
+        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,
+                });
+            }
+        }
+        return result;
+    };
+    return {
+        getWalletBalance,
+        getAvailableCoins,
+        getPendingCoins,
+        getTotalCoins,
+        getAvailableCoinsWithGeneratedDust,
+        getAvailableCoinsWithFullInfo,
+        getGenerationInfo,
+    };
+};

package/dist/DustCoreWallet.d.ts

@@ -0,0 +1,31 @@
+import { Bindingish, DustLocalState, DustNullifier, DustParameters, DustPublicKey, DustSecretKey, Proofish, Signaturish, Transaction, Event } from '@midnight-ntwrk/ledger-v6';
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { SyncProgress } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { DustToken, DustTokenWithNullifier } from './types/Dust.js';
+import { CoinWithValue } from './CoinsAndBalances.js';
+import { NetworkId, UnprovenDustSpend } from './types/ledger.js';
+export type PublicKey = {
+    publicKey: DustPublicKey;
+};
+export declare const PublicKey: {
+    fromSecretKey: (secretKey: DustSecretKey) => PublicKey;
+};
+export declare class DustCoreWallet {
+    readonly state: DustLocalState;
+    readonly publicKey: PublicKey;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly progress: SyncProgress.SyncProgress;
+    readonly networkId: NetworkId;
+    readonly pendingDustTokens: Array<DustTokenWithNullifier>;
+    constructor(state: DustLocalState, publicKey: PublicKey, networkId: NetworkId, pendingDustTokens?: Array<DustTokenWithNullifier>, syncProgress?: Omit<SyncProgress.SyncProgressData, 'isConnected'>, protocolVersion?: ProtocolVersion.ProtocolVersion);
+    static init(localState: DustLocalState, secretKey: DustSecretKey, networkId: NetworkId): DustCoreWallet;
+    static readonly initEmpty: (dustParameters: DustParameters, secretKey: DustSecretKey, networkId: NetworkId) => DustCoreWallet;
+    static empty(localState: DustLocalState, publicKey: PublicKey, networkId: NetworkId): DustCoreWallet;
+    static restore(localState: DustLocalState, publicKey: PublicKey, pendingTokens: Array<DustTokenWithNullifier>, syncProgress: SyncProgress.SyncProgressData, protocolVersion: bigint, networkId: NetworkId): DustCoreWallet;
+    applyEvents(secretKey: DustSecretKey, events: Event[], currentTime: Date): DustCoreWallet;
+    applyFailed(tx: Transaction<Signaturish, Proofish, Bindingish>): DustCoreWallet;
+    revertTransaction<TTransaction extends Transaction<Signaturish, Proofish, Bindingish>>(tx: TTransaction): DustCoreWallet;
+    updateProgress({ appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgress.SyncProgressData>): DustCoreWallet;
+    spendCoins(secretKey: DustSecretKey, coins: ReadonlyArray<CoinWithValue<DustToken>>, currentTime: Date): [ReadonlyArray<UnprovenDustSpend>, DustCoreWallet];
+    static pendingDustTokensToMap(tokens: Array<DustTokenWithNullifier>): Map<DustNullifier, DustToken>;
+}

package/dist/DustCoreWallet.js

@@ -0,0 +1,96 @@
+import { DustLocalState, } from '@midnight-ntwrk/ledger-v6';
+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';
+import { Array as Arr, pipe } from 'effect';
+export const PublicKey = {
+    fromSecretKey: (secretKey) => {
+        return {
+            publicKey: secretKey.publicKey,
+        };
+    },
+};
+export class DustCoreWallet {
+    state;
+    publicKey;
+    protocolVersion;
+    progress;
+    networkId;
+    pendingDustTokens;
+    constructor(state, publicKey, networkId, pendingDustTokens = [], syncProgress, protocolVersion = ProtocolVersion.MinSupportedVersion) {
+        this.state = state;
+        this.publicKey = publicKey;
+        this.networkId = networkId;
+        this.pendingDustTokens = pendingDustTokens;
+        this.protocolVersion = protocolVersion;
+        this.progress = syncProgress ? SyncProgress.createSyncProgress(syncProgress) : SyncProgress.createSyncProgress();
+    }
+    static init(localState, secretKey, networkId) {
+        return new DustCoreWallet(localState, PublicKey.fromSecretKey(secretKey), networkId);
+    }
+    static initEmpty = (dustParameters, secretKey, networkId) => {
+        return DustCoreWallet.empty(new DustLocalState(dustParameters), PublicKey.fromSecretKey(secretKey), networkId);
+    };
+    static empty(localState, publicKey, networkId) {
+        return new DustCoreWallet(localState, publicKey, networkId);
+    }
+    static restore(localState, publicKey, pendingTokens, syncProgress, protocolVersion, networkId) {
+        return new DustCoreWallet(localState, publicKey, networkId, pendingTokens, syncProgress, ProtocolVersion.ProtocolVersion(protocolVersion));
+    }
+    applyEvents(secretKey, events, currentTime) {
+        if (!events.length)
+            return this;
+        const updatedState = this.state.replayEvents(secretKey, events).processTtls(currentTime);
+        let updatedPending = this.pendingDustTokens;
+        if (updatedPending.length) {
+            const newAvailable = updatedState.utxos.map((utxo) => utxo.nonce);
+            updatedPending = updatedPending.filter((pendingToken) => newAvailable.includes(pendingToken.nonce));
+        }
+        return new DustCoreWallet(updatedState, this.publicKey, this.networkId, updatedPending, this.progress);
+    }
+    applyFailed(tx) {
+        const removedPending = [];
+        let updatedState = this.state;
+        if (tx.intents) {
+            const pendingTokensMap = DustCoreWallet.pendingDustTokensToMap(this.pendingDustTokens);
+            for (const intent of tx.intents.values()) {
+                if (intent.dustActions && intent.dustActions.spends) {
+                    for (const spend of intent.dustActions.spends) {
+                        const pending = pendingTokensMap.get(spend.oldNullifier);
+                        if (pending === undefined)
+                            continue;
+                        removedPending.push(spend.oldNullifier);
+                        updatedState = updatedState.processTtls(DateOps.addSeconds(pending.ctime, this.state.params.dustGracePeriodSeconds));
+                    }
+                }
+            }
+        }
+        const pendingLeft = this.pendingDustTokens.filter((token) => !removedPending.includes(token.nullifier));
+        return new DustCoreWallet(updatedState, this.publicKey, this.networkId, pendingLeft, this.progress);
+    }
+    revertTransaction(tx) {
+        return this.applyFailed(tx);
+    }
+    updateProgress({ appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }) {
+        const updatedProgress = SyncProgress.createSyncProgress({
+            appliedIndex: appliedIndex ?? this.progress.appliedIndex,
+            highestRelevantWalletIndex: highestRelevantWalletIndex ?? this.progress.highestRelevantWalletIndex,
+            highestIndex: highestIndex ?? this.progress.highestIndex,
+            highestRelevantIndex: highestRelevantIndex ?? this.progress.highestRelevantIndex,
+            isConnected: isConnected ?? this.progress.isConnected,
+        });
+        return new DustCoreWallet(this.state, this.publicKey, this.networkId, this.pendingDustTokens, updatedProgress);
+    }
+    spendCoins(secretKey, coins, currentTime) {
+        const [output, newState, newPending] = pipe(coins, Arr.reduce([[], this.state, this.pendingDustTokens], ([spends, localState], { token: coinToSpend, value: takeFee }) => {
+            const [newState, dustSpend] = localState.spend(secretKey, coinToSpend, takeFee, currentTime);
+            const newPending = [...this.pendingDustTokens, { ...coinToSpend, nullifier: dustSpend.oldNullifier }];
+            return [Arr.append(spends, dustSpend), newState, newPending];
+        }));
+        const updatedState = new DustCoreWallet(newState, this.publicKey, this.networkId, newPending, this.progress);
+        return [output, updatedState];
+    }
+    static pendingDustTokensToMap(tokens) {
+        return new Map(tokens.map(({ nullifier, ...token }) => [nullifier, token]));
+    }
+}

package/dist/DustWallet.d.ts

@@ -0,0 +1,51 @@
+import { DustParameters, DustPublicKey, DustSecretKey, FinalizedTransaction, Signature, SignatureVerifyingKey, UnprovenTransaction } from '@midnight-ntwrk/ledger-v6';
+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 * as rx from 'rxjs';
+import { Balance, CoinsAndBalancesCapability } 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 { DefaultV1Configuration, DefaultV1Variant } from './V1Builder.js';
+export type DustWalletCapabilities = {
+    serialization: SerializationCapability<DustCoreWallet, null, string>;
+    coinsAndBalances: CoinsAndBalancesCapability<DustCoreWallet>;
+    keys: KeysCapability<DustCoreWallet>;
+};
+export declare class DustWalletState {
+    static readonly mapState: (capabilities: DustWalletCapabilities) => (state: ProtocolState.ProtocolState<DustCoreWallet>) => DustWalletState;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly state: DustCoreWallet;
+    readonly capabilities: DustWalletCapabilities;
+    get totalCoins(): readonly DustToken[];
+    get availableCoins(): readonly DustToken[];
+    get pendingCoins(): readonly DustToken[];
+    get dustPublicKey(): DustPublicKey;
+    get dustAddress(): string;
+    get progress(): TransactionHistory.ProgressUpdate;
+    constructor(state: ProtocolState.ProtocolState<DustCoreWallet>, capabilities: DustWalletCapabilities);
+    walletBalance(time: Date): Balance;
+    availableCoinsWithFullInfo(time: Date): readonly DustTokenFullInfo[];
+    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>;
+    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;
+    restore(serializedState: string): DustWallet;
+}
+export declare function DustWallet(configuration: DefaultV1Configuration): DustWalletClass;

package/dist/DustWallet.js

@@ -0,0 +1,128 @@
+import { DustSecretKey, } from '@midnight-ntwrk/ledger-v6';
+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 { Effect, Either } from 'effect';
+import * as rx from 'rxjs';
+import { DustCoreWallet } from './DustCoreWallet.js';
+import { V1Tag } from './RunningV1Variant.js';
+import { V1Builder } from './V1Builder.js';
+export class DustWalletState {
+    static mapState = (capabilities) => (state) => {
+        return new DustWalletState(state, capabilities);
+    };
+    protocolVersion;
+    state;
+    capabilities;
+    get totalCoins() {
+        return this.capabilities.coinsAndBalances.getTotalCoins(this.state);
+    }
+    get availableCoins() {
+        return this.capabilities.coinsAndBalances.getAvailableCoins(this.state);
+    }
+    get pendingCoins() {
+        return this.capabilities.coinsAndBalances.getPendingCoins(this.state);
+    }
+    get dustPublicKey() {
+        return this.capabilities.keys.getDustPublicKey(this.state);
+    }
+    get dustAddress() {
+        return DustAddress.encodePublicKey(this.state.networkId, this.dustPublicKey);
+    }
+    get progress() {
+        return {
+            appliedIndex: this.state.progress.appliedIndex,
+            highestRelevantWalletIndex: this.state.progress.highestRelevantWalletIndex,
+            highestIndex: this.state.progress.highestIndex,
+            highestRelevantIndex: this.state.progress.highestRelevantIndex,
+        };
+    }
+    constructor(state, capabilities) {
+        this.protocolVersion = state.version;
+        this.state = state.state;
+        this.capabilities = capabilities;
+    }
+    walletBalance(time) {
+        return this.capabilities.coinsAndBalances.getWalletBalance(this.state, time);
+    }
+    availableCoinsWithFullInfo(time) {
+        return this.capabilities.coinsAndBalances.getAvailableCoinsWithFullInfo(this.state, time);
+    }
+    serialize() {
+        return this.capabilities.serialization.serialize(this.state);
+    }
+}
+export function DustWallet(configuration) {
+    const BaseWallet = WalletBuilder.init()
+        .withVariant(ProtocolVersion.MinSupportedVersion, new V1Builder().withDefaults())
+        .build(configuration);
+    return class DustWalletImplementation extends BaseWallet {
+        static startWithSeed(seed, dustParameters, networkId) {
+            const dustSecretKey = DustSecretKey.fromSeed(seed);
+            return DustWalletImplementation.startFirst(DustWalletImplementation, DustCoreWallet.initEmpty(dustParameters, dustSecretKey, networkId));
+        }
+        static restore(serializedState) {
+            const deserialized = DustWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
+                .pipe(Either.getOrThrow);
+            return DustWalletImplementation.startFirst(DustWalletImplementation, 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 }));
+        }
+        start(secretKey) {
+            return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground(secretKey) }).pipe(Effect.runPromise);
+        }
+        createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress),
+            })
+                .pipe(Effect.runPromise);
+        }
+        addDustGenerationSignature(transaction, signature) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.addDustGenerationSignature(transaction, signature),
+            })
+                .pipe(Effect.runPromise);
+        }
+        calculateFee(transaction) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.calculateFee(transaction),
+            })
+                .pipe(Effect.runPromise);
+        }
+        addFeePayment(secretKey, transaction, currentTime, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.addFeePayment(secretKey, transaction, currentTime, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
+        finalizeTransaction(recipe) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.finalizeTransaction(recipe),
+            })
+                .pipe(Effect.runPromise);
+        }
+        submitTransaction = ((tx, waitForStatus = 'InBlock') => {
+            return this.runtime
+                .dispatch({ [V1Tag]: (v1) => v1.submitTransaction(tx, waitForStatus) })
+                .pipe(Effect.runPromise);
+        });
+        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/Keys.d.ts

@@ -0,0 +1,8 @@
+import { DustPublicKey } from '@midnight-ntwrk/ledger-v6';
+import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { DustCoreWallet } from './DustCoreWallet.js';
+export type KeysCapability<TState> = {
+    getDustPublicKey(state: TState): DustPublicKey;
+    getDustAddress(state: TState): DustAddress;
+};
+export declare const makeDefaultKeysCapability: () => KeysCapability<DustCoreWallet>;

package/dist/Keys.js

@@ -0,0 +1,11 @@
+import { DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+export const makeDefaultKeysCapability = () => {
+    return {
+        getDustPublicKey: (state) => {
+            return state.publicKey.publicKey;
+        },
+        getDustAddress: (state) => {
+            return new DustAddress(state.publicKey.publicKey);
+        },
+    };
+};

package/dist/RunningV1Variant.d.ts

@@ -0,0 +1,44 @@
+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 { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { DustToken, UtxoWithMeta } from './types/Dust.js';
+import { KeysCapability } from './Keys.js';
+import { SyncCapability, SyncService } from './Sync.js';
+import { SimulatorState } from './Simulator.js';
+import { CoinsAndBalancesCapability, CoinSelection } from './CoinsAndBalances.js';
+import { TransactingCapability } from './Transacting.js';
+import { SubmissionService, SubmitTransactionMethod } from './Submission.js';
+import { DustCoreWallet } from './DustCoreWallet.js';
+import { SerializationCapability } from './Serialization.js';
+import { AnyTransaction } from './types/ledger.js';
+export declare namespace RunningV1Variant {
+    type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
+        serializationCapability: SerializationCapability<DustCoreWallet, null, TSerialized>;
+        syncService: SyncService<DustCoreWallet, TStartAux, TSyncUpdate>;
+        syncCapability: SyncCapability<DustCoreWallet, TSyncUpdate>;
+        transactingCapability: TransactingCapability<DustSecretKey, DustCoreWallet, TTransaction>;
+        provingService: Proving.ProvingService<TTransaction>;
+        coinsAndBalancesCapability: CoinsAndBalancesCapability<DustCoreWallet>;
+        keysCapability: KeysCapability<DustCoreWallet>;
+        submissionService: SubmissionService<TTransaction>;
+        coinSelection: CoinSelection<DustToken>;
+    };
+    type AnyContext = Context<any, any, any, any>;
+}
+export declare const V1Tag: unique symbol;
+export type DefaultRunningV1 = RunningV1Variant<string, SimulatorState, FinalizedTransaction, DustSecretKey>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux> implements Variant.RunningVariant<typeof V1Tag, DustCoreWallet> {
+    #private;
+    __polyTag__: typeof V1Tag;
+    readonly state: Stream.Stream<StateChange.StateChange<DustCoreWallet>, WalletRuntimeError>;
+    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>;
+    submitTransaction: SubmitTransactionMethod<TTransaction>;
+}

package/dist/RunningV1Variant.js

@@ -0,0 +1,113 @@
+import { Effect, SubscriptionRef, Stream, pipe, Scope, Sink, Console, Duration, Schedule } from 'effect';
+import { nativeToken, updatedValue, } from '@midnight-ntwrk/ledger-v6';
+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 { StateChange, VersionChangeType, } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+const progress = (state) => {
+    const appliedIndex = state.progress?.appliedIndex ?? 0n;
+    const highestRelevantWalletIndex = state.progress?.highestRelevantWalletIndex ?? 0n;
+    const highestIndex = state.progress?.highestIndex ?? 0n;
+    const highestRelevantIndex = state.progress?.highestRelevantIndex ?? 0n;
+    const sourceGap = highestIndex - highestRelevantIndex;
+    const applyGap = highestRelevantWalletIndex - appliedIndex;
+    return [StateChange.ProgressUpdate({ sourceGap, applyGap })];
+};
+const protocolVersionChange = (previous, current) => {
+    return previous.protocolVersion != current.protocolVersion
+        ? [
+            StateChange.VersionChange({
+                change: VersionChangeType.Version({
+                    version: ProtocolVersion.ProtocolVersion(current.protocolVersion),
+                }),
+            }),
+        ]
+        : [];
+};
+export const V1Tag = Symbol('V1');
+export class RunningV1Variant {
+    __polyTag__ = V1Tag;
+    #scope;
+    #context;
+    #v1Context;
+    state;
+    constructor(scope, context, v1Context) {
+        this.#scope = scope;
+        this.#context = context;
+        this.#v1Context = v1Context;
+        this.state = Stream.fromEffect(context.stateRef.get).pipe(Stream.flatMap((initialState) => context.stateRef.changes.pipe(Stream.mapAccum(initialState, (previous, current) => {
+            return [current, [previous, current]];
+        }))), Stream.mapConcat(([previous, current]) => {
+            // TODO: emit progress only upon actual change
+            return [
+                StateChange.State({ state: current }),
+                ...progress(current),
+                ...protocolVersionChange(previous, current),
+            ];
+        }));
+    }
+    startSyncInBackground(startAux) {
+        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 WalletError.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) => {
+            const maxDelay = Duration.minutes(2);
+            const jitter = Duration.millis(Math.floor(Math.random() * 1000));
+            const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);
+            return Duration.millis(Math.min(delayWithJitter, Duration.toMillis(maxDelay)));
+        }))));
+    }
+    createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+        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 this.#v1Context.transactingCapability
+                .createDustGenerationTransaction(currentTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
+                .pipe(EitherOps.toEffect);
+        }));
+    }
+    addDustGenerationSignature(transaction, signature) {
+        return this.#v1Context.transactingCapability
+            .addDustGenerationSignature(transaction, signature)
+            .pipe(EitherOps.toEffect);
+    }
+    calculateFee(transaction) {
+        return pipe(this.#v1Context.syncService.ledgerParameters(), Effect.map((params) => this.#v1Context.transactingCapability.calculateFee(transaction, params)));
+    }
+    addFeePayment(secretKey, transaction, currentTime, ttl) {
+        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]));
+        });
+    }
+    finalizeTransaction(recipe) {
+        return this.#v1Context.provingService
+            .prove(recipe)
+            .pipe(Effect.tapError(() => SubscriptionRef.updateEffect(this.#context.stateRef, (state) => EitherOps.toEffect(this.#v1Context.transactingCapability.revertRecipe(state, recipe)))));
+    }
+    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)))));
+    });
+}

package/dist/Serialization.d.ts

@@ -0,0 +1,9 @@
+import { Either, Schema } from 'effect';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { DustCoreWallet } from './DustCoreWallet.js';
+export type SerializationCapability<TWallet, TAux, TSerialized> = {
+    serialize(wallet: TWallet): TSerialized;
+    deserialize(aux: TAux, data: TSerialized): Either.Either<TWallet, WalletError.WalletError>;
+};
+export declare const Uint8ArraySchema: Schema.declare<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, readonly [], never>;
+export declare const makeDefaultV1SerializationCapability: () => SerializationCapability<DustCoreWallet, null, string>;