@midnight-ntwrk/wallet-sdk-shielded 1.0.0-beta.10

package/dist/v1/RunningV1Variant.d.ts

@@ -0,0 +1,46 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Effect, Scope, Stream } from 'effect';
+import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { ProvingService } from './Proving.js';
+import { ProvingRecipe } from './ProvingRecipe.js';
+import { SerializationCapability } from './Serialization.js';
+import { EventsSyncUpdate, SyncCapability, SyncService } from './Sync.js';
+import { TransactingCapability, TokenTransfer } from './Transacting.js';
+import { WalletError } from './WalletError.js';
+import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { KeysCapability } from './Keys.js';
+import { SubmissionService, SubmitTransactionMethod } from './Submission.js';
+import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet } from './CoreWallet.js';
+import { TransactionHistoryCapability } from './TransactionHistory.js';
+export declare namespace RunningV1Variant {
+    type Context<TSerialized, TSyncUpdate, TTransaction, TStartAux> = {
+        serializationCapability: SerializationCapability<CoreWallet, null, TSerialized>;
+        syncService: SyncService<CoreWallet, TStartAux, TSyncUpdate>;
+        syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
+        transactingCapability: TransactingCapability<ledger.ZswapSecretKeys, CoreWallet, TTransaction>;
+        provingService: ProvingService<TTransaction>;
+        coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
+        keysCapability: KeysCapability<CoreWallet>;
+        submissionService: SubmissionService<TTransaction>;
+        coinSelection: CoinSelection<ledger.QualifiedShieldedCoinInfo>;
+        transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, TTransaction>;
+    };
+    type AnyContext = Context<any, any, any, any>;
+}
+export declare const V1Tag: unique symbol;
+export type DefaultRunningV1 = RunningV1Variant<string, EventsSyncUpdate, ledger.FinalizedTransaction, ledger.ZswapSecretKeys>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
+    #private;
+    readonly __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>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>): Effect.Effect<ProvingRecipe<TTransaction>, WalletError>;
+    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
+    submitTransaction: SubmitTransactionMethod<TTransaction>;
+    serializeState(state: CoreWallet): TSerialized;
+}

package/dist/v1/RunningV1Variant.js

@@ -0,0 +1,95 @@
+import { Effect, pipe, Scope, Stream, SubscriptionRef, Schedule, Duration, Sink, Console } from 'effect';
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { StateChange, VersionChangeType, } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { OtherWalletError } from './WalletError.js';
+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 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)));
+        }))));
+    }
+    balanceTransaction(secretKeys, tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceTransaction(secretKeys, state, tx), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+        });
+    }
+    transferTransaction(secretKeys, outputs) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(secretKeys, state, outputs), EitherOps.toEffect, Effect.map(({ recipe, newState }) => [recipe, newState]));
+        });
+    }
+    initSwap(secretKeys, desiredInputs, desiredOutputs) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.initSwap(secretKeys, state, desiredInputs, desiredOutputs), EitherOps.toEffect, 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)))));
+    });
+    serializeState(state) {
+        return this.#v1Context.serializationCapability.serialize(state);
+    }
+}

package/dist/v1/Serialization.d.ts

@@ -0,0 +1,12 @@
+import { Either } from 'effect';
+import { WalletError } from './WalletError.js';
+import { CoreWallet } from './CoreWallet.js';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+export type SerializationCapability<TWallet, TAux, TSerialized> = {
+    serialize(wallet: TWallet): TSerialized;
+    deserialize(aux: TAux, data: TSerialized): Either.Either<TWallet, WalletError>;
+};
+export type DefaultSerializationConfiguration = {
+    networkId: NetworkId.NetworkId;
+};
+export declare const makeDefaultV1SerializationCapability: () => SerializationCapability<CoreWallet, null, string>;

package/dist/v1/Serialization.js

