@midnightntwrk/wallet-sdk-dust-wallet 4.2.0

package/dist/v1/CoreWallet.js

@@ -0,0 +1,105 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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-v8';
+import { ProtocolVersion, SyncProgress } from '@midnightntwrk/wallet-sdk-abstractions';
+import { DateOps } from '@midnightntwrk/wallet-sdk-utilities';
+import { Array as Arr, Option, pipe } from 'effect';
+export const PublicKey = {
+    fromSecretKey: (secretKey) => {
+        return {
+            publicKey: secretKey.publicKey,
+        };
+    },
+};
+export const CoreWallet = {
+    init(localState, secretKey, networkId) {
+        return CoreWallet.empty(localState, PublicKey.fromSecretKey(secretKey), networkId);
+    },
+    initEmpty(dustParameters, secretKey, networkId) {
+        return CoreWallet.empty(new DustLocalState(dustParameters), PublicKey.fromSecretKey(secretKey), networkId);
+    },
+    empty(localState, publicKey, networkId) {
+        return {
+            state: localState,
+            publicKey,
+            networkId,
+            pendingDust: [],
+            progress: SyncProgress.createSyncProgress(),
+            protocolVersion: ProtocolVersion.MinSupportedVersion,
+        };
+    },
+    restore(localState, publicKey, pendingTokens, syncProgress, protocolVersion, networkId) {
+        return {
+            state: localState,
+            publicKey,
+            networkId,
+            pendingDust: pendingTokens,
+            progress: SyncProgress.createSyncProgress(syncProgress),
+            protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
+        };
+    },
+    applyEventsWithChanges(wallet, secretKey, events, currentTime) {
+        // TODO: replace currentTime with `updatedState.syncTime` introduced in ledger-6.2.0-rc.1
+        const stateWithChanges = wallet.state.replayEventsWithChanges(secretKey, events);
+        const updatedState = stateWithChanges.state.processTtls(currentTime);
+        const availableNonces = updatedState.utxos.map((utxo) => utxo.nonce);
+        return [
+            {
+                ...wallet,
+                state: updatedState,
+                pendingDust: wallet.pendingDust.filter((t) => availableNonces.includes(t.nonce)),
+            },
+            stateWithChanges.changes,
+        ];
+    },
+    applyFailed(wallet, tx) {
+        const pendingSpendsMap = CoreWallet.pendingDustToMap(wallet.pendingDust);
+        const relevantSpends = pipe([...(tx.intents?.values() ?? [])], Arr.flatMap((intent) => {
+            const spendTime = intent.dustActions?.ctime;
+            return (intent.dustActions?.spends ?? []).map((spend) => ({ spend, spendTime }));
+        }), Arr.filterMap(({ spend, spendTime }) => pipe(Option.fromNullable(pendingSpendsMap.get(spend.oldNullifier)), Option.map(() => ({ spend, spendTime })))));
+        const [updatedState, removedNullifiers] = pipe(relevantSpends, Arr.reduce([wallet.state, []], ([state, removed], { spend, spendTime }) => [
+            state.processTtls(DateOps.addSeconds(spendTime, wallet.state.params.dustGracePeriodSeconds)),
+            Arr.append(removed, spend.oldNullifier),
+        ]));
+        return {
+            ...wallet,
+            state: updatedState,
+            pendingDust: wallet.pendingDust.filter((coin) => !removedNullifiers.includes(coin.nullifier)),
+        };
+    },
+    revertTransaction(wallet, tx) {
+        return CoreWallet.applyFailed(wallet, tx);
+    },
+    updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }) {
+        const updatedProgress = SyncProgress.createSyncProgress({
+            appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+            highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+            highestIndex: highestIndex ?? wallet.progress.highestIndex,
+            highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+            isConnected: isConnected ?? wallet.progress.isConnected,
+        });
+        return { ...wallet, progress: updatedProgress };
+    },
+    spendCoins(wallet, secretKey, coins, currentTime) {
+        const [output, newState, newPending] = pipe(coins, Arr.reduce([[], wallet.state, wallet.pendingDust], ([spends, localState, pending], { token: coinToSpend, value: takeFee }) => {
+            const [newState, dustSpend] = localState.spend(secretKey, coinToSpend, takeFee, currentTime);
+            const newPending = [...pending, { ...coinToSpend, nullifier: dustSpend.oldNullifier }];
+            return [Arr.append(spends, dustSpend), newState, newPending];
+        }));
+        return [output, { ...wallet, state: newState, pendingDust: newPending }];
+    },
+    pendingDustToMap(coins) {
+        return new Map(coins.map(({ nullifier, ...coins }) => [nullifier, coins]));
+    },
+};

