@midnight-ntwrk/wallet-sdk-unshielded-wallet 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/KeyStore.d.ts

@@ -1,9 +1,10 @@
-import { UnshieldedAddress, MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { MidnightBech32m } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { Signature, SignatureVerifyingKey, UserAddress } from '@midnight-ntwrk/ledger-v6';
 import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 export type PublicKey = {
     publicKey: SignatureVerifyingKey;
-    address: UnshieldedAddress;
+    addressHex: UserAddress;
+    address: string;
 };
 export declare const PublicKey: {
     fromKeyStore: (keystore: UnshieldedKeystore) => PublicKey;
@@ -15,9 +16,4 @@ export interface UnshieldedKeystore {
     getAddress(): UserAddress;
     signData(data: Uint8Array): Signature;
 }
-export interface Keystore {
-    keystore: UnshieldedKeystore;
-    getBech32Address(): MidnightBech32m;
-    getPublicKey(): SignatureVerifyingKey;
-}
 export declare const createKeystore: (secretKey: Uint8Array<ArrayBufferLike>, networkId: NetworkId.NetworkId) => UnshieldedKeystore;

package/dist/KeyStore.js

@@ -12,12 +12,12 @@
 // limitations under the License.
 import { UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
 import { addressFromKey, signData, signatureVerifyingKey, } from '@midnight-ntwrk/ledger-v6';
-import { pipe } from 'effect';
 export const PublicKey = {
     fromKeyStore: (keystore) => {
         return {
             publicKey: keystore.getPublicKey(),
-            address: pipe(keystore.getAddress(), (str) => Buffer.from(str, 'hex'), (bytes) => new UnshieldedAddress(bytes)),
+            addressHex: keystore.getAddress(),
+            address: keystore.getBech32Address().asString(),
         };
     },
 };

package/dist/UnshieldedWallet.d.ts

@@ -0,0 +1,57 @@
+import { ProtocolState, ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { BaseV1Configuration, DefaultV1Configuration, V1Variant, CoreWallet } from './v1/index.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import * as rx from 'rxjs';
+import { SerializationCapability } from './v1/Serialization.js';
+import { TransactionHistoryService } from './v1/TransactionHistory.js';
+import { CoinsAndBalancesCapability } from './v1/CoinsAndBalances.js';
+import { KeysCapability } from './v1/Keys.js';
+import { TokenTransfer } from './v1/Transacting.js';
+import { WalletSyncUpdate } from './v1/SyncSchema.js';
+import { UtxoWithMeta } from './v1/UnshieldedState.js';
+import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { PublicKey } from './KeyStore.js';
+import { SyncProgress } from './v1/SyncProgress.js';
+import { UnshieldedUpdate } from './v1/SyncSchema.js';
+import { 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 declare class UnshieldedWalletState<TSerialized = string> {
+    static readonly mapState: <TSerialized_1 = string>(capabilities: UnshieldedWalletCapabilities<TSerialized_1>) => (state: ProtocolState.ProtocolState<CoreWallet>) => UnshieldedWalletState<TSerialized_1>;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly state: CoreWallet;
+    readonly capabilities: UnshieldedWalletCapabilities<TSerialized>;
+    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>);
+    serialize(): TSerialized;
+}
+export type UnshieldedWallet = CustomizedUnshieldedWallet<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export interface CustomizedUnshieldedWallet<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+    readonly state: rx.Observable<UnshieldedWalletState<TSerialized>>;
+    start(): Promise<void>;
+    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Promise<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+    transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    serializeState(): Promise<TSerialized>;
+    waitForSyncedState(allowedGap?: bigint): Promise<UnshieldedWalletState<TSerialized>>;
+    getAddress(): Promise<UnshieldedAddress>;
+}
+export interface CustomizedUnshieldedWalletClass<TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction>>]> {
+    configuration: TConfig;
+    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TTransaction, TSyncUpdate, TSerialized>;
+}
+export declare function UnshieldedWallet(configuration: DefaultV1Configuration): UnshieldedWalletClass;
+export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction>, TConfig>): CustomizedUnshieldedWalletClass<TTransaction, TSyncUpdate, TSerialized, TConfig>;

package/dist/UnshieldedWallet.js

@@ -0,0 +1,120 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { V1Builder, V1Tag, CoreWallet } from './v1/index.js';
+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);
+    };
+    protocolVersion;
+    state;
+    capabilities;
+    get balances() {
+        return this.capabilities.coinsAndBalances.getAvailableBalances(this.state);
+    }
+    get totalCoins() {
+        return this.capabilities.coinsAndBalances.getTotalCoins(this.state);
+    }
+    get availableCoins() {
+        return this.capabilities.coinsAndBalances.getAvailableCoins(this.state);
+    }
+    get pendingCoins() {
+        return this.capabilities.coinsAndBalances.getPendingCoins(this.state);
+    }
+    get address() {
+        return this.capabilities.keys.getAddress(this.state);
+    }
+    get progress() {
+        return this.state.progress;
+    }
+    get transactionHistory() {
+        return this.capabilities.transactionHistory;
+    }
+    constructor(state, capabilities) {
+        this.protocolVersion = state.version;
+        this.state = state.state;
+        this.capabilities = capabilities;
+    }
+    serialize() {
+        return this.capabilities.serialization.serialize(this.state);
+    }
+}
+export function UnshieldedWallet(configuration) {
+    return CustomUnshieldedWallet(configuration, new V1Builder().withDefaults());
+}
+export function CustomUnshieldedWallet(configuration, builder) {
+    const buildArgs = [configuration];
+    const BaseWallet = WalletBuilder.init()
+        .withVariant(ProtocolVersion.MinSupportedVersion, builder)
+        .build(...buildArgs);
+    return class CustomUnshieldedWalletImplementation extends BaseWallet {
+        static startWithPublicKey(publicKeys) {
+            return CustomUnshieldedWalletImplementation.startFirst(CustomUnshieldedWalletImplementation, CoreWallet.init(publicKeys, configuration.networkId));
+        }
+        static restore(serializedState) {
+            const deserialized = CustomUnshieldedWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
+                .pipe(Either.getOrThrow);
+            return CustomUnshieldedWalletImplementation.startFirst(CustomUnshieldedWalletImplementation, deserialized);
+        }
+        state;
+        constructor(runtime, scope) {
+            super(runtime, scope);
+            this.state = this.rawState.pipe(rx.map(UnshieldedWalletState.mapState(CustomUnshieldedWalletImplementation.allVariantsRecord()[V1Tag].variant)), rx.shareReplay({ refCount: true, bufferSize: 1 }));
+        }
+        start() {
+            return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground() }).pipe(Effect.runPromise);
+        }
+        balanceTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        transferTransaction(outputs, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.transferTransaction(outputs, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
+        initSwap(desiredInputs, desiredOutputs, ttl) {
+            return this.runtime
+                .dispatch({ [V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl) })
+                .pipe(Effect.runPromise);
+        }
+        signTransaction(transaction, signSegment) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.signTransaction(transaction, signSegment),
+            })
+                .pipe(Effect.runPromise);
+        }
+        waitForSyncedState(allowedGap = 0n) {
+            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
+         */
+        serializeState() {
+            return rx.firstValueFrom(this.state).then((state) => state.serialize());
+        }
+        getAddress() {
+            return rx.firstValueFrom(this.state).then((state) => state.address);
+        }
+    };
+}

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export * from './WalletBuilder.js';
-export { State as UnshieldedWalletState } from './State.js';
-export { PublicKey, createKeystore, UnshieldedKeystore, Keystore } from './KeyStore.js';
+export * from './UnshieldedWallet.js';
+export * from './storage/index.js';
+export * from './KeyStore.js';

