@midnight-ntwrk/wallet-sdk-shielded 1.0.0-beta.10

package/dist/ShieldedWallet.d.ts

@@ -0,0 +1,70 @@
+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 { ProvingRecipe } from './v1/ProvingRecipe.js';
+import { SerializationCapability } from './v1/Serialization.js';
+import { ProgressUpdate, TransactionHistoryCapability } from './v1/TransactionHistory.js';
+import { AvailableCoin, CoinsAndBalancesCapability, PendingCoin } from './v1/CoinsAndBalances.js';
+import { KeysCapability } from './v1/Keys.js';
+import { ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { SubmissionEvent, SubmissionEventCases } from './v1/Submission.js';
+import { TokenTransfer } from './v1/Transacting.js';
+import { WalletSyncUpdate } from './v1/Sync.js';
+import { Variant, VariantBuilder, WalletLike } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+export type ShieldedWalletCapabilities<TSerialized = string, TTransaction = ledger.FinalizedTransaction> = {
+    serialization: SerializationCapability<CoreWallet, null, TSerialized>;
+    coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
+    keys: KeysCapability<CoreWallet>;
+    transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
+};
+export declare class ShieldedWalletState<TSerialized = string, TTransaction = ledger.FinalizedTransaction> {
+    static readonly mapState: <TSerialized_1 = string, TTransaction_1 = ledger.FinalizedTransaction>(capabilities: ShieldedWalletCapabilities<TSerialized_1, TTransaction_1>) => (state: ProtocolState.ProtocolState<CoreWallet>) => ShieldedWalletState<TSerialized_1, TTransaction_1>;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly state: CoreWallet;
+    readonly capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>;
+    get balances(): Record<ledger.RawTokenType, bigint>;
+    get totalCoins(): readonly (AvailableCoin | PendingCoin)[];
+    get availableCoins(): readonly AvailableCoin[];
+    get pendingCoins(): readonly PendingCoin[];
+    get coinPublicKey(): ShieldedCoinPublicKey;
+    get encryptionPublicKey(): ShieldedEncryptionPublicKey;
+    get address(): ShieldedAddress;
+    get progress(): ProgressUpdate;
+    get transactionHistory(): readonly TTransaction[];
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized, TTransaction>);
+    serialize(): TSerialized;
+}
+export type SubmitTransactionMethod<TTransaction> = {
+    (transaction: TTransaction, waitForStatus: 'Submitted'): Promise<SubmissionEventCases.Submitted>;
+    (transaction: TTransaction, waitForStatus: 'InBlock'): Promise<SubmissionEventCases.InBlock>;
+    (transaction: TTransaction, waitForStatus: 'Finalized'): Promise<SubmissionEventCases.Finalized>;
+    (transaction: TTransaction): Promise<SubmissionEventCases.InBlock>;
+    (transaction: TTransaction, waitForStatus?: 'Submitted' | 'InBlock' | 'Finalized'): Promise<SubmissionEvent>;
+};
+export type ShieldedWallet = CustomizedShieldedWallet<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export type ShieldedWalletClass = CustomizedShieldedWalletClass<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export interface CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> extends WalletLike.WalletLike<[
+    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
+]> {
+    readonly state: rx.Observable<ShieldedWalletState<TSerialized, TTransaction>>;
+    start(secretKeys: TStartAux): Promise<void>;
+    balanceTransaction(secretKeys: ledger.ZswapSecretKeys, tx: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>, newCoins: readonly ledger.ShieldedCoinInfo[]): Promise<ProvingRecipe<TTransaction>>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ProvingRecipe<TTransaction>>;
+    finalizeTransaction(recipe: ProvingRecipe<TTransaction>): Promise<TTransaction>;
+    readonly submitTransaction: SubmitTransactionMethod<TTransaction>;
+    serializeState(): Promise<TSerialized>;
+    waitForSyncedState(allowedGap?: bigint): Promise<ShieldedWalletState<TSerialized, TTransaction>>;
+    getAddress(): Promise<ShieldedAddress>;
+}
+export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[
+    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
+]> {
+    configuration: TConfig;
+    startWithShieldedSeed(seed: Uint8Array): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    startWithSecretKeys(secretKeys: ledger.ZswapSecretKeys): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedShieldedWallet<TStartAux, TTransaction, TSyncUpdate, TSerialized>;
+}
+export declare function ShieldedWallet(configuration: DefaultV1Configuration): ShieldedWalletClass;
+export declare function CustomShieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TConfig>): CustomizedShieldedWalletClass<TStartAux, TTransaction, TSyncUpdate, TSerialized, TConfig>;

