@midnight-ntwrk/wallet-sdk-unshielded-wallet 2.1.0 → 3.0.0

package/README.md

@@ -24,18 +24,17 @@ Unlike shielded transactions, unshielded operations do not use zero-knowledge pr
 ### Starting the Wallet
 
 ```typescript
-import {
-  UnshieldedWallet,
-  createKeystore,
-  PublicKey,
-  InMemoryTransactionHistoryStorage,
-} from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
+import { UnshieldedWallet, createKeystore, PublicKey } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
+import { InMemoryTransactionHistoryStorage, NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { randomBytes } from 'node:crypto';
 
 // Configuration for the wallet
 const configuration = {
-  networkId: 'testnet', // or 'mainnet', 'undeployed'
-  indexerUrl: 'ws://localhost:8088/api/v3/graphql/ws',
+  networkId: NetworkId.Undeployed, // or NetworkId.Testnet, NetworkId.Mainnet
+  indexerClientConnection: {
+    indexerWsUrl: 'ws://localhost:8088/api/v4/graphql/ws',
+    indexerHttpUrl: 'http://localhost:8088/api/v4/graphql',
+  },
   txHistoryStorage: new InMemoryTransactionHistoryStorage(),
 };
 

package/dist/KeyStore.d.ts

@@ -1,6 +1,6 @@
-import { MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
-import { Signature, SignatureVerifyingKey, UserAddress } from '@midnight-ntwrk/ledger-v8';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type Signature, type SignatureVerifyingKey, type UserAddress } from '@midnight-ntwrk/ledger-v8';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 export type PublicKey = {
     publicKey: SignatureVerifyingKey;
     addressHex: UserAddress;

package/dist/UnshieldedWallet.d.ts

@@ -12,27 +12,28 @@ import { type UtxoWithMeta } from './v1/UnshieldedState.js';
 import { type Variant, type VariantBuilder, type WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
 import { type PublicKey } from './KeyStore.js';
 import { type SyncProgress } from './v1/SyncProgress.js';
-import { type UnshieldedUpdate } from './v1/SyncSchema.js';
 import { type UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 export type UnshieldedWalletCapabilities<TSerialized = string> = {
     serialization: SerializationCapability<CoreWallet, TSerialized>;
     coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
     keys: KeysCapability<CoreWallet>;
-    transactionHistory: TransactionHistoryService<UnshieldedUpdate>;
+};
+export type UnshieldedWalletServices = {
+    transactionHistory: TransactionHistoryService;
 };
 export declare class UnshieldedWalletState<TSerialized = string> {
-    static readonly mapState: <TSerialized_1 = string>(capabilities: UnshieldedWalletCapabilities<TSerialized_1>) => (state: ProtocolState.ProtocolState<CoreWallet>) => UnshieldedWalletState<TSerialized_1>;
+    static readonly mapState: <TSerialized_1 = string>(variant: UnshieldedWalletCapabilities<TSerialized_1> & UnshieldedWalletServices) => (state: ProtocolState.ProtocolState<CoreWallet>) => UnshieldedWalletState<TSerialized_1>;
     readonly protocolVersion: ProtocolVersion.ProtocolVersion;
     readonly state: CoreWallet;
     readonly capabilities: UnshieldedWalletCapabilities<TSerialized>;
+    readonly services: UnshieldedWalletServices;
     get balances(): Record<ledger.RawTokenType, bigint>;
     get totalCoins(): readonly UtxoWithMeta[];
     get availableCoins(): readonly UtxoWithMeta[];
     get pendingCoins(): readonly UtxoWithMeta[];
     get address(): UnshieldedAddress;
     get progress(): SyncProgress;
-    get transactionHistory(): TransactionHistoryService<UnshieldedUpdate>;
-    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: UnshieldedWalletCapabilities<TSerialized>);
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: UnshieldedWalletCapabilities<TSerialized>, services: UnshieldedWalletServices);
     serialize(): TSerialized;
 }
 export type UnshieldedWallet = CustomizedUnshieldedWallet<WalletSyncUpdate, string>;

package/dist/UnshieldedWallet.js

@@ -16,12 +16,15 @@ import { Effect, Either } from 'effect';
 import * as rx from 'rxjs';
 import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
 export class UnshieldedWalletState {
-    static mapState = (capabilities) => (state) => {
-        return new UnshieldedWalletState(state, capabilities);
+    static mapState = (variant) => (state) => {
+        const { serialization, coinsAndBalances, keys } = variant;
+        const { transactionHistory } = variant;
+        return new UnshieldedWalletState(state, { serialization, coinsAndBalances, keys }, { transactionHistory });
     };
     protocolVersion;
     state;
     capabilities;
+    services;
     get balances() {
         return this.capabilities.coinsAndBalances.getAvailableBalances(this.state);
     }
@@ -40,13 +43,11 @@ export class UnshieldedWalletState {
     get progress() {
         return this.state.progress;
     }
-    get transactionHistory() {
-        return this.capabilities.transactionHistory;
-    }
-    constructor(state, capabilities) {
+    constructor(state, capabilities, services) {
         this.protocolVersion = state.version;
         this.state = state.state;
         this.capabilities = capabilities;
+        this.services = services;
     }
     serialize() {
         return this.capabilities.serialization.serialize(this.state);
@@ -135,8 +136,8 @@ export function CustomUnshieldedWallet(configuration, builder) {
             return rx.firstValueFrom(this.state.pipe(rx.filter((state) => state.state.progress.isCompleteWithin(allowedGap))));
         }
         /**
-         * Serializes the most recent state
-         * It's preferable to use [[UnshieldedWalletState.serialize]] instead, to know exactly, which state is serialized
+         * Serializes the most recent state It's preferable to use [[UnshieldedWalletState.serialize]] instead, to know
+         * exactly, which state is serialized
          */
         serializeState() {
             return rx.firstValueFrom(this.state).then((state) => state.serialize());

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * from './UnshieldedWallet.js';
-export * from './storage/index.js';
+export { type UnshieldedTransactionHistoryEntry, UnshieldedSectionSchema } from './v1/TransactionHistory.js';
 export * from './KeyStore.js';

package/dist/index.js

@@ -11,5 +11,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 export * from './UnshieldedWallet.js';
-export * from './storage/index.js';
+export { UnshieldedSectionSchema } from './v1/TransactionHistory.js';
 export * from './KeyStore.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -1,6 +1,6 @@
-import { CoreWallet } from './CoreWallet.js';
-import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { UtxoWithMeta } from './UnshieldedState.js';
+import { type CoreWallet } from './CoreWallet.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type UtxoWithMeta } from './UnshieldedState.js';
 export type Balances = Record<ledger.RawTokenType, bigint>;
 export type CoinsAndBalancesCapability<TState> = {
     getAvailableBalances(state: TState): Balances;

package/dist/v1/CoreWallet.d.ts

@@ -1,10 +1,10 @@
 import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
-import { SyncProgress, SyncProgressData } from './SyncProgress.js';
-import { PublicKey } from '../KeyStore.js';
-import { UnshieldedState, UnshieldedUpdate } from './UnshieldedState.js';
-import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type SyncProgress, type SyncProgressData } from './SyncProgress.js';
+import { type PublicKey } from '../KeyStore.js';
+import { UnshieldedState, type UnshieldedUpdate } from './UnshieldedState.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
 import { Either } from 'effect';
-import { WalletError } from './WalletError.js';
+import { type WalletError } from './WalletError.js';
 export type CoreWallet = Readonly<{
     state: UnshieldedState;
     publicKey: PublicKey;

package/dist/v1/Keys.d.ts

@@ -1,6 +1,6 @@
 import { UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import type { CoreWallet } from './CoreWallet.js';
-import { SignatureVerifyingKey } from '@midnight-ntwrk/ledger-v8';
+import { type SignatureVerifyingKey } from '@midnight-ntwrk/ledger-v8';
 export type KeysCapability<TState> = {
     getPublicKey(state: TState): SignatureVerifyingKey;
     getAddress(state: TState): UnshieldedAddress;

package/dist/v1/RunningV1Variant.d.ts

@@ -21,7 +21,7 @@ export declare namespace RunningV1Variant {
         coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
         keysCapability: KeysCapability<CoreWallet>;
         coinSelection: CoinSelection<ledger.Utxo>;
-        transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
+        transactionHistoryService: TransactionHistoryService;
     };
     type AnyContext = Context<any, any>;
 }

package/dist/v1/Serialization.d.ts

@@ -1,7 +1,7 @@
 import { Either } from 'effect';
-import { WalletError } from './WalletError.js';
+import { type WalletError } from './WalletError.js';
 import { CoreWallet } from './CoreWallet.js';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 export type SerializationCapability<TWallet, TSerialized> = {
     serialize(wallet: TWallet): TSerialized;
     deserialize(data: TSerialized): Either.Either<TWallet, WalletError>;

package/dist/v1/Sync.d.ts

@@ -1,9 +1,9 @@
-import { Scope, Stream, Either } from 'effect';
+import { type Scope, Stream, Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
-import { Simulator, SimulatorState } from './Simulator.js';
-import { WalletError } from './WalletError.js';
-import { TransactionHistoryService } from './TransactionHistory.js';
-import { WalletSyncUpdate } from './SyncSchema.js';
+import { type Simulator, type SimulatorState } from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
+import { type WalletError } from './WalletError.js';
+import { type TransactionHistoryService } from './TransactionHistory.js';
+import { type WalletSyncUpdate } from './SyncSchema.js';
 export interface SyncService<TState, TUpdate> {
     updates: (state: TState) => Stream.Stream<TUpdate, WalletError, Scope.Scope>;
 }
@@ -19,7 +19,7 @@ export type DefaultSyncConfiguration = {
     indexerClientConnection: IndexerClientConnection;
 };
 export type DefaultSyncContext = {
-    transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
+    transactionHistoryService: TransactionHistoryService;
 };
 export declare const makeDefaultSyncService: (config: DefaultSyncConfiguration) => SyncService<CoreWallet, WalletSyncUpdate>;
 export declare const makeDefaultSyncCapability: (_config: DefaultSyncConfiguration, getContext: () => DefaultSyncContext) => SyncCapability<CoreWallet, WalletSyncUpdate>;
@@ -30,4 +30,17 @@ export type SimulatorSyncUpdate = {
     update: SimulatorState;
 };
 export declare const makeSimulatorSyncService: (config: SimulatorSyncConfiguration) => SyncService<CoreWallet, SimulatorSyncUpdate>;
+/**
+ * Creates a sync capability that extracts UTXOs from the simulator's ledger state and applies them to the wallet.
+ *
+ * This capability:
+ *
+ * 1. Extracts all UTXOs for the wallet's address from the simulator ledger
+ * 2. Compares with the wallet's current UTXOs to determine created/spent
+ * 3. Applies the update to the wallet state
+ *
+ * Note: The `registeredForDustGeneration` flag is set based on whether the address appears in the ledger's dust
+ * delegation table. This is a heuristic that may not perfectly match the indexer's behavior but provides reasonable
+ * accuracy.
+ */
 export declare const makeSimulatorSyncCapability: () => SyncCapability<CoreWallet, SimulatorSyncUpdate>;

package/dist/v1/Sync.js

@@ -10,14 +10,17 @@
 // 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 { Stream, Schema, pipe, Either } from 'effect';
+import { Effect, Stream, Schema, pipe, Either, HashMap } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
+import { UtxoWithMeta } from './UnshieldedState.js';
+import { getCurrentBlockNumber, } from '@midnight-ntwrk/wallet-sdk-capabilities/simulation';
 import { UnshieldedTransactions } from '@midnight-ntwrk/wallet-sdk-indexer-client';
 import { WsSubscriptionClient, ConnectionHelper } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 import { SyncWalletError } from './WalletError.js';
 import { WsURL } from '@midnight-ntwrk/wallet-sdk-utilities/networking';
 import { EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { WalletSyncUpdateSchema } from './SyncSchema.js';
+import * as ledger from '@midnight-ntwrk/ledger-v8';
 export const makeDefaultSyncService = (config) => {
     return {
         updates: (state) => {
@@ -63,7 +66,7 @@ export const makeDefaultSyncCapability = (_config, getContext) => {
                         appliedId: BigInt(update.transaction.id),
                     });
                     const { transactionHistoryService } = getContext();
-                    void transactionHistoryService.create(update);
+                    Effect.runFork(transactionHistoryService.put(update));
                     return stateAfterUpdatingProgress;
                 }));
             }
@@ -72,14 +75,63 @@ export const makeDefaultSyncCapability = (_config, getContext) => {
 };
 export const makeSimulatorSyncService = (config) => {
     return {
-        updates: (_state) => config.simulator.state$.pipe(Stream.map((state) => ({ update: state }))),
+        updates: (_state) => {
+            // Get the initial state immediately to ensure we process existing blocks.
+            // Then subscribe to state$ for subsequent changes.
+            return pipe(Stream.fromEffect(config.simulator.getLatestState()), Stream.concat(config.simulator.state$), Stream.map((state) => ({ update: state })));
+        },
     };
 };
+/**
+ * Creates a sync capability that extracts UTXOs from the simulator's ledger state and applies them to the wallet.
+ *
+ * This capability:
+ *
+ * 1. Extracts all UTXOs for the wallet's address from the simulator ledger
+ * 2. Compares with the wallet's current UTXOs to determine created/spent
+ * 3. Applies the update to the wallet state
+ *
+ * Note: The `registeredForDustGeneration` flag is set based on whether the address appears in the ledger's dust
+ * delegation table. This is a heuristic that may not perfectly match the indexer's behavior but provides reasonable
+ * accuracy.
+ */
 export const makeSimulatorSyncCapability = () => {
+    const utxoKey = (utxo) => `${utxo.intentHash}#${utxo.outputNo}`;
     return {
-        applyUpdate: (state, _update) => {
-            return Either.right(state);
-            // return CoreWallet.replayEvents(state, secretKeys, events);
+        applyUpdate: (state, update) => {
+            const { ledger: ledgerState, currentTime } = update.update;
+            const walletAddress = state.publicKey.addressHex;
+            const nativeTokenType = ledger.nativeToken().raw;
+            // Heuristic: check if address appears in the ledger's dust delegation table
+            const isAddressRegisteredForDust = ledgerState.dust.toString().includes(walletAddress);
+            // Build a Map of simulator UTXOs keyed by intent hash + output number
+            const simulatorUtxoMap = new Map(Array.from(ledgerState.utxo.filter(walletAddress)).map((utxo) => [
+                utxoKey(utxo),
+                new UtxoWithMeta({
+                    utxo,
+                    meta: {
+                        ctime: currentTime,
+                        registeredForDustGeneration: utxo.type === nativeTokenType && isAddressRegisteredForDust,
+                    },
+                }),
+            ]));
+            // Created: in simulator but not in wallet (neither available nor pending)
+            const createdUtxos = Array.from(simulatorUtxoMap)
+                .filter(([hash]) => !HashMap.has(state.state.availableUtxos, hash) && !HashMap.has(state.state.pendingUtxos, hash))
+                .map(([, utxo]) => utxo);
+            // Spent: in wallet (pending or available) but no longer in simulator
+            const spentUtxos = [
+                ...Array.from(HashMap.entries(state.state.pendingUtxos)),
+                ...Array.from(HashMap.entries(state.state.availableUtxos)),
+            ]
+                .filter(([hash]) => !simulatorUtxoMap.has(hash))
+                .map(([, utxo]) => utxo);
+            const blockNumber = getCurrentBlockNumber(update.update);
+            const updateProgress = (wallet) => CoreWallet.updateProgress(wallet, { appliedId: blockNumber, isConnected: true });
+            if (createdUtxos.length === 0 && spentUtxos.length === 0) {
+                return Either.right(updateProgress(state));
+            }
+            return pipe(CoreWallet.applyUpdate(state, { createdUtxos, spentUtxos, status: 'SUCCESS' }), Either.map(updateProgress));
         },
     };
 };

