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

package/dist/Serialization.js

@@ -0,0 +1,64 @@
+import { Effect, ParseResult, Either, pipe, Schema } from 'effect';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { DustCoreWallet } from './DustCoreWallet.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) => WalletError.WalletError.other(err)), Either.flatMap((snapshot) => Either.try({
+                try: () => DustCoreWallet.restore(snapshot.state, snapshot.publicKey, [], {
+                    appliedIndex: snapshot.offset ?? 0n,
+                    highestRelevantWalletIndex: 0n,
+                    highestIndex: 0n,
+                    highestRelevantIndex: 0n,
+                    isConnected: false,
+                }, snapshot.protocolVersion, snapshot.networkId),
+                catch: (err) => WalletError.WalletError.other(err),
+            })));
+        },
+    };
+};

package/dist/Simulator.d.ts

@@ -0,0 +1,32 @@
+import { Effect, Either, Scope, Stream, SubscriptionRef } from 'effect';
+import { LedgerState, BlockContext, UserAddress, SignatureVerifyingKey, WellFormedStrictness, TransactionResult, ProofErasedTransaction, SyntheticCost } from '@midnight-ntwrk/ledger-v6';
+import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { NetworkId } from './types/ledger.js';
+export type SimulatorState = Readonly<{
+    networkId: NetworkId;
+    ledger: LedgerState;
+    lastTx: ProofErasedTransaction | undefined;
+    lastTxResult: TransactionResult | undefined;
+    lastTxNumber: bigint;
+}>;
+export declare class Simulator {
+    #private;
+    static nextBlockContext: (blockTime: Date) => Effect.Effect<BlockContext>;
+    static init(networkId: NetworkId): Effect.Effect<Simulator, never, Scope.Scope>;
+    static apply(simulatorState: SimulatorState, tx: ProofErasedTransaction, strictness: WellFormedStrictness, blockContext: BlockContext, blockFullness?: SyntheticCost): Either.Either<[{
+        blockNumber: bigint;
+        blockHash: string;
+    }, SimulatorState], LedgerOps.LedgerError>;
+    readonly state$: Stream.Stream<SimulatorState>;
+    constructor(stateRef: SubscriptionRef.SubscriptionRef<SimulatorState>, state$: Stream.Stream<SimulatorState>);
+    getLatestState(): Effect.Effect<SimulatorState>;
+    rewardNight(recipient: UserAddress, amount: bigint, verifyingKey: SignatureVerifyingKey): Effect.Effect<{
+        blockNumber: bigint;
+        blockHash: string;
+    }, LedgerOps.LedgerError>;
+    submitRegularTx(tx: ProofErasedTransaction, blockFullness?: SyntheticCost): Effect.Effect<{
+        blockNumber: bigint;
+        blockHash: string;
+    }, LedgerOps.LedgerError>;
+    fastForward(lastTxNumber: bigint): Effect.Effect<undefined, LedgerOps.LedgerError>;
+}

package/dist/Simulator.js