package/dist/ShieldedWallet.js

@@ -0,0 +1,136 @@
+// 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 * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Effect, Either } from 'effect';
+import * as rx from 'rxjs';
+import { WalletBuilder } from '@midnight-ntwrk/wallet-sdk-runtime';
+export class ShieldedWalletState {
+    static mapState = (capabilities) => (state) => {
+        return new ShieldedWalletState(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 coinPublicKey() {
+        return this.capabilities.keys.getCoinPublicKey(this.state);
+    }
+    get encryptionPublicKey() {
+        return this.capabilities.keys.getEncryptionPublicKey(this.state);
+    }
+    get address() {
+        return this.capabilities.keys.getAddress(this.state);
+    }
+    get progress() {
+        return this.capabilities.transactionHistory.progress(this.state);
+    }
+    get transactionHistory() {
+        return this.capabilities.transactionHistory.transactionHistory(this.state);
+    }
+    constructor(state, capabilities) {
+        this.protocolVersion = state.version;
+        this.state = state.state;
+        this.capabilities = capabilities;
+    }
+    serialize() {
+        return this.capabilities.serialization.serialize(this.state);
+    }
+}
+export function ShieldedWallet(configuration) {
+    return CustomShieldedWallet(configuration, new V1Builder().withDefaults());
+}
+export function CustomShieldedWallet(configuration, builder) {
+    const buildArgs = [configuration];
+    const BaseWallet = WalletBuilder.init()
+        .withVariant(ProtocolVersion.MinSupportedVersion, builder)
+        .build(...buildArgs);
+    return class CustomShieldedWalletImplementation extends BaseWallet {
+        static startWithSecretKeys(secretKeys) {
+            return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, CoreWallet.initEmpty(secretKeys, CustomShieldedWalletImplementation.configuration.networkId));
+        }
+        static startWithShieldedSeed(seed) {
+            const secretKeys = ledger.ZswapSecretKeys.fromSeed(seed);
+            return CustomShieldedWalletImplementation.startWithSecretKeys(secretKeys);
+        }
+        static restore(serializedState) {
+            const deserialized = CustomShieldedWalletImplementation.allVariantsRecord()[V1Tag].variant.deserializeState(serializedState)
+                .pipe(Either.getOrThrow);
+            return CustomShieldedWalletImplementation.startFirst(CustomShieldedWalletImplementation, deserialized);
+        }
+        state;
+        constructor(runtime, scope) {
+            super(runtime, scope);
+            this.state = this.rawState.pipe(rx.map(ShieldedWalletState.mapState(CustomShieldedWalletImplementation.allVariantsRecord()[V1Tag].variant)), rx.shareReplay({ refCount: true, bufferSize: 1 }));
+        }
+        start(secretKeys) {
+            return this.runtime.dispatch({ [V1Tag]: (v1) => v1.startSyncInBackground(secretKeys) }).pipe(Effect.runPromise);
+        }
+        balanceTransaction(secretKeys, tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceTransaction(secretKeys, tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        transferTransaction(secretKeys, outputs) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.transferTransaction(secretKeys, outputs),
+            })
+                .pipe(Effect.runPromise);
+        }
+        initSwap(secretKeys, desiredInputs, desiredOutputs) {
+            return this.runtime
+                .dispatch({ [V1Tag]: (v1) => v1.initSwap(secretKeys, desiredInputs, desiredOutputs) })
+                .pipe(Effect.runPromise);
+        }
+        finalizeTransaction(recipe) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.finalizeTransaction(recipe),
+            })
+                .pipe(Effect.runPromise);
+        }
+        submitTransaction = ((tx, waitForStatus = 'InBlock') => {
+            return this.runtime
+                .dispatch({ [V1Tag]: (v1) => v1.submitTransaction(tx, waitForStatus) })
+                .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 [[ShieldedWalletState.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

@@ -0,0 +1 @@
+export * from './ShieldedWallet.js';

package/dist/index.js

@@ -0,0 +1,13 @@
+// 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.
+export * from './ShieldedWallet.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -0,0 +1,24 @@
+import { CoreWallet } from './CoreWallet.js';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+export type AvailableCoin = {
+    coin: ledger.QualifiedShieldedCoinInfo;
+    commitment: ledger.CoinCommitment;
+    nullifier: ledger.Nullifier;
+};
+export type PendingCoin = {
+    coin: ledger.ShieldedCoinInfo;
+    ttl: Date | undefined;
+    commitment: ledger.CoinCommitment;
+    nullifier: ledger.Nullifier;
+};
+export type Coin = AvailableCoin | PendingCoin;
+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 AvailableCoin[];
+    getPendingCoins(state: TState): readonly PendingCoin[];
+    getTotalCoins(state: TState): ReadonlyArray<AvailableCoin | PendingCoin>;
+};
+export declare const makeDefaultCoinsAndBalancesCapability: () => CoinsAndBalancesCapability<CoreWallet>;

package/dist/v1/CoinsAndBalances.js

@@ -0,0 +1,46 @@
+import { pipe, Array } from 'effect';
+import { RecordOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+const calculateBalances = (coins) => coins.reduce((acc, { coin }) => ({
+    ...acc,
+    [coin.type]: acc[coin.type] === undefined ? coin.value : acc[coin.type] + coin.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) => {
+        const pendingSpends = new Set([...state.state.pendingSpends.values()].map(([coin]) => coin.nonce));
+        return pipe([...state.state.coins], Array.filter((coin) => !pendingSpends.has(coin.nonce)), Array.map((coin) => {
+            return {
+                coin,
+                commitment: state.coinHashes[coin.nonce].commitment,
+                nullifier: state.coinHashes[coin.nonce].nullifier,
+            };
+        }));
+    };
+    const getPendingCoins = (state) => pipe([...state.state.pendingOutputs.values()], Array.map(([coin, ttl]) => ({
+        coin,
+        ttl,
+        commitment: state.coinHashes[coin.nonce].commitment,
+        nullifier: state.coinHashes[coin.nonce].nullifier,
+    })));
+    const getTotalCoins = (state) => [...getAvailableCoins(state), ...getPendingCoins(state)];
+    return {
+        getAvailableBalances,
+        getPendingBalances,
+        getTotalBalances,
+        getAvailableCoins,
+        getPendingCoins,
+        getTotalCoins,
+    };
+};

package/dist/v1/CoreWallet.d.ts

@@ -0,0 +1,49 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Either } from 'effect';
+import { SyncProgress, SyncProgressData } from './SyncProgress.js';
+import { WalletError } from './WalletError.js';
+export type PublicKeys = {
+    coinPublicKey: ledger.CoinPublicKey;
+    encryptionPublicKey: ledger.EncPublicKey;
+};
+export declare const PublicKeys: {
+    fromSecretKeys: (secretKeys: ledger.ZswapSecretKeys) => PublicKeys;
+};
+export type CoinHashesMap = Readonly<Record<ledger.Nonce, {
+    nullifier: ledger.Nullifier;
+    commitment: ledger.CoinCommitment;
+}>>;
+export declare const CoinHashesMap: {
+    empty: {};
+    pickAllCoins(state: ledger.ZswapLocalState): readonly ledger.ShieldedCoinInfo[];
+    assertValid(map: CoinHashesMap, state: ledger.ZswapLocalState): Either.Either<void, Set<ledger.Nonce>>;
+    updateWithCoins(secretKeys: ledger.ZswapSecretKeys, existing: CoinHashesMap, coins: Iterable<ledger.ShieldedCoinInfo>): CoinHashesMap;
+    updateWithNewCoins(secretKeys: ledger.ZswapSecretKeys, existing: CoinHashesMap, coins: Iterable<ledger.ShieldedCoinInfo>): CoinHashesMap;
+    init(secretKeys: ledger.ZswapSecretKeys, coins: Iterable<ledger.ShieldedCoinInfo>): CoinHashesMap;
+};
+export type CoreWallet = Readonly<{
+    state: ledger.ZswapLocalState;
+    publicKeys: PublicKeys;
+    protocolVersion: ProtocolVersion.ProtocolVersion;
+    progress: SyncProgress;
+    networkId: string;
+    txHistoryArray: readonly ledger.FinalizedTransaction[];
+    coinHashes: CoinHashesMap;
+}>;
+export declare const CoreWallet: {
+    init(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
+    empty(publicKeys: PublicKeys, networkId: string): CoreWallet;
+    restore(localState: ledger.ZswapLocalState, secretKeys: ledger.ZswapSecretKeys, txHistory: readonly ledger.FinalizedTransaction[], syncProgress: Omit<SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
+    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, txHistory: readonly ledger.FinalizedTransaction[], coinHashes: CoinHashesMap, syncProgress: SyncProgressData, protocolVersion: bigint, networkId: string): Either.Either<CoreWallet, WalletError>;
+    initEmpty(keys: ledger.ZswapSecretKeys, networkId: string): CoreWallet;
+    applyCollapsedUpdate(wallet: CoreWallet, collapsed: ledger.MerkleTreeCollapsedUpdate): CoreWallet;
+    apply<TOffer extends ledger.ZswapOffer<ledger.Proofish>>(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, offer: TOffer): CoreWallet;
+    replayEvents(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, events: ledger.Event[]): CoreWallet;
+    updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgressData>): CoreWallet;
+    addTransaction(wallet: CoreWallet, tx: ledger.FinalizedTransaction): CoreWallet;
+    revertTransaction<TTx extends ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>>(wallet: CoreWallet, _tx: TTx): CoreWallet;
+    updateTxHistory(wallet: CoreWallet, newTxs: readonly ledger.FinalizedTransaction[]): CoreWallet;
+    spendCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.QualifiedShieldedCoinInfo>, segment: number): [ReadonlyArray<ledger.ZswapOffer<ledger.PreProof>>, CoreWallet];
+    watchCoins(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, coins: ReadonlyArray<ledger.ShieldedCoinInfo>): CoreWallet;
+};

package/dist/v1/CoreWallet.js

@@ -0,0 +1,152 @@
+// 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 * as ledger from '@midnight-ntwrk/ledger-v6';
+import { ProtocolVersion } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Either, Iterable, pipe, Record, Array as Arr } from 'effect';
+import { createSyncProgress } from './SyncProgress.js';
+import { InvalidCoinHashesError } from './WalletError.js';
+export const PublicKeys = {
+    fromSecretKeys: (secretKeys) => {
+        return {
+            coinPublicKey: secretKeys.coinPublicKey,
+            encryptionPublicKey: secretKeys.encryptionPublicKey,
+        };
+    },
+};
+export const CoinHashesMap = {
+    empty: {},
+    pickAllCoins(state) {
+        return [...state.coins, ...state.pendingOutputs.values().map(([coin]) => coin)];
+    },
+    assertValid(map, state) {
+        const coins = CoinHashesMap.pickAllCoins(state);
+        const coinNonces = new Set(Iterable.map(coins, (coin) => coin.nonce));
+        const definedNonces = new Set(Object.keys(map));
+        const missingNonces = coinNonces.difference(definedNonces);
+        return missingNonces.size === 0 ? Either.void : Either.left(missingNonces);
+    },
+    updateWithCoins(secretKeys, existing, coins) {
+        return Record.fromIterableWith(coins, (coin) => [
+            coin.nonce,
+            existing[coin.nonce] ?? {
+                commitment: ledger.coinCommitment(coin, secretKeys.coinPublicKey),
+                nullifier: ledger.coinNullifier(coin, secretKeys.coinSecretKey),
+            },
+        ]);
+    },
+    updateWithNewCoins(secretKeys, existing, coins) {
+        const newMap = CoinHashesMap.updateWithCoins(secretKeys, CoinHashesMap.empty, coins);
+        return Record.union(existing, newMap, (a) => a);
+    },
+    init(secretKeys, coins) {
+        return CoinHashesMap.updateWithCoins(secretKeys, {}, coins);
+    },
+};
+export const CoreWallet = {
+    init(localState, secretKeys, networkId) {
+        const publicKeys = PublicKeys.fromSecretKeys(secretKeys);
+        const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
+        const progress = createSyncProgress();
+        const protocolVersion = ProtocolVersion.MinSupportedVersion;
+        return { state: localState, publicKeys, networkId, coinHashes, txHistoryArray: [], progress, protocolVersion };
+    },
+    empty(publicKeys, networkId) {
+        return {
+            state: new ledger.ZswapLocalState(),
+            publicKeys,
+            networkId,
+            coinHashes: CoinHashesMap.empty,
+            txHistoryArray: [],
+            progress: createSyncProgress(),
+            protocolVersion: ProtocolVersion.MinSupportedVersion,
+        };
+    },
+    restore(localState, secretKeys, txHistory, syncProgress, protocolVersion, networkId) {
+        const publicKeys = PublicKeys.fromSecretKeys(secretKeys);
+        const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
+        return {
+            state: localState,
+            publicKeys,
+            networkId,
+            coinHashes,
+            txHistoryArray: txHistory,
+            progress: createSyncProgress(syncProgress),
+            protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
+        };
+    },
+    restoreWithCoinHashes(publicKeys, localState, txHistory, coinHashes, syncProgress, protocolVersion, networkId) {
+        return CoinHashesMap.assertValid(coinHashes, localState).pipe(Either.mapBoth({
+            onLeft: (missingNonces) => new InvalidCoinHashesError({ message: 'Missing coin hashes for coins present in the state', missingNonces }),
+            onRight: () => ({
+                state: localState,
+                publicKeys,
+                networkId,
+                coinHashes,
+                txHistoryArray: txHistory,
+                progress: createSyncProgress(syncProgress),
+                protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
+            }),
+        }));
+    },
+    initEmpty(keys, networkId) {
+        return this.empty(PublicKeys.fromSecretKeys(keys), networkId);
+    },
+    applyCollapsedUpdate(wallet, collapsed) {
+        const newState = wallet.state.applyCollapsedUpdate(collapsed);
+        return { ...wallet, state: newState };
+    },
+    apply(wallet, secretKeys, offer) {
+        const newState = wallet.state.apply(secretKeys, offer);
+        const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
+        return { ...wallet, state: newState, coinHashes: newCoinHashes };
+    },
+    replayEvents(wallet, secretKeys, events) {
+        const newState = wallet.state.replayEvents(secretKeys, events);
+        const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
+        return { ...wallet, state: newState, coinHashes: newCoinHashes };
+    },
+    updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }) {
+        const updatedProgress = createSyncProgress({
+            appliedIndex: appliedIndex ?? wallet.progress.appliedIndex,
+            highestRelevantWalletIndex: highestRelevantWalletIndex ?? wallet.progress.highestRelevantWalletIndex,
+            highestIndex: highestIndex ?? wallet.progress.highestIndex,
+            highestRelevantIndex: highestRelevantIndex ?? wallet.progress.highestRelevantIndex,
+            isConnected: isConnected ?? wallet.progress.isConnected,
+        });
+        return { ...wallet, progress: updatedProgress };
+    },
+    addTransaction(wallet, tx) {
+        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, tx] };
+    },
+    /* not implemented until this is done https://shielded.atlassian.net/browse/PM-19678 */
+    revertTransaction(wallet, _tx) {
+        return wallet;
+    },
+    updateTxHistory(wallet, newTxs) {
+        return { ...wallet, txHistoryArray: [...wallet.txHistoryArray, ...newTxs] };
+    },
+    spendCoins(wallet, secretKeys, coins, segment) {
+        const [offers, newLocalState] = pipe(coins, Arr.reduce([[], wallet.state], ([accOffers, localState], coinToSpend) => {
+            const [nextState, newInput] = localState.spend(secretKeys, coinToSpend, segment);
+            const inputOffer = ledger.ZswapOffer.fromInput(newInput, coinToSpend.type, coinToSpend.value);
+            return [accOffers.concat([inputOffer]), nextState];
+        }));
+        const updated = { ...wallet, state: newLocalState };
+        return [offers, updated];
+    },
+    watchCoins(wallet, secretKeys, coins) {
+        const newLocalState = coins.reduce((localState, coin) => localState.watchFor(wallet.publicKeys.coinPublicKey, coin), wallet.state);
+        const newCoinHashes = CoinHashesMap.updateWithNewCoins(secretKeys, wallet.coinHashes, coins);
+        return { ...wallet, state: newLocalState, coinHashes: newCoinHashes };
+    },
+};

