@midnight-ntwrk/wallet-sdk-unshielded-wallet 2.1.0 → 3.1.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>;
@@ -45,6 +46,13 @@ export type UnshieldedWalletAPI<TSerialized = string> = {
     balanceUnboundTransaction(tx: UnboundTransaction): Promise<UnboundTransactionBalanceResult>;
     balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Promise<UnprovenTransactionBalanceResult>;
     transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    /**
+     * Books a caller-supplied set of Night UTxOs and returns an unproven transaction that moves them back to the same
+     * owner, split between the guaranteed (segment 0) and fallible (segment 1) sections of a single intent. Booking moves
+     * the UTxOs from available to pending so a concurrent build call cannot reuse them. The fallible section is available
+     * for callers that want to attach further actions (e.g. a Dust registration) at segment 1.
+     */
+    rotateUtxos(guaranteedUtxos: readonly UtxoWithMeta[], fallibleUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Promise<ledger.UnprovenTransaction>;
     initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
     signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
     signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;

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);
@@ -105,6 +106,13 @@ export function CustomUnshieldedWallet(configuration, builder) {
             })
                 .pipe(Effect.runPromise);
         }
+        rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
         initSwap(desiredInputs, desiredOutputs, ttl) {
             return this.runtime
                 .dispatch({ [V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl) })
@@ -135,8 +143,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

@@ -4,6 +4,7 @@ import { type SerializationCapability } from './Serialization.js';
 import { type SyncCapability, type SyncService } from './Sync.js';
 import { type WalletSyncUpdate } from './SyncSchema.js';
 import { type TransactingCapability, type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './Transacting.js';
+import { type UtxoWithMeta } from './UnshieldedState.js';
 import { type UnboundTransaction } from './TransactionOps.js';
 import { type WalletError } from './WalletError.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
@@ -21,7 +22,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>;
 }
@@ -38,6 +39,7 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate> implements Varia
     balanceUnboundTransaction(tx: UnboundTransaction): Effect.Effect<UnboundTransactionBalanceResult, WalletError>;
     balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Effect.Effect<UnprovenTransactionBalanceResult, WalletError>;
     transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    rotateUtxos(guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<UnboundTransaction, WalletError>;

package/dist/v1/RunningV1Variant.js

@@ -87,6 +87,11 @@ export class RunningV1Variant {
             return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
         });
     }
+    rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.rotateUtxos(state, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
     initSwap(desiredInputs, desiredOutputs, ttl) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
             return pipe(this.#v1Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), Effect.map(({ transaction, newState }) => [transaction, newState]));

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;