@@ -0,0 +1,103 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect, ParseResult, Either, pipe, Schema } from 'effect';
+import { WalletError } from './WalletError.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { CoreWallet } from './CoreWallet.js';
+const TxSchema = Schema.declare((input) => input instanceof ledger.Transaction).annotations({
+    identifier: 'ledger.Transaction',
+});
+const StateSchema = Schema.declare((input) => input instanceof ledger.ZswapLocalState).annotations({
+    identifier: 'ledger.ZswapLocalState',
+});
+const Uint8ArraySchema = Schema.declare((input) => input instanceof Uint8Array).annotations({
+    identifier: 'Uint8Array',
+});
+const TxFromUint8Array = () => Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, TxSchema, {
+    encode: (tx) => {
+        return Effect.try({
+            try: () => {
+                return tx.serialize();
+            },
+            catch: (err) => {
+                return new ParseResult.Unexpected(err, 'Could not serialize transaction');
+            },
+        });
+    },
+    decode: (bytes) => Effect.try({
+        try: () => ledger.Transaction.deserialize('signature', 'proof', 'binding', bytes),
+        catch: (err) => {
+            return new ParseResult.Unexpected(err, 'Could not deserialize transaction');
+        },
+    }),
+}));
+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.ZswapLocalState.deserialize(bytes),
+        catch: (err) => {
+            return new ParseResult.Unexpected(err, 'Could not deserialize local state');
+        },
+    }),
+}));
+const HexedTx = () => pipe(Schema.Uint8ArrayFromHex, Schema.compose(TxFromUint8Array()));
+const HexedState = () => pipe(Schema.Uint8ArrayFromHex, Schema.compose(StateFromUInt8Array()));
+export const makeDefaultV1SerializationCapability = () => {
+    const SnapshotSchema = Schema.Struct({
+        publicKeys: Schema.Struct({
+            coinPublicKey: Schema.String,
+            encryptionPublicKey: Schema.String,
+        }),
+        txHistory: Schema.Array(HexedTx()),
+        state: HexedState(),
+        protocolVersion: Schema.BigInt,
+        offset: Schema.optional(Schema.BigInt),
+        networkId: Schema.String,
+        coinHashes: Schema.Record({
+            key: Schema.String,
+            value: Schema.Struct({ nullifier: Schema.String, commitment: Schema.String }),
+        }),
+    });
+    return {
+        serialize: (wallet) => {
+            const buildSnapshot = (w) => ({
+                publicKeys: w.publicKeys,
+                txHistory: w.txHistoryArray,
+                state: w.state,
+                protocolVersion: w.protocolVersion,
+                networkId: w.networkId,
+                offset: w.progress?.appliedIndex,
+                coinHashes: w.coinHashes,
+            });
+            return pipe(wallet, buildSnapshot, Schema.encodeSync(SnapshotSchema), JSON.stringify);
+        },
+        deserialize: (aux, serialized) => {
+            return pipe(serialized, Schema.decodeUnknownEither(Schema.parseJson(SnapshotSchema)), Either.mapLeft((err) => WalletError.other(err)), Either.flatMap((snapshot) => CoreWallet.restoreWithCoinHashes(snapshot.publicKeys, snapshot.state, snapshot.txHistory, snapshot.coinHashes, {
+                appliedIndex: snapshot.offset ?? 0n,
+                highestRelevantWalletIndex: 0n,
+                highestIndex: 0n,
+                highestRelevantIndex: 0n,
+                isConnected: false,
+            }, snapshot.protocolVersion, snapshot.networkId)));
+        },
+    };
+};

package/dist/v1/Simulator.d.ts

@@ -0,0 +1,22 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Array as Arr, Effect, Scope, Stream, SubscriptionRef } from 'effect';
+export type SimulatorState = Readonly<{
+    ledger: ledger.LedgerState;
+    lastTxResult: ledger.TransactionResult;
+    lastTxNumber: bigint;
+}>;
+export declare class Simulator {
+    #private;
+    static nextBlockContext: (number: bigint) => Effect.Effect<ledger.BlockContext>;
+    static init(genesisMints: Readonly<Arr.NonEmptyArray<{
+        amount: bigint;
+        type: ledger.RawTokenType;
+        recipient: ledger.ZswapSecretKeys;
+    }>>): Effect.Effect<Simulator, never, Scope.Scope>;
+    readonly state$: Stream.Stream<SimulatorState>;
+    constructor(stateRef: SubscriptionRef.SubscriptionRef<SimulatorState>, state$: Stream.Stream<SimulatorState>);
+    submitRegularTx(tx: ledger.ProofErasedTransaction): Effect.Effect<{
+        blockNumber: bigint;
+        blockHash: string;
+    }>;
+}

