@midnightntwrk/wallet-sdk-shielded 3.0.2

package/README.md

@@ -0,0 +1,124 @@
+# @midnightntwrk/wallet-sdk-shielded
+
+Manages shielded tokens on the Midnight network using zero-knowledge proofs.
+
+## Installation
+
+```bash
+npm install @midnightntwrk/wallet-sdk-shielded
+```
+
+## Overview
+
+The Shielded Wallet handles private token operations where transaction values and addresses are hidden from observers
+while maintaining verifiability. It provides:
+
+- Zero-knowledge proof generation
+- Coin commitment tracking
+- Encrypted output decryption
+- Shielded transfer transactions
+- Transaction balancing for shielded tokens
+
+## Usage
+
+### Starting the Wallet
+
+```typescript
+import { ShieldedWallet } from '@midnightntwrk/wallet-sdk-shielded';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+import { randomBytes } from 'node:crypto';
+
+// Configuration for the wallet
+const configuration = {
+  networkId: 'preview',
+  provingServerUrl: new URL('http://localhost:6300'),
+  relayURL: new URL('ws://localhost:9944'),
+  indexerClientConnection: {
+    indexerHttpUrl: 'http://localhost:8088/api/v3/graphql',
+    indexerWsUrl: 'ws://localhost:8088/api/v3/graphql/ws',
+  },
+};
+
+// Create secret keys from a shielded seed
+const seed = randomBytes(32);
+const shieldedSecretKeys = ledger.ZswapSecretKeys.fromSeed(seed);
+
+// Create and start the wallet
+const shieldedWallet = ShieldedWallet(configuration).startWithSecretKeys(shieldedSecretKeys);
+
+// Start syncing with the network
+await shieldedWallet.start(shieldedSecretKeys);
+```
+
+### Alternative: Start with Seed Directly
+
+```typescript
+// Start directly with a shielded seed
+const shieldedWallet = ShieldedWallet(configuration).startWithSeed(seed);
+await shieldedWallet.start(ledger.ZswapSecretKeys.fromSeed(seed));
+```
+
+### Restoring from Serialized State
+
+```typescript
+// Restore a wallet from previously serialized state
+const shieldedWallet = ShieldedWallet(configuration).restore(serializedState);
+await shieldedWallet.start(shieldedSecretKeys);
+```
+
+### Observing State
+
+```typescript
+wallet.state.subscribe((state) => {
+  console.log('Progress:', state.state.progress);
+  console.log('Coins:', state.state.coins);
+});
+```
+
+### Creating Transfer Transactions
+
+```typescript
+const tx = await wallet.transferTransaction(shieldedSecretKeys, [
+  { type: 'NIGHT', receiverAddress: 'mn_shield-addr1...', amount: 1000n },
+]);
+```
+
+### Balancing Transactions
+
+```typescript
+const balancingTx = await wallet.balanceTransaction(shieldedSecretKeys, transactionToBalance);
+```
+
+### Creating Swap Offers
+
+```typescript
+const swapTx = await wallet.initSwap(
+  shieldedSecretKeys,
+  { NIGHT: 500n }, // inputs
+  [{ type: 'TOKEN_A', receiverAddress: shieldedAddress, amount: 100n }], // outputs
+);
+```
+
+## Privacy Model
+
+Shielded transactions use zero-knowledge proofs to hide:
+
+- Transaction amounts
+- Sender addresses
+- Receiver addresses
+
+While still proving:
+
+- The sender has sufficient balance
+- No tokens are created or destroyed
+- The transaction is valid
+
+## Exports
+
+- `ShieldedWallet` - Main wallet class
+- `ShieldedWalletState` - Wallet state type
+- Version 1 exports via `@midnightntwrk/wallet-sdk-shielded/v1`
+
+## License
+
+Apache-2.0

package/dist/ShieldedWallet.d.ts

