@midnight-ntwrk/wallet-sdk-shielded 2.1.0 → 3.0.1

package/dist/v1/TransactionHistory.js

@@ -1,31 +1,98 @@
-import { CoreWallet } from './CoreWallet.js';
-export const makeDefaultTransactionHistoryCapability = () => {
+// 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 { TransactionHistoryStorage } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Duration, Array as EArray, Effect, Schedule, Schema } from 'effect';
+import { TransactionHistoryDetail } from '@midnight-ntwrk/wallet-sdk-indexer-client';
+import { HttpQueryClient } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
+import { TransactionHistoryError } from './WalletError.js';
+export const QualifiedShieldedCoinInfoSchema = Schema.Struct({
+    type: Schema.String,
+    nonce: Schema.String,
+    value: Schema.BigInt,
+    mtIndex: Schema.BigInt,
+});
+export const ShieldedSectionSchema = Schema.Struct({
+    receivedCoins: Schema.Array(QualifiedShieldedCoinInfoSchema),
+    spentCoins: Schema.Array(QualifiedShieldedCoinInfoSchema),
+});
+export const ShieldedTransactionHistoryEntrySchema = Schema.Struct({
+    hash: TransactionHistoryStorage.TransactionHashSchema,
+    protocolVersion: Schema.Number,
+    status: TransactionHistoryStorage.TransactionHistoryStatusSchema,
+    shielded: ShieldedSectionSchema,
+});
+const coinEquals = Schema.equivalence(QualifiedShieldedCoinInfoSchema);
+export const mergeShieldedSections = (existing, incoming) => ({
+    receivedCoins: EArray.unionWith(existing.receivedCoins, incoming.receivedCoins, coinEquals),
+    spentCoins: EArray.unionWith(existing.spentCoins, incoming.spentCoins, coinEquals),
+});
+const convertUpdateToStorageEntry = (changes, metadata, protocolVersion) => ({
+    hash: changes.source,
+    protocolVersion,
+    status: metadata.status,
+    shielded: {
+        receivedCoins: changes.receivedCoins.map(({ mt_index, ...rest }) => ({ ...rest, mtIndex: mt_index })),
+        spentCoins: changes.spentCoins.map(({ mt_index, ...rest }) => ({ ...rest, mtIndex: mt_index })),
+    },
+});
+const upsertShieldedEntry = (txHistoryStorage, entry) => Effect.tryPromise({
+    try: () => txHistoryStorage.upsert(entry),
+    catch: (e) => new TransactionHistoryError({ message: `Failed to upsert history entry for ${entry.hash}`, cause: e }),
+});
+export const makeDefaultTransactionHistoryService = (config, _getContext) => {
+    const txHistoryStorage = config.txHistoryStorage;
+    const queryClientLayer = HttpQueryClient.layer({ url: config.indexerClientConnection.indexerHttpUrl });
     return {
-        updateTxHistory: (state, newTxs) => {
-            return newTxs.reduce((acc, tx) => CoreWallet.addTransaction(acc, tx), state);
-        },
-        transactionHistory: (_state) => {
-            return [];
+        put: (changes, metadata, protocolVersion) => {
+            const entry = convertUpdateToStorageEntry(changes, metadata, protocolVersion);
+            return upsertShieldedEntry(txHistoryStorage, entry);
         },
+        getTransactionDetails: (hash) => Effect.gen(function* () {
+            const statusQuery = yield* TransactionHistoryDetail;
+            const result = yield* statusQuery({ transactionHash: hash });
+            const tx = result.transactions[0];
+            const rawStatus = tx.__typename === 'RegularTransaction' ? tx.transactionResult.status : undefined;
+            const status = rawStatus === 'FAILURE' || rawStatus === 'PARTIAL_SUCCESS' ? rawStatus : 'SUCCESS';
+            return {
+                hash: tx.hash,
+                timestamp: tx.block.timestamp,
+                status,
+            };
+        }).pipe(Effect.provide(queryClientLayer), Effect.scoped, Effect.retry(Schedule.exponential(Duration.seconds(1)).pipe(Schedule.compose(Schedule.recurs(3)))), Effect.mapError((cause) => new TransactionHistoryError({
+            message: `Failed to fetch transaction metadata for ${hash}`,
+            cause,
+        }))),
     };
 };
-export const makeSimulatorTransactionHistoryCapability = () => {
+export const makeSimulatorTransactionHistoryService = (config, _getContext) => {
+    const txHistoryStorage = config.txHistoryStorage;
     return {
-        updateTxHistory: (state, newTxs) => {
-            return CoreWallet.updateTxHistory(state, newTxs); // @TODO fix this cast
-        },
-        transactionHistory: (_state) => {
-            return [];
-        },
-    };
-};
-export const makeDiscardTransactionHistoryCapability = () => {
-    return {
-        updateTxHistory: (state) => {
-            return state;
-        },
-        transactionHistory: (_state) => {
-            return [];
+        put: (changes, metadata, protocolVersion) => {
+            const entry = convertUpdateToStorageEntry(changes, metadata, protocolVersion);
+            return upsertShieldedEntry(txHistoryStorage, {
+                ...entry,
+                timestamp: new Date(metadata.timestamp),
+            });
         },
+        getTransactionDetails: (hash) => Effect.tryPromise({
+            try: () => txHistoryStorage.get(hash),
+            catch: (e) => new TransactionHistoryError({ message: `Failed to get transaction details for ${hash}`, cause: e }),
+        }).pipe(Effect.flatMap((entry) => entry
+            ? Effect.succeed({
+                hash: entry.hash,
+                timestamp: entry.timestamp ? entry.timestamp.getTime() : Date.now(),
+                status: entry.status,
+            })
+            : Effect.fail(new TransactionHistoryError({ message: `No transaction found in storage for hash: ${hash}` })))),
     };
 };

package/dist/v1/TransactionImbalances.d.ts

@@ -1,8 +1,8 @@
-import { Imbalances, TransactionCostModel } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { Imbalances, type TransactionCostModel } from '@midnight-ntwrk/wallet-sdk-capabilities';
 export declare const ShieldedCostModel: TransactionCostModel;
 export type TransactionImbalances = Readonly<{
     guaranteed: Imbalances;
-    fallible: Imbalances;
+    fallible: ReadonlyMap<number, Imbalances>;
 }>;
 export declare const TransactionImbalances: {
     empty: () => TransactionImbalances;

package/dist/v1/TransactionImbalances.js

@@ -19,12 +19,12 @@ export const TransactionImbalances = new (class {
     empty = () => {
         return {
             guaranteed: Imbalances.empty(),
-            fallible: Imbalances.empty(),
+            fallible: new Map(),
         };
     };
     areBalanced = (imbalances) => {
-        const areFallibleAllZeroes = imbalances.fallible.entries().every(([, value]) => value === 0n);
         const areGuaranteedAllZeroes = imbalances.guaranteed.entries().every(([, value]) => value === 0n);
-        return areFallibleAllZeroes && areGuaranteedAllZeroes;
+        const areFallibleAllZeroes = Array.from(imbalances.fallible.values()).every((segmentImbalances) => segmentImbalances.entries().every(([, value]) => value === 0n));
+        return areGuaranteedAllZeroes && areFallibleAllZeroes;
     };
 })();

package/dist/v1/TransactionOps.d.ts

@@ -1,6 +1,6 @@
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { TransactionImbalances } from './TransactionImbalances.js';
-import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type TransactionImbalances } from './TransactionImbalances.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
 export type TransactionOps<Tx> = {
     getImbalances(tx: Tx): TransactionImbalances;
     id(tx: Tx): string;
@@ -12,6 +12,6 @@ export declare const TransactionOps: {
     shared: {
         getImbalances(tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction): TransactionImbalances;
         getGuaranteedImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;
-        getFallibleImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => Imbalances;
+        getFallibleImbalances: (tx: ledger.FinalizedTransaction | ledger.UnprovenTransaction | ledger.ProofErasedTransaction) => ReadonlyMap<number, Imbalances>;
     };
 };

package/dist/v1/TransactionOps.js

@@ -10,7 +10,6 @@
 // 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 { pipe } from 'effect';
 import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
 export const TransactionOps = new (class {
     default = {
@@ -41,11 +40,10 @@ export const TransactionOps = new (class {
         getImbalances(tx) {
             const guaranteedImbalances = TransactionOps.shared.getGuaranteedImbalances(tx);
             const fallibleImbalances = TransactionOps.shared.getFallibleImbalances(tx);
-            return pipe({
+            return {
                 guaranteed: guaranteedImbalances,
                 fallible: fallibleImbalances,
-                fees: 0n,
-            });
+            };
         },
         getGuaranteedImbalances: (tx) => {
             const rawGuaranteedImbalances = tx
@@ -53,24 +51,23 @@ export const TransactionOps = new (class {
                 .entries()
                 .filter(([token]) => token.tag === 'shielded')
                 .map(([token, value]) => {
-                return [token.raw.toString(), value];
+                return [token.raw, value];
             });
             return Imbalances.fromEntries(rawGuaranteedImbalances);
         },
         getFallibleImbalances: (tx) => {
-            try {
-                const rawFallibleImbalances = tx
-                    .imbalances(1)
+            const segments = Array.from(tx.fallibleOffer?.keys() ?? []);
+            const fallibleImbalances = segments.flatMap((segment) => {
+                const rawImbalances = tx
+                    .imbalances(segment)
                     .entries()
                     .filter(([token]) => token.tag === 'shielded')
                     .map(([token, value]) => {
-                    return [token.raw.toString(), value];
+                    return [token.raw, value];
                 });
-                return Imbalances.fromEntries(rawFallibleImbalances);
-            }
-            catch {
-                return Imbalances.empty();
-            }
+                return [[segment, Imbalances.fromEntries(rawImbalances)]];
+            });
+            return new Map(fallibleImbalances);
         },
     };
 })();

package/dist/v1/V1Builder.d.ts

@@ -4,18 +4,18 @@ import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { type Variant, type VariantBuilder } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
 import { type SerializationCapability } from './Serialization.js';
-import { type DefaultSyncContext, type DefaultSyncConfiguration, type SyncCapability, type SyncService, type WalletSyncUpdate } from './Sync.js';
+import { type DefaultSyncContext, type DefaultSyncConfiguration, type ChangesResult, type SyncCapability, type SyncService, type WalletSyncUpdate } from './Sync.js';
 import { type DefaultTransactingConfiguration, type DefaultTransactingContext, type TransactingCapability } from './Transacting.js';
 import { type WalletError } from './WalletError.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { type KeysCapability } from './Keys.js';
 import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { CoreWallet } from './CoreWallet.js';
-import { type TransactionHistoryCapability } from './TransactionHistory.js';
+import { type DefaultTransactionHistoryConfiguration, type TransactionHistoryService } from './TransactionHistory.js';
 export type BaseV1Configuration = {
     networkId: NetworkId.NetworkId;
 };
-export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultTransactingConfiguration;
+export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultTransactingConfiguration & DefaultTransactionHistoryConfiguration;
 declare const V1BuilderSymbol: {
     readonly typeId: unique symbol;
 };
@@ -24,7 +24,7 @@ export type V1Variant<TSerialized, TSyncUpdate, TTransaction, TAuxData> = Varian
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
     serialization: SerializationCapability<CoreWallet, null, TSerialized>;
-    transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
+    transactionHistory: TransactionHistoryService;
 };
 export type AnyV1Variant = V1Variant<any, any, any, any>;
 export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate, ledger.FinalizedTransaction, ledger.ZswapSecretKeys>;
@@ -39,7 +39,7 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
     withTransactionType<Transaction>(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, Transaction, TStartAux>;
     withDefaultTransactionType(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
     withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext & DefaultSyncContext, TSerialized, WalletSyncUpdate, TTransaction, ledger.ZswapSecretKeys>;
-    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate, TStartAux extends object>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TStartAux, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate, TStartAux extends object>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TStartAux, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate, ChangesResult>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withSerializationDefaults(): V1Builder<TConfig, TContext, string, TSyncUpdate, TTransaction, TStartAux>;
     withSerialization<TSerializationConfig, TSerializationContext extends Partial<RunningV1Variant.AnyContext>, TSerialized>(serializationCapability: (configuration: TSerializationConfig, getContext: () => TSerializationContext) => SerializationCapability<CoreWallet, null, TSerialized>): V1Builder<TConfig & TSerializationConfig, TContext & TSerializationContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withTransactingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
@@ -48,8 +48,8 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
     withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<CoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
-    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
-    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryCapability: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryCapability<CoreWallet, TTransaction>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultTransactionHistoryConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryService: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryService): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
     build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TSerialized, TSyncUpdate, TTransaction, TStartAux>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>;
@@ -58,7 +58,7 @@ export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Confi
 declare namespace V1Builder {
     type HasSync<TConfig, TContext, TSyncUpdate, TStartAux> = {
         readonly syncService: (configuration: TConfig, getContext: () => TContext) => SyncService<CoreWallet, TStartAux, TSyncUpdate>;
-        readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<CoreWallet, TSyncUpdate>;
+        readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<CoreWallet, TSyncUpdate, ChangesResult>;
     };
     type HasTransacting<TConfig, TContext, TTransaction> = {
         readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<ledger.ZswapSecretKeys, CoreWallet, TTransaction>;
@@ -72,22 +72,18 @@ declare namespace V1Builder {
     type HasCoinsAndBalances<TConfig, TContext> = {
         readonly coinsAndBalancesCapability: (configuration: TConfig, getContext: () => TContext) => CoinsAndBalancesCapability<CoreWallet>;
     };
-    type HasTransactionHistory<TConfig, TContext, TTransaction> = {
-        readonly transactionHistoryCapability: (configuration: TConfig, getContext: () => TContext) => TransactionHistoryCapability<CoreWallet, TTransaction>;
+    type HasTransactionHistory<TConfig, TContext> = {
+        readonly transactionHistoryService: (configuration: TConfig, getContext: () => TContext) => TransactionHistoryService;
     };
     type HasKeys<TConfig, TContext> = {
         readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<CoreWallet>;
     };
-    /**
-     * The internal build state of {@link V1Builder}.
-     */
-    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext, TTransaction>>;
+    /** The internal build state of {@link V1Builder}. */
+    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext>>;
     type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never, TTransaction = never, TStartAux = object> = {
         [K in keyof FullBuildState<never, never, never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>[K] | undefined;
     };
-    /**
-     * Utility interface that manages the type variance of {@link V1Builder}.
-     */
+    /** Utility interface that manages the type variance of {@link V1Builder}. */
     interface Variance<R> {
         readonly [V1BuilderSymbol.typeId]: {
             readonly _R: Types.Covariant<R>;

package/dist/v1/V1Builder.js

@@ -21,7 +21,7 @@ import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
 import { makeDefaultKeysCapability } from './Keys.js';
 import { chooseCoin } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { CoreWallet, PublicKeys } from './CoreWallet.js';
-import { makeDefaultTransactionHistoryCapability } from './TransactionHistory.js';
+import { makeDefaultTransactionHistoryService, } from './TransactionHistory.js';
 const V1BuilderSymbol = {
     typeId: Symbol('@midnight-ntwrk/wallet#V1Builder'),
 };
@@ -44,7 +44,7 @@ export class V1Builder {
         return new V1Builder({
             ...this.#buildState,
             transactingCapability: undefined,
-            transactionHistoryCapability: undefined,
+            transactionHistoryService: undefined,
         });
     }
     withDefaultTransactionType() {
@@ -97,12 +97,12 @@ export class V1Builder {
         });
     }
     withTransactionHistoryDefaults() {
-        return this.withTransactionHistory(makeDefaultTransactionHistoryCapability);
+        return this.withTransactionHistory(makeDefaultTransactionHistoryService);
     }
-    withTransactionHistory(transactionHistoryCapability) {
+    withTransactionHistory(transactionHistoryService) {
         return new V1Builder({
             ...this.#buildState,
-            transactionHistoryCapability,
+            transactionHistoryService,
         });
     }
     withKeysDefaults() {
@@ -122,7 +122,7 @@ export class V1Builder {
             coinsAndBalances: v1Context.coinsAndBalancesCapability,
             keys: v1Context.keysCapability,
             serialization: v1Context.serializationCapability,
-            transactionHistory: v1Context.transactionHistoryCapability,
+            transactionHistory: v1Context.transactionHistoryService,
             start(context) {
                 return Effect.gen(function* () {
                     const scope = yield* Scope.Scope;
@@ -142,7 +142,7 @@ export class V1Builder {
         if (!isBuildStateFull(this.#buildState)) {
             throw new Error('Not all components are configured in V1 Builder');
         }
-        const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryCapability, } = this.#buildState;
+        const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService, } = this.#buildState;
         const getContext = () => context;
         const context = {
             serializationCapability: serializationCapability(configuration, getContext),
@@ -152,7 +152,7 @@ export class V1Builder {
             coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
             keysCapability: keysCapability(configuration, getContext),
             coinSelection: coinSelection(configuration, getContext),
-            transactionHistoryCapability: transactionHistoryCapability(configuration, getContext),
+            transactionHistoryService: transactionHistoryService(configuration, getContext),
         };
         return context;
     }
@@ -166,7 +166,7 @@ const isBuildStateFull = (buildState) => {
         'serializationCapability',
         'coinsAndBalancesCapability',
         'keysCapability',
-        'transactionHistoryCapability',
+        'transactionHistoryService',
     ];
     return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');
 };

package/dist/v1/WalletError.d.ts

@@ -1,11 +1,11 @@
-import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 export declare const WalletError: {
     other(err: unknown): WalletError;
     submission(err: unknown): WalletError;
 };
 export type WalletError = OtherWalletError | InsufficientFundsError | SubmissionError | AddressError | SyncWalletError | InvalidCoinHashesError | TransactingError | LedgerOps.LedgerError;
-declare const OtherWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const OtherWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.Other";
 } & Readonly<A>;
 export declare class OtherWalletError extends OtherWalletError_base<{
@@ -13,7 +13,7 @@ export declare class OtherWalletError extends OtherWalletError_base<{
     cause?: unknown;
 }> {
 }
-declare const SyncWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const SyncWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.Sync";
 } & Readonly<A>;
 export declare class SyncWalletError extends SyncWalletError_base<{
@@ -21,7 +21,7 @@ export declare class SyncWalletError extends SyncWalletError_base<{
     cause?: unknown;
 }> {
 }
-declare const SubmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const SubmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.SubmissionWalletError";
 } & Readonly<A>;
 export declare class SubmissionError extends SubmissionError_base<{
@@ -29,7 +29,7 @@ export declare class SubmissionError extends SubmissionError_base<{
     cause?: unknown;
 }> {
 }
-declare const InsufficientFundsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const InsufficientFundsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.InsufficientFunds";
 } & Readonly<A>;
 export declare class InsufficientFundsError extends InsufficientFundsError_base<{
@@ -38,7 +38,7 @@ export declare class InsufficientFundsError extends InsufficientFundsError_base<
     amount: bigint;
 }> {
 }
-declare const AddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const AddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.Address";
 } & Readonly<A>;
 export declare class AddressError extends AddressError_base<{
@@ -47,7 +47,7 @@ export declare class AddressError extends AddressError_base<{
     cause?: unknown;
 }> {
 }
-declare const InvalidCoinHashesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const InvalidCoinHashesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.InvalidCoinHashes";
 } & Readonly<A>;
 export declare class InvalidCoinHashesError extends InvalidCoinHashesError_base<{
@@ -55,7 +55,7 @@ export declare class InvalidCoinHashesError extends InvalidCoinHashesError_base<
     missingNonces: Set<ledger.Nonce>;
 }> {
 }
-declare const TransactingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+declare const TransactingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
     readonly _tag: "Wallet.Transacting";
 } & Readonly<A>;
 export declare class TransactingError extends TransactingError_base<{
@@ -63,4 +63,12 @@ export declare class TransactingError extends TransactingError_base<{
     cause?: unknown;
 }> {
 }
+declare const TransactionHistoryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.TransactionHistory";
+} & Readonly<A>;
+export declare class TransactionHistoryError extends TransactionHistoryError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
 export {};

package/dist/v1/WalletError.js

@@ -49,3 +49,5 @@ export class InvalidCoinHashesError extends Data.TaggedError('Wallet.InvalidCoin
 }
 export class TransactingError extends Data.TaggedError('Wallet.Transacting') {
 }
+export class TransactionHistoryError extends Data.TaggedError('Wallet.TransactionHistory') {
+}

package/dist/v1/index.d.ts

@@ -6,7 +6,7 @@ export * as Serialization from './Serialization.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
-export * as Simulator from './Simulator.js';
+export * as Simulator from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
 export * from './TransactionOps.js';

package/dist/v1/index.js

@@ -18,7 +18,7 @@ export * as Serialization from './Serialization.js';
 export * as CoinsAndBalances from './CoinsAndBalances.js';
 export * as Keys from './Keys.js';
 export * from './RunningV1Variant.js';
-export * as Simulator from './Simulator.js';
+export * as Simulator from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
 export * as WalletError from './WalletError.js';
 export * from './CoreWallet.js';
 export * from './TransactionOps.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-shielded",
-  "version": "2.1.0",
+  "version": "3.0.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -28,13 +28,13 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v8": "^8.0.2",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "2.0.0",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.1.0",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.2.0",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.2.0",
-    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.2",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.1.0",
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "^2.1.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "^3.1.2",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "^3.3.1",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "^1.2.2",
+    "@midnight-ntwrk/wallet-sdk-runtime": "^1.0.4",
+    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.0",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },

package/dist/v1/Simulator.d.ts

@@ -1,22 +0,0 @@
-import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { Array as Arr, Effect, type 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>);
-    submitTransaction(tx: ledger.ProofErasedTransaction): Effect.Effect<{
-        blockNumber: bigint;
-        blockHash: string;
-    }>;
-}