package/dist/v1/SyncSchema.d.ts

@@ -160,32 +160,19 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
         };
     }[];
     readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
-    readonly createdUtxos: readonly {
-        readonly utxo: {
-            readonly type: string;
-            readonly value: bigint;
-            readonly owner: string;
-            readonly intentHash: string;
-            readonly outputNo: number;
-        };
-        readonly meta: {
-            readonly ctime: Date;
-            readonly registeredForDustGeneration: boolean;
-        };
-    }[];
     readonly transaction: {
         readonly type: "RegularTransaction" | "SystemTransaction";
         readonly protocolVersion: number;
         readonly id: number;
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
         readonly fees?: {
             readonly paidFees: bigint;
             readonly estimatedFees: bigint;
         } | undefined;
-        readonly block: {
-            readonly timestamp: Date;
-        };
         readonly transactionResult?: {
             readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
             readonly segments: readonly {
@@ -194,9 +181,7 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
             }[] | null;
         } | undefined;
     };
-}, {
-    readonly type: "UnshieldedTransaction";
-    readonly spentUtxos: readonly {
+    readonly createdUtxos: readonly {
         readonly utxo: {
             readonly type: string;
             readonly value: bigint;
@@ -209,8 +194,9 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
             readonly registeredForDustGeneration: boolean;
         };
     }[];
-    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
-    readonly createdUtxos: readonly {
+}, {
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
         readonly utxo: {
             readonly type: string;
             readonly value: bigint;
@@ -223,19 +209,20 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
             readonly registeredForDustGeneration: boolean;
         };
     }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
     readonly transaction: {
         readonly type: "RegularTransaction" | "SystemTransaction";
         readonly protocolVersion: number;
         readonly id: number;
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
         readonly fees?: {
             readonly paidFees: bigint;
             readonly estimatedFees: bigint;
         } | undefined;
-        readonly block: {
-            readonly timestamp: Date;
-        };
         readonly transactionResult?: {
             readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
             readonly segments: readonly {
@@ -244,6 +231,19 @@ export declare const UnshieldedUpdateSchema: Schema.transform<Schema.Struct<{
             }[] | null;
         } | undefined;
     };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
 }, never>>;
 export type UnshieldedUpdate = Schema.Schema.Type<typeof UnshieldedUpdateSchema>;
 export declare const ProgressSchema: Schema.Struct<{
@@ -355,32 +355,19 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
         };
     }[];
     readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
-    readonly createdUtxos: readonly {
-        readonly utxo: {
-            readonly type: string;
-            readonly value: bigint;
-            readonly owner: string;
-            readonly intentHash: string;
-            readonly outputNo: number;
-        };
-        readonly meta: {
-            readonly ctime: Date;
-            readonly registeredForDustGeneration: boolean;
-        };
-    }[];
     readonly transaction: {
         readonly type: "RegularTransaction" | "SystemTransaction";
         readonly protocolVersion: number;
         readonly id: number;
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
         readonly fees?: {
             readonly paidFees: bigint;
             readonly estimatedFees: bigint;
         } | undefined;
-        readonly block: {
-            readonly timestamp: Date;
-        };
         readonly transactionResult?: {
             readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
             readonly segments: readonly {
@@ -389,9 +376,7 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
             }[] | null;
         } | undefined;
     };
-}, {
-    readonly type: "UnshieldedTransaction";
-    readonly spentUtxos: readonly {
+    readonly createdUtxos: readonly {
         readonly utxo: {
             readonly type: string;
             readonly value: bigint;
@@ -404,8 +389,9 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
             readonly registeredForDustGeneration: boolean;
         };
     }[];
-    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
-    readonly createdUtxos: readonly {
+}, {
+    readonly type: "UnshieldedTransaction";
+    readonly spentUtxos: readonly {
         readonly utxo: {
             readonly type: string;
             readonly value: bigint;
@@ -418,19 +404,20 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
             readonly registeredForDustGeneration: boolean;
         };
     }[];
+    readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
     readonly transaction: {
         readonly type: "RegularTransaction" | "SystemTransaction";
         readonly protocolVersion: number;
         readonly id: number;
         readonly hash: string;
         readonly identifiers?: readonly string[] | undefined;
+        readonly block: {
+            readonly timestamp: Date;
+        };
         readonly fees?: {
             readonly paidFees: bigint;
             readonly estimatedFees: bigint;
         } | undefined;
-        readonly block: {
-            readonly timestamp: Date;
-        };
         readonly transactionResult?: {
             readonly status: "SUCCESS" | "FAILURE" | "PARTIAL_SUCCESS";
             readonly segments: readonly {
@@ -439,6 +426,19 @@ export declare const WalletSyncUpdateSchema: Schema.Union<[Schema.transform<Sche
             }[] | null;
         } | undefined;
     };
+    readonly createdUtxos: readonly {
+        readonly utxo: {
+            readonly type: string;
+            readonly value: bigint;
+            readonly owner: string;
+            readonly intentHash: string;
+            readonly outputNo: number;
+        };
+        readonly meta: {
+            readonly ctime: Date;
+            readonly registeredForDustGeneration: boolean;
+        };
+    }[];
 }, never>>, Schema.Struct<{
     type: Schema.Literal<["UnshieldedTransactionsProgress"]>;
     highestTransactionId: typeof Schema.Number;

package/dist/v1/Transacting.d.ts

@@ -1,13 +1,13 @@
 import * as ledger from '@midnight-ntwrk/ledger-v8';
-import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
-import { WalletError } from './WalletError.js';
-import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
-import { TransactionOps, UnboundTransaction } from './TransactionOps.js';
-import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
-import { KeysCapability } from './Keys.js';
-import { UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { type WalletError } from './WalletError.js';
+import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { TransactionOps, type UnboundTransaction } from './TransactionOps.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 export interface TokenTransfer {
     readonly amount: bigint;
     readonly type: ledger.RawTokenType;
@@ -48,32 +48,34 @@ export declare class TransactingCapabilityImplementation implements TransactingC
     readonly getKeys: () => KeysCapability<CoreWallet>;
     constructor(networkId: NetworkId.NetworkId, getCoinSelection: () => CoinSelection<ledger.Utxo>, getCoins: () => CoinsAndBalancesCapability<CoreWallet>, getKeys: () => KeysCapability<CoreWallet>, txOps: TransactionOps);
     /**
-     * Balances an unbound transaction
-     * Note: Unbound transactions are balanced in place and returned
+     * Balances an unbound transaction Note: Unbound transactions are balanced in place and returned
+     *
      * @param wallet - The wallet to balance the transaction with
      * @param transaction - The transaction to balance
      * @returns The balanced transaction and the new wallet state if successful, otherwise an error
      */
     balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
     /**
-     * Balances an unproven transaction
-     * Note: This method does the same thing as balanceUnboundTransaction but is provided for convenience and type safety
+     * Balances an unproven transaction Note: This method does the same thing as balanceUnboundTransaction but is provided
+     * for convenience and type safety
+     *
      * @param wallet - The wallet to balance the transaction with
      * @param transaction - The transaction to balance
      * @returns The balanced transaction and the new wallet state if successful, otherwise an error
      */
     balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
     /**
-     * Balances a bound transaction
-     * Note: In bound transactions we can only balance the guaranteed section in intents
+     * Balances a bound transaction Note: In bound transactions we can only balance the guaranteed section in intents
+     *
      * @param wallet - The wallet to balance the transaction with
      * @param transaction - The transaction to balance
-     * @returns A balancing counterpart transaction (which should be merged with the original transaction )
-     * and the new wallet state if successful, otherwise an error
+     * @returns A balancing counterpart transaction (which should be merged with the original transaction ) and the new
+     *   wallet state if successful, otherwise an error
      */
     balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
     /**
      * Makes a transfer transaction
+     *
      * @param wallet - The wallet to make the transfer with
      * @param outputs - The outputs for the transfer
      * @param ttl - The TTL for the transaction
@@ -82,6 +84,7 @@ export declare class TransactingCapabilityImplementation implements TransactingC
     makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
     /**
      * Initializes a swap transaction
+     *
      * @param wallet - The wallet to initialize the swap for
      * @param desiredInputs - The desired inputs for the swap
      * @param desiredOutputs - The desired outputs for the swap
@@ -93,8 +96,10 @@ export declare class TransactingCapabilityImplementation implements TransactingC
     signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Either.Either<UnboundTransaction, WalletError>;
     /**
      * Reverts a transaction by rolling back all inputs owned by this wallet
+     *
      * @param wallet - The wallet to revert the transaction for
-     * @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or UnprovenTransaction)
+     * @param transaction - The transaction to revert (can be FinalizedTransaction, UnboundTransaction, or
+     *   UnprovenTransaction)
      * @returns The updated wallet with rolled back UTXOs if successful, otherwise an error
      */
     revertTransaction(wallet: CoreWallet, transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Either.Either<CoreWallet, WalletError>;