package/dist/v1/Keys.d.ts

@@ -0,0 +1,8 @@
+import type { CoreWallet } from './CoreWallet.js';
+import { ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey } from '@midnight-ntwrk/wallet-sdk-address-format';
+export type KeysCapability<TState> = {
+    getCoinPublicKey(state: TState): ShieldedCoinPublicKey;
+    getEncryptionPublicKey(state: TState): ShieldedEncryptionPublicKey;
+    getAddress(state: TState): ShieldedAddress;
+};
+export declare const makeDefaultKeysCapability: () => KeysCapability<CoreWallet>;

package/dist/v1/Keys.js

@@ -0,0 +1,16 @@
+import { ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey, } from '@midnight-ntwrk/wallet-sdk-address-format';
+export const makeDefaultKeysCapability = () => {
+    return {
+        getCoinPublicKey: (state) => {
+            return new ShieldedCoinPublicKey(Buffer.from(state.publicKeys.coinPublicKey, 'hex'));
+        },
+        getEncryptionPublicKey: (state) => {
+            return new ShieldedEncryptionPublicKey(Buffer.from(state.publicKeys.encryptionPublicKey, 'hex'));
+        },
+        getAddress: (state) => {
+            const coinPublicKey = new ShieldedCoinPublicKey(Buffer.from(state.publicKeys.coinPublicKey, 'hex'));
+            const encryptionPublicKey = new ShieldedEncryptionPublicKey(Buffer.from(state.publicKeys.encryptionPublicKey, 'hex'));
+            return new ShieldedAddress(coinPublicKey, encryptionPublicKey);
+        },
+    };
+};