package/dist/v1/Keys.d.ts

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

package/dist/v1/Keys.js

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

package/dist/v1/RunningV1Variant.d.ts

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

package/dist/v1/RunningV1Variant.js

@@ -0,0 +1,143 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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-v8';
+import { ProtocolVersion } from '@midnightntwrk/wallet-sdk-abstractions';
+import { OtherWalletError } from './WalletError.js';
+import { ArrayOps, EitherOps } from '@midnightntwrk/wallet-sdk-utilities';
+import { StateChange, VersionChangeType, } from '@midnightntwrk/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) => SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => Effect.try({
+            try: () => {
+                const [newState, changesResult] = this.#v1Context.syncCapability.applyUpdate(state, update);
+                return [changesResult, newState];
+            },
+            catch: (err) => new OtherWalletError({
+                message: 'Error while applying sync update',
+                cause: err,
+            }),
+        })).pipe(Effect.flatMap(({ changes, protocolVersion }) => 
+        // Skip the tx-history fork entirely when there are no changes.
+        // Forking unconditionally allocates a fiber per apply call (one
+        // for every batch the sync emits, even the all-progress ones),
+        // which adds up fast during catch-up.
+        changes.length === 0
+            ? Effect.void
+            : pipe(Effect.forEach(changes, (change) => pipe(this.#v1Context.transactionHistoryService.getTransactionDetails(change.source), Effect.flatMap((metadata) => this.#v1Context.transactionHistoryService.put(change, metadata, protocolVersion)), Effect.catchAllCause((cause) => Console.error('Error processing tx history metadata', cause))), { discard: true, concurrency: 'unbounded' }), Effect.forkScoped)), Effect.provideService(Scope.Scope, this.#scope))), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
+            const maxDelay = Duration.minutes(2);
+            const jitter = Duration.millis(Math.floor(Math.random() * 1000));
+            const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);
+            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(new OtherWalletError({ message: 'Token of a non-Night type received' }));
+        }
+        return Effect.gen(this, function* () {
+            const currentState = yield* SubscriptionRef.get(this.#context.stateRef);
+            const blockData = yield* this.#v1Context.syncService.blockData();
+            const resolvedTime = currentTime ?? blockData.timestamp;
+            const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, resolvedTime);
+            return yield* this.#v1Context.transactingCapability
+                .createDustGenerationTransaction(resolvedTime, ttl, utxosWithDustValue, nightVerifyingKey, dustReceiverAddress)
+                .pipe(EitherOps.toEffect);
+        });
+    }
+    splitNightUtxosForDustRegistration(currentTime, nightUtxos, isRegistration) {
+        if (nightUtxos.some((utxo) => utxo.type !== nativeToken().raw)) {
+            return Effect.fail(new OtherWalletError({ message: 'Token of a non-Night type received' }));
+        }
+        return Effect.gen(this, function* () {
+            const currentState = yield* SubscriptionRef.get(this.#context.stateRef);
+            const utxosWithDustValue = this.#v1Context.coinsAndBalancesCapability.estimateDustGeneration(currentState, nightUtxos, currentTime);
+            return this.#v1Context.transactingCapability.splitNightUtxosForDustRegistration(utxosWithDustValue, isRegistration);
+        });
+    }
+    attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment) {
+        return this.#v1Context.transactingCapability
+            .attachDustRegistration(transaction, currentTime, nightVerifyingKey, dustReceiverAddress, feePayment)
+            .pipe(EitherOps.toEffect);
+    }
+    addDustGenerationSignature(transaction, signature) {
+        return this.#v1Context.transactingCapability
+            .addDustGenerationSignature(transaction, signature)
+            .pipe(EitherOps.toEffect);
+    }
+    addDustRegistrationSignature(transaction, signature) {
+        return this.#v1Context.transactingCapability
+            .addDustRegistrationSignature(transaction, signature)
+            .pipe(EitherOps.toEffect);
+    }
+    calculateFee(transactions) {
+        return pipe(this.#v1Context.syncService.blockData(), Effect.map((blockData) => pipe(transactions, Arr.map((transaction) => this.#v1Context.transactingCapability.calculateFee(transaction, blockData.ledgerParameters)), ArrayOps.sumBigInt)));
+    }
+    estimateFee(secretKey, transactions, ttl, currentTime) {
+        return pipe(Effect.all([SubscriptionRef.get(this.#context.stateRef), this.#v1Context.syncService.blockData()]), Effect.flatMap(([state, blockData]) => pipe(this.#v1Context.transactingCapability.estimateFee(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters), EitherOps.toEffect)));
+    }
+    balanceTransactions(secretKey, transactions, ttl, currentTime) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.syncService.blockData(), Effect.flatMap((blockData) => this.#v1Context.transactingCapability.balanceTransactions(secretKey, state, transactions, ttl, currentTime ?? blockData.timestamp, blockData.ledgerParameters)));
+        });
+    }
+    revertTransaction(transaction) {
+        return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.revertTransaction(state, transaction), EitherOps.toEffect);
+        });
+    }
+}

package/dist/v1/Serialization.d.ts

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

package/dist/v1/Serialization.js

@@ -0,0 +1,75 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 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-v8';
+import { OtherWalletError } from './WalletError.js';
+import { CoreWallet } from './CoreWallet.js';
+const StateSchema = Schema.declare((input) => input instanceof ledger.DustLocalState).annotations({
+    identifier: 'ledger.DustLocalState',
+});
+export const Uint8ArraySchema = Schema.declare((input) => input instanceof Uint8Array).annotations({
+    identifier: 'Uint8Array',
+});
+const StateFromUInt8Array = Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, StateSchema, {
+    encode: (state) => {
+        return Effect.try({
+            try: () => {
+                return state.serialize();
+            },
+            catch: (err) => {
+                return new ParseResult.Unexpected(err, 'Could not serialize local state');
+            },
+        });
+    },
+    decode: (bytes) => Effect.try({
+        try: () => ledger.DustLocalState.deserialize(bytes),
+        catch: (err) => {
+            return new ParseResult.Unexpected(err, 'Could not deserialize local state');
+        },
+    }),
+}));
+const HexedState = pipe(Schema.Uint8ArrayFromHex, Schema.compose(StateFromUInt8Array));
+const SnapshotSchema = Schema.Struct({
+    publicKey: Schema.Struct({
+        publicKey: Schema.BigInt,
+    }),
+    state: HexedState,
+    protocolVersion: Schema.BigInt,
+    networkId: Schema.String,
+    offset: Schema.optional(Schema.BigInt),
+});
+export const makeDefaultV1SerializationCapability = () => {
+    return {
+        serialize: (wallet) => {
+            const buildSnapshot = (w) => ({
+                publicKey: w.publicKey,
+                state: w.state,
+                protocolVersion: w.protocolVersion,
+                networkId: w.networkId,
+                offset: w.progress?.appliedIndex,
+            });
+            return pipe(wallet, buildSnapshot, Schema.encodeSync(SnapshotSchema), JSON.stringify);
+        },
+        deserialize: (aux, serialized) => {
+            return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SnapshotSchema)), Either.mapLeft((err) => new OtherWalletError({ message: 'Error while deserializing snapshot', cause: err })), Either.flatMap((snapshot) => Either.try({
+                try: () => CoreWallet.restore(snapshot.state, snapshot.publicKey, [], {
+                    appliedIndex: snapshot.offset ?? 0n,
+                    highestRelevantWalletIndex: 0n,
+                    highestIndex: 0n,
+                    highestRelevantIndex: 0n,
+                }, snapshot.protocolVersion, snapshot.networkId),
+                catch: (err) => new OtherWalletError({ message: 'Error while restoring core wallet', cause: err }),
+            })));
+        },
+    };
+};