package/dist/v1/Simulator.js

@@ -0,0 +1,102 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Array as Arr, Effect, Encoding, pipe, Stream, SubscriptionRef, Clock } from 'effect';
+import { ArrayOps, EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import * as crypto from 'crypto';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+const simpleHash = (input) => {
+    return Encoding.decodeHex(input).pipe(EitherOps.toEffect, Effect.andThen((parsed) => Effect.promise(() => crypto.subtle.digest('SHA-256', parsed))), Effect.andThen((out) => Encoding.encodeHex(new Uint8Array(out))), Effect.orDie);
+};
+const wellFormedStrictness = (params = {}) => {
+    const strictness = new ledger.WellFormedStrictness();
+    // Note: Enforce balancing should be true by default outside genesis mints
+    strictness.enforceBalancing = params?.enforceBalancing ?? false;
+    strictness.verifyNativeProofs = params?.verifyNativeProofs ?? false;
+    strictness.verifyContractProofs = params?.verifyContractProofs ?? false;
+    strictness.enforceLimits = params?.enforceLimits ?? false;
+    strictness.verifySignatures = params?.verifySignatures ?? false;
+    return strictness;
+};
+export class Simulator {
+    static nextBlockContext = (number) => pipe(number.toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash, Effect.map((hash) => ({
+        parentBlockHash: hash,
+        secondsSinceEpoch: number,
+        secondsSinceEpochErr: 1,
+    })));
+    static init(genesisMints) {
+        const emptyState = ledger.LedgerState.blank(NetworkId.NetworkId.Undeployed);
+        const noStrictness = wellFormedStrictness();
+        const makeTransactions = (context) => Effect.gen(function* () {
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const verificationTime = new Date(nowMillis);
+            const tx = pipe(genesisMints, Arr.map((transfer) => {
+                const coin = ledger.createShieldedCoinInfo(transfer.type, transfer.amount);
+                const output = ledger.ZswapOutput.new(coin, 0, transfer.recipient.coinPublicKey, transfer.recipient.encryptionPublicKey);
+                return ledger.ZswapOffer.fromOutput(output, transfer.type, transfer.amount);
+            }), ArrayOps.fold((acc, offer) => acc.merge(offer)), (offer) => ledger.Transaction.fromParts(NetworkId.NetworkId.Undeployed, offer).eraseProofs(), (tx) => tx.wellFormed(emptyState, noStrictness, verificationTime));
+            const [initialState, initialResult] = emptyState.apply(tx, new ledger.TransactionContext(emptyState, context));
+            const postBlockUpdateState = initialState.postBlockUpdate(verificationTime);
+            return {
+                initialResult,
+                initialState: postBlockUpdateState,
+                tx,
+            };
+        });
+        return Effect.gen(function* () {
+            const context = yield* Simulator.nextBlockContext(0n);
+            const init = yield* makeTransactions(context);
+            const initialState = {
+                ledger: init.initialState,
+                lastTxResult: init.initialResult,
+                lastTxNumber: 0n,
+            };
+            const ref = yield* SubscriptionRef.make(initialState);
+            const changesStream = yield* Stream.share(ref.changes, {
+                capacity: 'unbounded',
+                replay: Number.MAX_SAFE_INTEGER,
+            });
+            yield* pipe(changesStream, Stream.runDrain, Effect.forkScoped);
+            return new Simulator(ref, changesStream);
+        });
+    }
+    #stateRef;
+    state$;
+    constructor(stateRef, state$) {
+        this.#stateRef = stateRef;
+        this.state$ = state$;
+    }
+    submitRegularTx(tx) {
+        return pipe(this.#stateRef, SubscriptionRef.modifyEffect((simulatorState) => Effect.gen(function* () {
+            const nextNumber = simulatorState.lastTxNumber + 1n;
+            const context = yield* Simulator.nextBlockContext(nextNumber);
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const verificationTime = new Date(nowMillis);
+            const noStrictness = wellFormedStrictness();
+            const verifiedTx = tx.wellFormed(simulatorState.ledger, noStrictness, verificationTime);
+            const [newState, result] = simulatorState.ledger.apply(verifiedTx, new ledger.TransactionContext(simulatorState.ledger, context));
+            const postBlockUpdatedState = newState.postBlockUpdate(verificationTime);
+            const newSimulatorState = {
+                ...simulatorState,
+                ledger: postBlockUpdatedState,
+                lastTxResult: result,
+                lastTxNumber: nextNumber,
+            };
+            const output = {
+                blockNumber: nextNumber,
+                blockHash: context.parentBlockHash,
+            };
+            return [output, newSimulatorState];
+        })));
+    }
+}