package/dist/v1/Proving.d.ts

@@ -0,0 +1,12 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Effect } from 'effect';
+import { ProvingRecipe } from './ProvingRecipe.js';
+import { WalletError } from './WalletError.js';
+export interface ProvingService<TTransaction> {
+    prove(recipe: ProvingRecipe<TTransaction>): Effect.Effect<TTransaction, WalletError>;
+}
+export type DefaultProvingConfiguration = {
+    provingServerUrl: URL;
+};
+export declare const makeDefaultProvingService: (configuration: DefaultProvingConfiguration) => ProvingService<ledger.FinalizedTransaction>;
+export declare const makeSimulatorProvingService: () => ProvingService<ledger.ProofErasedTransaction>;

package/dist/v1/Proving.js

@@ -0,0 +1,53 @@
+// 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 { HttpProverClient, ProverClient } from '@midnight-ntwrk/wallet-sdk-prover-client/effect';
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Effect, pipe } from 'effect';
+import { ProvingError } from './WalletError.js';
+export const makeDefaultProvingService = (configuration) => {
+    const clientLayer = HttpProverClient.layer({
+        url: configuration.provingServerUrl,
+    });
+    return {
+        prove(recipe) {
+            switch (recipe.type) {
+                case 'BalanceTransactionToProve':
+                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transactionToProve, ledger.CostModel.initialCostModel())), Effect.map((provenTx) => recipe.transactionToBalance.merge(provenTx.bind())), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
+                        message: error.message,
+                        cause: error,
+                    }))));
+                case 'TransactionToProve':
+                    return pipe(ProverClient.ProverClient, Effect.flatMap((client) => client.proveTransaction(recipe.transaction, ledger.CostModel.initialCostModel())), Effect.map((proven) => proven.bind()), Effect.provide(clientLayer), Effect.catchAll((error) => Effect.fail(new ProvingError({
+                        message: error.message,
+                        cause: error,
+                    }))));
+                case 'NothingToProve':
+                    return Effect.succeed(recipe.transaction);
+            }
+        },
+    };
+};
+export const makeSimulatorProvingService = () => {
+    return {
+        prove(recipe) {
+            switch (recipe.type) {
+                case 'BalanceTransactionToProve':
+                    return pipe(Effect.succeed(recipe.transactionToProve.eraseProofs()), Effect.map((proven) => recipe.transactionToBalance.merge(proven)));
+                case 'TransactionToProve':
+                    return Effect.succeed(recipe.transaction.eraseProofs());
+                case 'NothingToProve':
+                    return Effect.succeed(recipe.transaction);
+            }
+        },
+    };
+};