@@ -0,0 +1,65 @@
+import { type ProtocolState, ProtocolVersion, type SyncProgress } from '@midnightntwrk/wallet-sdk-abstractions';
+import { type BaseV1Configuration, type DefaultV1Configuration, type V1Variant, CoreWallet } from './v1/index.js';
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import * as rx from 'rxjs';
+import { type BalancingResult } from './v1/Transacting.js';
+import { type SerializationCapability } from './v1/Serialization.js';
+import { type TransactionHistoryService } from './v1/TransactionHistory.js';
+import { type AvailableCoin, type CoinsAndBalancesCapability, type PendingCoin } from './v1/CoinsAndBalances.js';
+import { type KeysCapability } from './v1/Keys.js';
+import { type ShieldedAddress, type ShieldedCoinPublicKey, type ShieldedEncryptionPublicKey } from '@midnightntwrk/wallet-sdk-address-format';
+import { type TokenTransfer } from './v1/Transacting.js';
+import { type WalletSyncUpdate } from './v1/Sync.js';
+import { type Variant, type VariantBuilder, type WalletLike } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
+export type ShieldedWalletCapabilities<TSerialized = string> = {
+    serialization: SerializationCapability<CoreWallet, null, TSerialized>;
+    coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
+    keys: KeysCapability<CoreWallet>;
+};
+export type ShieldedWalletServices = {
+    transactionHistory: TransactionHistoryService;
+};
+export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
+export declare class ShieldedWalletState<TSerialized = string, _TTransaction = ledger.FinalizedTransaction> {
+    static readonly mapState: <TSerialized_1 = string>(variant: ShieldedWalletCapabilities<TSerialized_1> & ShieldedWalletServices) => (state: ProtocolState.ProtocolState<CoreWallet>) => ShieldedWalletState<TSerialized_1>;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly state: CoreWallet;
+    readonly capabilities: ShieldedWalletCapabilities<TSerialized>;
+    readonly services: ShieldedWalletServices;
+    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(): SyncProgress.SyncProgress;
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: ShieldedWalletCapabilities<TSerialized>, services: ShieldedWalletServices);
+    serialize(): TSerialized;
+}
+export type ShieldedWallet = CustomizedShieldedWallet<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export type ShieldedWalletClass = CustomizedShieldedWalletClass<ledger.ZswapSecretKeys, ledger.FinalizedTransaction, WalletSyncUpdate, string>;
+export type ShieldedWalletAPI<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSerialized = string> = {
+    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>): Promise<BalancingResult>;
+    transferTransaction(secretKeys: ledger.ZswapSecretKeys, outputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    initSwap(secretKeys: ledger.ZswapSecretKeys, desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[]): Promise<ledger.UnprovenTransaction>;
+    serializeState(): Promise<TSerialized>;
+    waitForSyncedState(allowedGap?: bigint): Promise<ShieldedWalletState<TSerialized, TTransaction>>;
+    getAddress(): Promise<ShieldedAddress>;
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<void>;
+    stop(): Promise<void>;
+};
+export type CustomizedShieldedWallet<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string> = ShieldedWalletAPI<TStartAux, TTransaction, TSerialized> & WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>]>;
+export type DefaultShieldedConfiguration = DefaultV1Configuration;
+export interface CustomizedShieldedWalletClass<TStartAux = ledger.ZswapSecretKeys, TTransaction = ledger.FinalizedTransaction, TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultShieldedConfiguration> extends WalletLike.BaseWalletClass<[
+    Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>>
+]> {
+    configuration: TConfig;
+    startWithSeed(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,132 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { ProtocolVersion } from '@midnightntwrk/wallet-sdk-abstractions';
+import { V1Builder, V1Tag, CoreWallet, } from './v1/index.js';
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { Effect, Either } from 'effect';
+import * as rx from 'rxjs';
+import { WalletBuilder } from '@midnightntwrk/wallet-sdk-runtime';
+export class ShieldedWalletState {
+    static mapState = (variant) => (state) => {
+        const { serialization, coinsAndBalances, keys } = variant;
+        const { transactionHistory } = variant;
+        return new ShieldedWalletState(state, { serialization, coinsAndBalances, keys }, { transactionHistory });
+    };
+    protocolVersion;
+    state;
+    capabilities;
+    services;
+    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.state.progress;
+    }
+    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);
+    }
+}
+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 startWithSeed(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);
+        }
+        revertTransaction(transaction) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.revertTransaction(transaction),
+            })
+                .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,2 @@
+export * from './ShieldedWallet.js';
+export { type ShieldedTransactionHistoryEntry, ShieldedSectionSchema, mergeShieldedSections, } from './v1/TransactionHistory.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+export * from './ShieldedWallet.js';
+export { ShieldedSectionSchema, mergeShieldedSections, } from './v1/TransactionHistory.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -0,0 +1,24 @@
+import { type CoreWallet } from './CoreWallet.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+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 '@midnightntwrk/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,47 @@
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { ProtocolVersion, SyncProgress } from '@midnightntwrk/wallet-sdk-abstractions';
+import { Either } from 'effect';
+import { type 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.SyncProgress;
+    networkId: string;
+    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, syncProgress: Omit<SyncProgress.SyncProgressData, "isConnected">, protocolVersion: bigint, networkId: string): CoreWallet;
+    restoreWithCoinHashes(publicKeys: PublicKeys, localState: ledger.ZswapLocalState, coinHashes: CoinHashesMap, syncProgress: 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;
+    replayEventsWithChanges(wallet: CoreWallet, secretKeys: ledger.ZswapSecretKeys, events: ledger.Event[]): [CoreWallet, ledger.ZswapStateChanges[]];
+    updateProgress(wallet: CoreWallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }: Partial<SyncProgress.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,153 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import * as ledger from '@midnight-ntwrk/ledger-v8';
+import { ProtocolVersion, SyncProgress } from '@midnightntwrk/wallet-sdk-abstractions';
+import { Either, Iterable, pipe, Record, Array as Arr } from 'effect';
+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 = SyncProgress.createSyncProgress();
+        const protocolVersion = ProtocolVersion.MinSupportedVersion;
+        return { state: localState, publicKeys, networkId, coinHashes, progress, protocolVersion };
+    },
+    empty(publicKeys, networkId) {
+        return {
+            state: new ledger.ZswapLocalState(),
+            publicKeys,
+            networkId,
+            coinHashes: CoinHashesMap.empty,
+            progress: SyncProgress.createSyncProgress(),
+            protocolVersion: ProtocolVersion.MinSupportedVersion,
+        };
+    },
+    restore(localState, secretKeys, syncProgress, protocolVersion, networkId) {
+        const publicKeys = PublicKeys.fromSecretKeys(secretKeys);
+        const coinHashes = CoinHashesMap.init(secretKeys, CoinHashesMap.pickAllCoins(localState));
+        return {
+            state: localState,
+            publicKeys,
+            networkId,
+            coinHashes,
+            progress: SyncProgress.createSyncProgress(syncProgress),
+            protocolVersion: ProtocolVersion.ProtocolVersion(protocolVersion),
+        };
+    },
+    restoreWithCoinHashes(publicKeys, localState, 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,
+                progress: SyncProgress.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 };
+    },
+    replayEventsWithChanges(wallet, secretKeys, events) {
+        const stateWithChanges = wallet.state.replayEventsWithChanges(secretKeys, events);
+        const newState = stateWithChanges.state;
+        const newCoinHashes = CoinHashesMap.updateWithCoins(secretKeys, wallet.coinHashes, CoinHashesMap.pickAllCoins(newState));
+        const updatedWallet = { ...wallet, state: newState, coinHashes: newCoinHashes };
+        return [updatedWallet, stateWithChanges.changes];
+    },
+    updateProgress(wallet, { appliedIndex, highestRelevantWalletIndex, highestIndex, highestRelevantIndex, isConnected, }) {
+        const updatedProgress = SyncProgress.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 };
+    },
+    // TODO: Remove after tx history is implemented
+    addTransaction(wallet, _tx) {
+        return wallet;
+    },
+    /* not implemented until this is done https://shielded.atlassian.net/browse/PM-19678 */
+    revertTransaction(wallet, tx) {
+        const newState = wallet.state.revertTransaction(tx);
+        return { ...wallet, state: newState };
+    },
+    // TODO: Remove after tx history is implemented
+    updateTxHistory(wallet, _newTxs) {
+        return wallet;
+    },
+    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 '@midnightntwrk/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 '@midnightntwrk/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);
+        },
+    };
+};