package/dist/v1/Submission.d.ts

@@ -0,0 +1,31 @@
+import { Effect } from 'effect';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { WalletError } from './WalletError.js';
+import { Simulator } from './Simulator.js';
+import { SubmissionEvent as SubmissionEventImported } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
+export declare const SubmissionEvent: typeof SubmissionEventImported;
+export type SubmissionEvent = SubmissionEventImported.SubmissionEvent;
+export declare namespace SubmissionEventCases {
+    type Finalized = SubmissionEventImported.Cases.Finalized;
+    type Submitted = SubmissionEventImported.Cases.Submitted;
+    type InBlock = SubmissionEventImported.Cases.InBlock;
+}
+export type SubmitTransactionMethod<TTransaction> = {
+    (transaction: TTransaction, waitForStatus: 'Submitted'): Effect.Effect<SubmissionEventCases.Submitted, WalletError>;
+    (transaction: TTransaction, waitForStatus: 'InBlock'): Effect.Effect<SubmissionEventCases.InBlock, WalletError>;
+    (transaction: TTransaction, waitForStatus: 'Finalized'): Effect.Effect<SubmissionEventCases.Finalized, WalletError>;
+    (transaction: TTransaction): Effect.Effect<SubmissionEventCases.InBlock, WalletError>;
+    (transaction: TTransaction, waitForStatus?: 'Submitted' | 'InBlock' | 'Finalized'): Effect.Effect<SubmissionEvent, WalletError>;
+};
+export interface SubmissionService<TTransaction> {
+    submitTransaction: SubmitTransactionMethod<TTransaction>;
+    close(): Effect.Effect<void>;
+}
+export type DefaultSubmissionConfiguration = {
+    relayURL: URL;
+};
+export declare const makeDefaultSubmissionService: (config: DefaultSubmissionConfiguration) => SubmissionService<ledger.FinalizedTransaction>;
+export type SimulatorSubmissionConfiguration = {
+    simulator: Simulator;
+};
+export declare const makeSimulatorSubmissionService: (waitForStatus?: "Submitted" | "InBlock" | "Finalized") => (config: SimulatorSubmissionConfiguration) => SubmissionService<ledger.ProofErasedTransaction>;

package/dist/v1/Submission.js