@@ -0,0 +1,98 @@
+import { Effect, Encoding, pipe, Stream, SubscriptionRef } from 'effect';
+import { LedgerState, ClaimRewardsTransaction, SignatureErased, Transaction, WellFormedStrictness, TransactionContext, } from '@midnight-ntwrk/ledger-v6';
+import { DateOps, EitherOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import * as crypto from 'crypto';
+const simpleHash = (input) => {
+    return Encoding.decodeHex(input).pipe(EitherOps.toEffect, Effect.andThen((parsed) => Effect.promise(() => crypto.subtle.digest('SHA-256', parsed))), Effect.andThen((out) => Encoding.encodeHex(new Uint8Array(out))), Effect.orDie);
+};
+export class Simulator {
+    static nextBlockContext = (blockTime) => pipe(DateOps.dateToSeconds(blockTime).toString(16), (str) => (str.length % 2 == 0 ? str : str.padStart(str.length + 1, '0')), simpleHash, Effect.map((hash) => ({
+        parentBlockHash: hash,
+        secondsSinceEpoch: DateOps.dateToSeconds(blockTime),
+        secondsSinceEpochErr: 1,
+    })));
+    static init(networkId) {
+        return Effect.gen(function* () {
+            const initialState = {
+                networkId,
+                ledger: LedgerState.blank(networkId),
+                lastTx: undefined,
+                lastTxResult: undefined,
+                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);
+        });
+    }
+    static apply(simulatorState, tx, strictness, blockContext, blockFullness) {
+        return LedgerOps.ledgerTry(() => {
+            blockFullness = blockFullness ?? tx.cost(simulatorState.ledger.parameters);
+            const blockNumber = blockContext.secondsSinceEpoch;
+            const blockTime = DateOps.secondsToDate(blockNumber);
+            const verifiedTransaction = tx.wellFormed(simulatorState.ledger, strictness, blockTime);
+            const transactionContext = new TransactionContext(simulatorState.ledger, blockContext);
+            const [newLedgerState, txResult] = simulatorState.ledger.apply(verifiedTransaction, transactionContext);
+            const newSimulatorState = {
+                ...simulatorState,
+                ledger: newLedgerState.postBlockUpdate(blockTime, blockFullness),
+                lastTx: tx,
+                lastTxResult: txResult,
+                lastTxNumber: blockNumber,
+            };
+            const output = {
+                blockNumber,
+                blockHash: blockContext.parentBlockHash,
+            };
+            return [output, newSimulatorState];
+        });
+    }
+    #stateRef;
+    state$;
+    constructor(stateRef, state$) {
+        this.#stateRef = stateRef;
+        this.state$ = state$;
+    }
+    getLatestState() {
+        return SubscriptionRef.get(this.#stateRef);
+    }
+    rewardNight(recipient, amount, verifyingKey) {
+        return SubscriptionRef.modifyEffect(this.#stateRef, (simulatorState) => Effect.gen(function* () {
+            const nextNumber = DateOps.secondsToDate(simulatorState.lastTxNumber + 1n);
+            const newLedgerState = yield* LedgerOps.ledgerTry(() => simulatorState.ledger.testingDistributeNight(recipient, amount, nextNumber));
+            const newSimulatorState = {
+                ...simulatorState,
+                ledger: newLedgerState,
+            };
+            const signature = new SignatureErased();
+            const claimRewardsTransaction = new ClaimRewardsTransaction(signature.instance, newSimulatorState.networkId, amount, verifyingKey, LedgerOps.randomNonce(), signature);
+            const tx = Transaction.fromRewards(claimRewardsTransaction).eraseProofs();
+            const blockContext = yield* Simulator.nextBlockContext(nextNumber);
+            return yield* Simulator.apply(newSimulatorState, tx, new WellFormedStrictness(), blockContext);
+        }));
+    }
+    submitRegularTx(tx, blockFullness) {
+        return SubscriptionRef.modifyEffect(this.#stateRef, (simulatorState) => Effect.gen(function* () {
+            const nextNumber = DateOps.secondsToDate(simulatorState.lastTxNumber + 1n);
+            const context = yield* Simulator.nextBlockContext(nextNumber);
+            return yield* Simulator.apply(simulatorState, tx, new WellFormedStrictness(), context, blockFullness);
+        }));
+    }
+    fastForward(lastTxNumber) {
+        return SubscriptionRef.modify(this.#stateRef, (simulatorState) => {
+            return [
+                undefined,
+                {
+                    ...simulatorState,
+                    lastTxNumber,
+                    lastTx: undefined,
+                    lastTxResult: undefined,
+                },
+            ];
+        });
+    }
+}

package/dist/Submission.d.ts

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

package/dist/Submission.js

@@ -0,0 +1,57 @@
+import { Deferred, Effect, Encoding, Exit, pipe, Scope } from 'effect';
+import { NodeClient, PolkadotNodeClient, SubmissionEvent as SubmissionEventImported, } from '@midnight-ntwrk/wallet-sdk-node-client/effect';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+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.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/Sync.d.ts