package/dist/v1/Sync.d.ts

@@ -0,0 +1,96 @@
+import { Effect, Layer, Schema, type Scope, Stream } from 'effect';
+import { type DustSecretKey, type DustStateChanges, Event as LedgerEvent, LedgerParameters } from '@midnight-ntwrk/ledger-v8';
+import { type SubscriptionClient, type QueryClient } from '@midnightntwrk/wallet-sdk-indexer-client/effect';
+import { type WalletError } from './WalletError.js';
+import { type Simulator, type SimulatorState } from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+import { CoreWallet } from './CoreWallet.js';
+import { type NetworkId } from './types/ledger.js';
+export interface SyncService<TState, TStartAux, TUpdate> {
+    updates: (state: TState, auxData: TStartAux) => Stream.Stream<TUpdate, WalletError, Scope.Scope>;
+    blockData: () => Effect.Effect<BlockData, WalletError>;
+}
+export interface BlockData {
+    hash: string;
+    height: number;
+    ledgerParameters: LedgerParameters;
+    timestamp: Date;
+}
+export type ChangesResult = {
+    readonly changes: DustStateChanges[];
+    readonly protocolVersion: number;
+};
+export interface SyncCapability<TState, TUpdate, TResult> {
+    applyUpdate: (state: TState, update: TUpdate) => [TState, TResult];
+}
+export type IndexerClientConnection = {
+    indexerHttpUrl: string;
+    indexerWsUrl?: string;
+    keepAlive?: number;
+    /** Cap on the in-flight event queue between the WebSocket push and the apply loop. Default: 10000. */
+    bufferSize?: number;
+    /** In-flight count at which the disposed WS subscription is reopened. Default: 100. */
+    resumeThreshold?: number;
+};
+export type BatchUpdatesConfig = {
+    /**
+     * Maximum number of events to collect into a single batch before emitting.
+     *
+     * @default 10
+     */
+    readonly size?: number;
+    /**
+     * Maximum time in milliseconds to wait for a full batch before emitting a partial one. Controls the `groupedWithin`
+     * timeout — lower values mean more responsive (but smaller) batches when events arrive slowly.
+     *
+     * @default 1
+     */
+    readonly timeout?: number;
+    /**
+     * Minimum delay in milliseconds injected between consecutive batches. Prevents the sync stream from saturating
+     * downstream consumers when many events are available at once. Set to 0 to disable spacing entirely.
+     *
+     * @default 4
+     */
+    readonly spacing?: number;
+};
+export type DefaultSyncConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+    networkId: NetworkId;
+    batchUpdates?: BatchUpdatesConfig;
+};
+export type SimulatorSyncConfiguration = {
+    simulator: Simulator;
+    networkId: NetworkId;
+};
+export type SimulatorSyncUpdate = {
+    update: SimulatorState;
+    secretKey: DustSecretKey;
+};
+export type SecretKeysResource = <A>(cb: (key: DustSecretKey) => A) => A;
+export declare const SecretKeysResource: {
+    create: (secretKey: DustSecretKey) => SecretKeysResource;
+};
+export declare const SyncEventsUpdateSchema: Schema.Struct<{
+    id: typeof Schema.Number;
+    raw: Schema.Schema<LedgerEvent, string, never>;
+    maxId: typeof Schema.Number;
+}>;
+export type WalletSyncSubscription = Schema.Schema.Type<typeof SyncEventsUpdateSchema>;
+export type WalletSyncUpdate = {
+    updates: WalletSyncSubscription[];
+    secretKey: DustSecretKey;
+    timestamp: Date;
+};
+export declare const WalletSyncUpdate: {
+    create: (updates: WalletSyncSubscription[], secretKey: DustSecretKey, timestamp: Date) => WalletSyncUpdate;
+};
+export declare const makeDefaultSyncService: (config: DefaultSyncConfiguration) => SyncService<CoreWallet, DustSecretKey, WalletSyncUpdate>;
+export type IndexerSyncService = {
+    connectionLayer: () => Layer.Layer<SubscriptionClient, WalletError, Scope.Scope>;
+    subscribeWallet: (state: CoreWallet) => Stream.Stream<WalletSyncSubscription, WalletError, Scope.Scope | SubscriptionClient>;
+    queryClient: () => Layer.Layer<QueryClient, WalletError, Scope.Scope>;
+};
+export declare const makeIndexerSyncService: (config: DefaultSyncConfiguration) => IndexerSyncService;
+export declare const makeDefaultSyncCapability: () => SyncCapability<CoreWallet, WalletSyncUpdate, ChangesResult>;
+export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<CoreWallet, DustSecretKey, SimulatorSyncUpdate>;
+export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate, ChangesResult>;