@@ -0,0 +1,69 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Deferred, Effect, Encoding, Exit, pipe, Scope } from 'effect';
+import { WalletError } from './WalletError.js';
+import { NodeClient, PolkadotNodeClient, SubmissionEvent as SubmissionEventImported, } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
+export const SubmissionEvent = SubmissionEventImported;
+export const makeDefaultSubmissionService = (config) => {
+    const scopeAndClientDeferred = Deferred.make().pipe(Effect.runSync);
+    const makeScopeAndClient = Effect.gen(function* () {
+        const scope = yield* Scope.make();
+        const client = yield* PolkadotNodeClient.make({
+            nodeURL: config.relayURL,
+        }).pipe(Effect.provideService(Scope.Scope, scope));
+        return { scope, client };
+    });
+    void pipe(scopeAndClientDeferred, Deferred.complete(makeScopeAndClient), Effect.runPromise);
+    const submit = (transaction, waitForStatus = 'InBlock') => {
+        return pipe(NodeClient.sendMidnightTransactionAndWait(transaction.serialize(), waitForStatus), Effect.provideServiceEffect(NodeClient.NodeClient, pipe(scopeAndClientDeferred, Deferred.await, Effect.map(({ client }) => client))), Effect.mapError((err) => WalletError.submission(err)));
+    };
+    return {
+        submitTransaction: submit,
+        close() {
+            return pipe(scopeAndClientDeferred, Deferred.await, Effect.flatMap(({ scope }) => Scope.close(scope, Exit.void)), Effect.ignoreLogged);
+        },
+    };
+};
+export const makeSimulatorSubmissionService = (waitForStatus = 'InBlock') => (config) => {
+    const submit = (transaction) => {
+        const serializedTx = transaction.serialize();
+        return config.simulator.submitRegularTx(transaction).pipe(Effect.map((output) => {
+            // Let's mimic node's client behavior here
+            switch (waitForStatus) {
+                case 'Submitted':
+                    return SubmissionEvent.Submitted({
+                        tx: serializedTx,
+                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
+                    });
+                case 'InBlock':
+                    return SubmissionEvent.InBlock({
+                        tx: serializedTx,
+                        blockHash: output.blockHash,
+                        blockHeight: output.blockNumber,
+                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
+                    });
+                case 'Finalized':
+                    return SubmissionEvent.Finalized({
+                        tx: serializedTx,
+                        blockHash: output.blockHash,
+                        blockHeight: output.blockNumber,
+                        txHash: Encoding.encodeHex(serializedTx.subarray(0, 32)),
+                    });
+            }
+        }));
+    };
+    return {
+        submitTransaction: submit,
+        close: () => Effect.void,
+    };
+};

package/dist/v1/Sync.d.ts

@@ -0,0 +1,51 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Scope, Stream, Schema } from 'effect';
+import { CoreWallet } from './CoreWallet.js';
+import { Simulator, SimulatorState } from './Simulator.js';
+import { WalletError } from './WalletError.js';
+import { TransactionHistoryCapability } from './TransactionHistory.js';
+export interface SyncService<TState, TStartAux, TUpdate> {
+    updates: (state: TState, auxData: TStartAux) => Stream.Stream<TUpdate, WalletError, Scope.Scope>;
+}
+export interface SyncCapability<TState, TUpdate> {
+    applyUpdate: (state: TState, update: TUpdate) => TState;
+}
+export type IndexerClientConnection = {
+    indexerHttpUrl: string;
+    indexerWsUrl?: string;
+};
+export type DefaultSyncConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+};
+export type DefaultSyncContext = {
+    transactionHistoryCapability: TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
+};
+type SecretKeysResource = <A>(cb: (keys: ledger.ZswapSecretKeys) => A) => A;
+export declare const SecretKeysResource: {
+    create: (secretKeys: ledger.ZswapSecretKeys) => SecretKeysResource;
+};
+export type WalletSyncUpdate = {
+    update: EventsSyncUpdate;
+    secretKeys: SecretKeysResource;
+};
+export declare const WalletSyncUpdate: {
+    create: (update: EventsSyncUpdate, secretKeys: ledger.ZswapSecretKeys) => WalletSyncUpdate;
+};
+export declare const EventsSyncUpdate: Schema.TaggedStruct<"EventsSyncUpdate", {
+    id: typeof Schema.Number;
+    maxId: typeof Schema.Number;
+    event: Schema.declare<ledger.Event, ledger.Event, readonly [], never>;
+}>;
+export type EventsSyncUpdate = Schema.Schema.Type<typeof EventsSyncUpdate>;
+export declare const makeEventsSyncService: (config: DefaultSyncConfiguration) => SyncService<CoreWallet, ledger.ZswapSecretKeys, WalletSyncUpdate>;
+export declare const makeEventsSyncCapability: () => SyncCapability<CoreWallet, WalletSyncUpdate>;
+export type SimulatorSyncConfiguration = {
+    simulator: Simulator;
+};
+export type SimulatorSyncUpdate = {
+    update: SimulatorState;
+    secretKeys: ledger.ZswapSecretKeys;
+};
+export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<CoreWallet, ledger.ZswapSecretKeys, SimulatorSyncUpdate>;
+export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate>;
+export {};