package/dist/v1/ProvingRecipe.d.ts

@@ -0,0 +1,18 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+export declare const TRANSACTION_TO_PROVE = "TransactionToProve";
+export declare const BALANCE_TRANSACTION_TO_PROVE = "BalanceTransactionToProve";
+export declare const NOTHING_TO_PROVE = "NothingToProve";
+export type TransactionToProve = {
+    readonly type: typeof TRANSACTION_TO_PROVE;
+    readonly transaction: ledger.UnprovenTransaction;
+};
+export type BalanceTransactionToProve<Transaction> = {
+    readonly type: typeof BALANCE_TRANSACTION_TO_PROVE;
+    readonly transactionToProve: ledger.UnprovenTransaction;
+    readonly transactionToBalance: Transaction;
+};
+export type NothingToProve<Transaction> = {
+    readonly type: typeof NOTHING_TO_PROVE;
+    readonly transaction: Transaction;
+};
+export type ProvingRecipe<Transaction> = TransactionToProve | BalanceTransactionToProve<Transaction> | NothingToProve<Transaction>;

package/dist/v1/ProvingRecipe.js

@@ -0,0 +1,3 @@
+export const TRANSACTION_TO_PROVE = 'TransactionToProve';
+export const BALANCE_TRANSACTION_TO_PROVE = 'BalanceTransactionToProve';
+export const NOTHING_TO_PROVE = 'NothingToProve';