package/dist/index.js

@@ -10,5 +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.
-export * from './WalletBuilder.js';
-export { PublicKey, createKeystore } from './KeyStore.js';
+export * from './UnshieldedWallet.js';
+export * from './storage/index.js';
+export * from './KeyStore.js';

package/dist/{tx-history-storage → storage}/InMemoryTransactionHistoryStorage.d.ts

@@ -5,13 +5,9 @@ declare const TransactionHistorySchema: Schema.Map$<typeof Schema.String, Schema
     hash: typeof Schema.String;
     protocolVersion: typeof Schema.Number;
     identifiers: Schema.Array$<typeof Schema.String>;
-    transactionResult: Schema.NullOr<Schema.Struct<{
-        status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
-        segments: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            success: typeof Schema.Boolean;
-        }>>;
-    }>>;
+    timestamp: typeof Schema.Date;
+    fees: Schema.NullOr<typeof Schema.BigInt>;
+    status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
 }>>;
 export type TransactionHistory = Schema.Schema.Type<typeof TransactionHistorySchema>;
 /**

package/dist/{tx-history-storage → storage}/TransactionHistoryStorage.d.ts

@@ -6,13 +6,9 @@ export declare const TransactionHistoryEntrySchema: Schema.Struct<{
     hash: typeof Schema.String;
     protocolVersion: typeof Schema.Number;
     identifiers: Schema.Array$<typeof Schema.String>;
-    transactionResult: Schema.NullOr<Schema.Struct<{
-        status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
-        segments: Schema.Array$<Schema.Struct<{
-            id: typeof Schema.String;
-            success: typeof Schema.Boolean;
-        }>>;
-    }>>;
+    timestamp: typeof Schema.Date;
+    fees: Schema.NullOr<typeof Schema.BigInt>;
+    status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
 }>;
 export type TransactionHistoryEntry = Schema.Schema.Type<typeof TransactionHistoryEntrySchema>;
 export interface TransactionHistoryStorage {

package/dist/{tx-history-storage → storage}/TransactionHistoryStorage.js

@@ -17,11 +17,7 @@ export const TransactionHistoryEntrySchema = Schema.Struct({
     hash: TransactionHashSchema,
     protocolVersion: Schema.Number,
     identifiers: Schema.Array(Schema.String),
-    transactionResult: Schema.NullOr(Schema.Struct({
-        status: Schema.Literal('SUCCESS', 'FAILURE', 'PARTIAL_SUCCESS'),
-        segments: Schema.Array(Schema.Struct({
-            id: Schema.String,
-            success: Schema.Boolean,
-        })),
-    })),
+    timestamp: Schema.Date,
+    fees: Schema.NullOr(Schema.BigInt),
+    status: Schema.Literal('SUCCESS', 'FAILURE', 'PARTIAL_SUCCESS'),
 });

package/dist/{tx-history-storage → storage}/index.d.ts

@@ -1,2 +1,3 @@
 export * from './InMemoryTransactionHistoryStorage.js';
+export * from './NoOpTransactionHistoryStorage.js';
 export * from './TransactionHistoryStorage.js';

package/dist/{tx-history-storage → storage}/index.js

@@ -11,4 +11,5 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 export * from './InMemoryTransactionHistoryStorage.js';
+export * from './NoOpTransactionHistoryStorage.js';
 export * from './TransactionHistoryStorage.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -0,0 +1,13 @@
+import { CoreWallet } from './CoreWallet.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { UtxoWithMeta } from './UnshieldedState.js';
+export type Balances = Record<ledger.RawTokenType, bigint>;
+export type CoinsAndBalancesCapability<TState> = {
+    getAvailableBalances(state: TState): Balances;
+    getPendingBalances(state: TState): Balances;
+    getTotalBalances(state: TState): Balances;
+    getAvailableCoins(state: TState): readonly UtxoWithMeta[];
+    getPendingCoins(state: TState): readonly UtxoWithMeta[];
+    getTotalCoins(state: TState): ReadonlyArray<UtxoWithMeta>;
+};
+export declare const makeDefaultCoinsAndBalancesCapability: () => CoinsAndBalancesCapability<CoreWallet>;

package/dist/v1/CoinsAndBalances.js

@@ -0,0 +1,36 @@
+import { pipe } from 'effect';
+import { RecordOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { UnshieldedState } from './UnshieldedState.js';
+const calculateBalances = (utxos) => utxos.reduce((acc, { utxo }) => ({
+    ...acc,
+    [utxo.type]: acc[utxo.type] === undefined ? utxo.value : acc[utxo.type] + utxo.value,
+}), {});
+export const makeDefaultCoinsAndBalancesCapability = () => {
+    const getAvailableBalances = (state) => {
+        const availableCoins = getAvailableCoins(state);
+        return calculateBalances(availableCoins);
+    };
+    const getPendingBalances = (state) => {
+        const pendingCoins = getPendingCoins(state);
+        return calculateBalances(pendingCoins);
+    };
+    const getTotalBalances = (state) => {
+        const availableBalances = getAvailableBalances(state);
+        const pendingBalances = getPendingBalances(state);
+        return pipe([availableBalances, pendingBalances], RecordOps.mergeWithAccumulator(0n, (a, b) => a + b));
+    };
+    const getAvailableCoins = (state) => UnshieldedState.toArrays(state.state).availableUtxos;
+    const getPendingCoins = (state) => UnshieldedState.toArrays(state.state).pendingUtxos;
+    const getTotalCoins = (state) => [
+        ...getAvailableCoins(state),
+        ...getPendingCoins(state),
+    ];
+    return {
+        getAvailableBalances,
+        getPendingBalances,
+        getTotalBalances,
+        getAvailableCoins,
+        getPendingCoins,
+        getTotalCoins,
+    };
+};

package/dist/v1/CoreWallet.d.ts

@@ -0,0 +1,24 @@
+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-v6';
+import { Either } from 'effect';
+import { WalletError } from './WalletError.js';
+export type CoreWallet = Readonly<{
+    state: UnshieldedState;
+    publicKey: PublicKey;
+    protocolVersion: ProtocolVersion.ProtocolVersion;
+    progress: SyncProgress;
+    networkId: string;
+}>;
+export declare const CoreWallet: {
+    init(publicKey: PublicKey, networkId: string): CoreWallet;
+    restore(state: UnshieldedState, publicKey: PublicKey, syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: ProtocolVersion.ProtocolVersion, networkId: string): CoreWallet;
+    updateProgress(wallet: CoreWallet, { appliedId, highestTransactionId, isConnected }: Partial<SyncProgressData>): CoreWallet;
+    applyUpdate(coreWallet: CoreWallet, update: UnshieldedUpdate): Either.Either<CoreWallet, WalletError>;
+    applyFailedUpdate(coreWallet: CoreWallet, update: UnshieldedUpdate): Either.Either<CoreWallet, WalletError>;
+    rollbackUtxo(coreWallet: CoreWallet, utxo: ledger.Utxo): Either.Either<CoreWallet, WalletError>;
+    spend(coreWallet: CoreWallet, utxo: ledger.Utxo): Either.Either<CoreWallet, WalletError>;
+    spendUtxos(wallet: CoreWallet, utxos: ReadonlyArray<ledger.Utxo>): Either.Either<[ReadonlyArray<ledger.Utxo>, CoreWallet], WalletError>;
+};

package/dist/v1/CoreWallet.js

@@ -0,0 +1,60 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { createSyncProgress } from './SyncProgress.js';
+import { UnshieldedState } from './UnshieldedState.js';
+import { Either, Array as Arr, pipe } from 'effect';
+import { ApplyTransactionError, RollbackUtxoError, SpendUtxoError } from './WalletError.js';
+export const CoreWallet = {
+    init(publicKey, networkId) {
+        return {
+            state: UnshieldedState.empty(),
+            publicKey,
+            protocolVersion: ProtocolVersion.MinSupportedVersion,
+            progress: createSyncProgress(),
+            networkId,
+        };
+    },
+    restore(state, publicKey, syncProgress, protocolVersion, networkId) {
+        return {
+            state,
+            publicKey,
+            protocolVersion,
+            progress: createSyncProgress(syncProgress),
+            networkId,
+        };
+    },
+    updateProgress(wallet, { appliedId, highestTransactionId, isConnected }) {
+        const progress = createSyncProgress({
+            appliedId: appliedId ?? wallet.progress.appliedId,
+            highestTransactionId: highestTransactionId ?? wallet.progress.highestTransactionId,
+            isConnected: isConnected ?? wallet.progress.isConnected,
+        });
+        return { ...wallet, progress };
+    },
+    applyUpdate(coreWallet, update) {
+        return UnshieldedState.applyUpdate(coreWallet.state, update).pipe(Either.map((state) => ({ ...coreWallet, state })), Either.mapLeft((error) => new ApplyTransactionError(error)));
+    },
+    applyFailedUpdate(coreWallet, update) {
+        return UnshieldedState.applyFailedUpdate(coreWallet.state, update).pipe(Either.map((state) => ({ ...coreWallet, state })), Either.mapLeft((error) => new ApplyTransactionError(error)));
+    },
+    rollbackUtxo(coreWallet, utxo) {
+        return UnshieldedState.rollbackSpendByUtxo(coreWallet.state, utxo).pipe(Either.map((state) => ({ ...coreWallet, state })), Either.mapLeft((error) => new RollbackUtxoError(error)));
+    },
+    spend(coreWallet, utxo) {
+        return UnshieldedState.spendByUtxo(coreWallet.state, utxo).pipe(Either.map((state) => ({ ...coreWallet, state })), Either.mapLeft((error) => new SpendUtxoError(error)));
+    },
+    spendUtxos(wallet, utxos) {
+        return pipe(utxos, Arr.reduce(Either.right([[], wallet.state]), (acc, utxoToSpend) => acc.pipe(Either.flatMap(([accUtxos, state]) => UnshieldedState.spendByUtxo(state, utxoToSpend).pipe(Either.map((nextState) => [accUtxos.concat([utxoToSpend]), nextState]), Either.mapLeft((error) => new SpendUtxoError(error)))))), Either.map(([spentUtxos, state]) => [spentUtxos, { ...wallet, state }]));
+    },
+};

package/dist/v1/Keys.d.ts

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

package/dist/v1/Keys.js

@@ -0,0 +1,23 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { UnshieldedAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+export const makeDefaultKeysCapability = () => {
+    return {
+        getPublicKey: (state) => {
+            return state.publicKey.publicKey;
+        },
+        getAddress: (state) => {
+            return new UnshieldedAddress(Buffer.from(state.publicKey.addressHex, 'hex'));
+        },
+    };
+};

package/dist/v1/RunningV1Variant.d.ts

@@ -0,0 +1,41 @@
+import { Effect, Scope, Stream } from 'effect';
+import { WalletRuntimeError, Variant, StateChange } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { SerializationCapability } from './Serialization.js';
+import { SyncCapability, SyncService } from './Sync.js';
+import { WalletSyncUpdate } from './SyncSchema.js';
+import { TransactingCapability, TokenTransfer } from './Transacting.js';
+import { WalletError } from './WalletError.js';
+import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { KeysCapability } from './Keys.js';
+import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet } from './CoreWallet.js';
+import { TransactionHistoryService } from './TransactionHistory.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+export declare namespace RunningV1Variant {
+    type Context<TSerialized, TSyncUpdate, TTransaction> = {
+        serializationCapability: SerializationCapability<CoreWallet, TSerialized>;
+        syncService: SyncService<CoreWallet, TSyncUpdate>;
+        syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
+        transactingCapability: TransactingCapability<TTransaction, CoreWallet>;
+        coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
+        keysCapability: KeysCapability<CoreWallet>;
+        coinSelection: CoinSelection<ledger.Utxo>;
+        transactionHistoryService: TransactionHistoryService<WalletSyncUpdate>;
+    };
+    type AnyContext = Context<any, any, any>;
+}
+export declare const V1Tag: unique symbol;
+export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate, ledger.FinalizedTransaction>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate, TTransaction> implements Variant.RunningVariant<typeof V1Tag, CoreWallet> {
+    #private;
+    readonly __polyTag__: typeof V1Tag;
+    readonly state: Stream.Stream<StateChange.StateChange<CoreWallet>, WalletRuntimeError>;
+    constructor(scope: Scope.Scope, context: Variant.VariantContext<CoreWallet>, v1Context: RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction>);
+    startSyncInBackground(): Effect.Effect<void>;
+    startSync(): Stream.Stream<void, WalletError, Scope.Scope>;
+    balanceTransaction(tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Effect.Effect<ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, WalletError>;
+    transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    serializeState(state: CoreWallet): TSerialized;
+}

package/dist/v1/RunningV1Variant.js

@@ -0,0 +1,91 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Effect, pipe, Scope, Stream, SubscriptionRef, Schedule, Duration, Sink, Console } from 'effect';
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { StateChange, VersionChangeType, } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { EitherOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+const progress = (state) => {
+    const appliedId = state.progress?.appliedId ?? 0n;
+    const highestTransactionId = state.progress?.highestTransactionId ?? 0n;
+    const sourceGap = highestTransactionId - appliedId;
+    const applyGap = appliedId - appliedId;
+    return [StateChange.ProgressUpdate({ sourceGap, applyGap })];
+};
+const protocolVersionChange = (previous, current) => {
+    return previous.protocolVersion != current.protocolVersion
+        ? [
+            StateChange.VersionChange({
+                change: VersionChangeType.Version({
+                    version: ProtocolVersion.ProtocolVersion(current.protocolVersion),
+                }),
+            }),
+        ]
+        : [];
+};
+export const V1Tag = Symbol('V1');
+export class RunningV1Variant {
+    __polyTag__ = V1Tag;
+    #scope;
+    #context;
+    #v1Context;
+    state;
+    constructor(scope, context, v1Context) {
+        this.#scope = scope;
+        this.#context = context;
+        this.#v1Context = v1Context;
+        this.state = Stream.fromEffect(context.stateRef.get).pipe(Stream.flatMap((initialState) => context.stateRef.changes.pipe(Stream.mapAccum(initialState, (previous, current) => {
+            return [current, [previous, current]];
+        }))), Stream.mapConcat(([previous, current]) => {
+            // TODO: emit progress only upon actual change
+            return [
+                StateChange.State({ state: current }),
+                ...progress(current),
+                ...protocolVersionChange(previous, current),
+            ];
+        }));
+    }
+    startSyncInBackground() {
+        return this.startSync().pipe(Stream.runScoped(Sink.drain), Effect.forkScoped, Effect.provideService(Scope.Scope, this.#scope));
+    }
+    startSync() {
+        return pipe(SubscriptionRef.get(this.#context.stateRef), Stream.fromEffect, Stream.flatMap((state) => this.#v1Context.syncService.updates(state)), Stream.mapEffect((update) => {
+            return SubscriptionRef.updateEffect(this.#context.stateRef, (state) => pipe(this.#v1Context.syncCapability.applyUpdate(state, update), EitherOps.toEffect));
+        }), Stream.tapError((error) => Console.error(error)), Stream.retry(pipe(Schedule.exponential(Duration.seconds(1), 2), Schedule.map((delay) => {
+            const maxDelay = Duration.minutes(2);
+            const jitter = Duration.millis(Math.floor(Math.random() * 1000));
+            const delayWithJitter = Duration.toMillis(delay) + Duration.toMillis(jitter);
+            return Duration.millis(Math.min(delayWithJitter, Duration.toMillis(maxDelay)));
+        }))));
+    }
+    balanceTransaction(tx) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.balanceTransaction(state, tx), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
+    transferTransaction(outputs, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.flatMap(({ transaction, newState }) => pipe(this.#v1Context.transactingCapability.balanceTransaction(newState, transaction), 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]));
+        });
+    }
+    signTransaction(transaction, signSegment) {
+        return this.#v1Context.transactingCapability.signTransaction(transaction, signSegment);
+    }
+    serializeState(state) {
+        return this.#v1Context.serializationCapability.serialize(state);
+    }
+}

package/dist/v1/Serialization.d.ts

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