@@ -0,0 +1,58 @@
+import { Effect, Layer, Schema, Scope, Stream } from 'effect';
+import { DustSecretKey, Event as LedgerEvent, LedgerParameters } from '@midnight-ntwrk/ledger-v6';
+import { SubscriptionClient, QueryClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { Simulator, SimulatorState } from './Simulator.js';
+import { DustCoreWallet } from './DustCoreWallet.js';
+import { NetworkId } from './types/ledger.js';
+export interface SyncService<TState, TStartAux, TUpdate> {
+    updates: (state: TState, auxData: TStartAux) => Stream.Stream<TUpdate, WalletError.WalletError, Scope.Scope>;
+    ledgerParameters: () => Effect.Effect<LedgerParameters, WalletError.WalletError>;
+}
+export interface SyncCapability<TState, TUpdate> {
+    applyUpdate: (state: TState, update: TUpdate) => TState;
+}
+export type IndexerClientConnection = {
+    indexerHttpUrl: string;
+    indexerWsUrl?: string;
+};
+export type DefaultSyncConfiguration = {
+    indexerClientConnection: IndexerClientConnection;
+    networkId: NetworkId;
+};
+export type SimulatorSyncConfiguration = {
+    simulator: Simulator;
+    networkId: NetworkId;
+};
+export type SimulatorSyncUpdate = {
+    update: SimulatorState;
+    secretKey: DustSecretKey;
+};
+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 = {
+    update: WalletSyncSubscription;
+    secretKeys: SecretKeysResource;
+};
+export declare const WalletSyncUpdate: {
+    create: (update: WalletSyncSubscription, secretKey: DustSecretKey) => WalletSyncUpdate;
+};
+export declare const makeDefaultSyncService: (config: DefaultSyncConfiguration) => SyncService<DustCoreWallet, DustSecretKey, WalletSyncUpdate>;
+export type IndexerSyncService = {
+    connectionLayer: () => Layer.Layer<SubscriptionClient, WalletError.WalletError, Scope.Scope>;
+    subscribeWallet: (state: DustCoreWallet) => Stream.Stream<WalletSyncSubscription, WalletError.WalletError, Scope.Scope | SubscriptionClient>;
+    queryClient: () => Layer.Layer<QueryClient, WalletError.WalletError, Scope.Scope>;
+};
+export declare const makeIndexerSyncService: (config: DefaultSyncConfiguration) => IndexerSyncService;
+export declare const makeDefaultSyncCapability: () => SyncCapability<DustCoreWallet, WalletSyncUpdate>;
+export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<DustCoreWallet, DustSecretKey, SimulatorSyncUpdate>;
+export declare const makeSimulatorSyncCapability: () => SyncCapability<DustCoreWallet, SimulatorSyncUpdate>;
+export {};

package/dist/Sync.js

@@ -0,0 +1,123 @@
+import { Effect, Either, Layer, ParseResult, pipe, Schema, Stream } from 'effect';
+import { Event as LedgerEvent, LedgerParameters } from '@midnight-ntwrk/ledger-v6';
+import { BlockHash, DustLedgerEvents } from '@midnight-ntwrk/wallet-sdk-indexer-client';
+import { WsSubscriptionClient, HttpQueryClient, ConnectionHelper, } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { DateOps, EitherOps, LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { WsURL } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
+import { WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { Uint8ArraySchema } from './Serialization.js';
+export const SecretKeysResource = {
+    create: (secretKey) => {
+        let sk = secretKey;
+        return (cb) => {
+            if (sk === null || sk === undefined) {
+                throw new Error('Secret key has been consumed');
+            }
+            const result = cb(sk);
+            sk = null;
+            return result;
+        };
+    },
+};
+const LedgerEventSchema = Schema.declare((input) => input instanceof LedgerEvent).annotations({
+    identifier: 'ledger.Event',
+});
+const LedgerEventFromUInt8Array = Schema.asSchema(Schema.transformOrFail(Uint8ArraySchema, LedgerEventSchema, {
+    encode: (e) => {
+        return Effect.try({
+            try: () => e.serialize(),
+            catch: (err) => {
+                return new ParseResult.Unexpected(err, 'Could not serialize Ledger Event');
+            },
+        });
+    },
+    decode: (bytes) => Effect.try({
+        try: () => LedgerEvent.deserialize(bytes),
+        catch: (err) => {
+            return new ParseResult.Unexpected(err, 'Could not deserialize Ledger Event');
+        },
+    }),
+}));
+const HexedEvent = pipe(Schema.Uint8ArrayFromHex, Schema.compose(LedgerEventFromUInt8Array));
+export const SyncEventsUpdateSchema = Schema.Struct({
+    id: Schema.Number,
+    raw: HexedEvent,
+    maxId: Schema.Number,
+});
+export const WalletSyncUpdate = {
+    create: (update, secretKey) => {
+        return {
+            update,
+            secretKeys: SecretKeysResource.create(secretKey),
+        };
+    },
+};
+export const makeDefaultSyncService = (config) => {
+    const indexerSyncService = makeIndexerSyncService(config);
+    return {
+        updates: (state, secretKey) => {
+            return pipe(indexerSyncService.subscribeWallet(state), Stream.map((data) => WalletSyncUpdate.create(data, secretKey)), Stream.provideSomeLayer(indexerSyncService.connectionLayer()));
+        },
+        ledgerParameters: () => {
+            return Effect.gen(function* () {
+                const query = yield* BlockHash;
+                const result = yield* query({ offset: null });
+                return result.block?.ledgerParameters;
+            }).pipe(Effect.provide(indexerSyncService.queryClient()), Effect.scoped, Effect.catchAll((err) => Effect.fail(WalletError.WalletError.other(`Encountered unexpected error: ${err.message}`))), Effect.flatMap((ledgerParameters) => {
+                if (ledgerParameters === undefined) {
+                    return Effect.fail(WalletError.WalletError.other('Unable to fetch ledger parameters'));
+                }
+                return LedgerOps.ledgerTry(() => LedgerParameters.deserialize(Buffer.from(ledgerParameters, 'hex')));
+            }));
+        },
+    };
+};
+export const makeIndexerSyncService = (config) => {
+    return {
+        queryClient() {
+            return pipe(HttpQueryClient.layer({ url: config.indexerClientConnection.indexerHttpUrl }), Layer.mapError((error) => WalletError.WalletError.other(error)));
+        },
+        connectionLayer() {
+            const { indexerClientConnection } = config;
+            return ConnectionHelper.createWebSocketUrl(indexerClientConnection.indexerHttpUrl, indexerClientConnection.indexerWsUrl).pipe(Either.flatMap((url) => WsURL.make(url)), Either.match({
+                onLeft: (error) => Layer.fail(error),
+                onRight: (url) => WsSubscriptionClient.layer({ url }),
+            }), Layer.mapError((e) => new WalletError.SyncWalletError({ message: 'Failed to to obtain correct indexer URLs', cause: e })));
+        },
+        subscribeWallet(state) {
+            const { appliedIndex } = state.progress;
+            return pipe(DustLedgerEvents.run({
+                id: Number(appliedIndex),
+            }), Stream.mapEffect((subscription) => pipe(Schema.decodeUnknownEither(SyncEventsUpdateSchema)(subscription.dustLedgerEvents), Either.mapLeft((err) => new WalletError.SyncWalletError(err)), EitherOps.toEffect)), Stream.mapError((error) => new WalletError.SyncWalletError(error)));
+        },
+    };
+};
+export const makeDefaultSyncCapability = () => {
+    return {
+        applyUpdate(state, wrappedUpdate) {
+            const { update, secretKeys } = wrappedUpdate;
+            const nextIndex = BigInt(update.id);
+            const highestRelevantWalletIndex = BigInt(update.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);
+            return secretKeys((keys) => state
+                .applyEvents(keys, events, new Date())
+                .updateProgress({ appliedIndex: nextIndex, highestRelevantWalletIndex, isConnected: true }));
+        },
+    };
+};
+export const makeSimulatorSyncService = (config) => {
+    return {
+        updates: (_state, secretKey) => config.simulator.state$.pipe(Stream.map((state) => ({ update: state, secretKey }))),
+        ledgerParameters: () => pipe(config.simulator.getLatestState(), Effect.map((state) => state.ledger.parameters)),
+    };
+};
+export const makeSimulatorSyncCapability = () => ({
+    applyUpdate: (state, update) => state
+        .applyEvents(update.secretKey, update.update.lastTxResult?.events || [], DateOps.secondsToDate(update.update.lastTxNumber))
+        .updateProgress({ appliedIndex: update.update.lastTxNumber }),
+});

package/dist/Transacting.d.ts

@@ -0,0 +1,50 @@
+import { Either } from 'effect';
+import { DustSecretKey, Signature, SignatureVerifyingKey, Utxo, FinalizedTransaction, ProofErasedTransaction, UnprovenTransaction, LedgerParameters } from '@midnight-ntwrk/ledger-v6';
+import { ProvingRecipe, 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 { 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>;
+    calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
+    addFeePayment(secretKey: TSecrets, state: TState, transaction: UnprovenTransaction, currentTime: Date, ttl: 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>;
+}
+export type DefaultTransactingConfiguration = {
+    networkId: NetworkId;
+    costParameters: TotalCostParameters;
+};
+export type DefaultTransactingContext = {
+    coinSelection: CoinSelection<DustToken>;
+    coinsAndBalancesCapability: CoinsAndBalancesCapability<DustCoreWallet>;
+    keysCapability: KeysCapability<DustCoreWallet>;
+};
+export declare const makeDefaultTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<DustSecretKey, DustCoreWallet, FinalizedTransaction>;
+export declare const makeSimulatorTransactingCapability: (config: DefaultTransactingConfiguration, getContext: () => DefaultTransactingContext) => TransactingCapability<DustSecretKey, DustCoreWallet, ProofErasedTransaction>;
+export declare class TransactingCapabilityImplementation<TTransaction extends AnyTransaction> implements TransactingCapability<DustSecretKey, DustCoreWallet, TTransaction> {
+    #private;
+    readonly networkId: string;
+    readonly costParams: TotalCostParameters;
+    readonly getCoinSelection: () => CoinSelection<DustToken>;
+    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>;
+    calculateFee(transaction: AnyTransaction, ledgerParams: LedgerParameters): bigint;
+    static feeImbalance(transaction: AnyTransaction, totalFee: bigint): bigint;
+    addFeePayment(secretKey: DustSecretKey, state: DustCoreWallet, transaction: UnprovenTransaction, currentTime: Date, ttl: 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>;
+}