@midnightntwrk/wallet-sdk-unshielded-wallet 3.1.0

package/README.md

@@ -0,0 +1,123 @@
+# @midnightntwrk/wallet-sdk-unshielded-wallet
+
+Manages unshielded tokens on the Midnight network.
+
+## Installation
+
+```bash
+npm install @midnightntwrk/wallet-sdk-unshielded-wallet
+```
+
+## Overview
+
+The Unshielded Wallet handles transparent token operations where transactions are publicly visible on the blockchain.
+Unlike shielded transactions, unshielded operations do not use zero-knowledge proofs. This package provides:
+
+- Public token balance tracking
+- Transparent transfer transactions
+- Transaction balancing for unshielded tokens
+- Swap initialization and participation
+- Transaction signing
+
+## Usage
+
+### Starting the Wallet
+
+```typescript
+import { UnshieldedWallet, createKeystore, PublicKey } from '@midnightntwrk/wallet-sdk-unshielded-wallet';
+import { InMemoryTransactionHistoryStorage, NetworkId } from '@midnightntwrk/wallet-sdk-abstractions';
+import { randomBytes } from 'node:crypto';
+
+// Configuration for the wallet
+const configuration = {
+  networkId: NetworkId.Undeployed, // or NetworkId.Testnet, NetworkId.Mainnet
+  indexerClientConnection: {
+    indexerWsUrl: 'ws://localhost:8088/api/v4/graphql/ws',
+    indexerHttpUrl: 'http://localhost:8088/api/v4/graphql',
+  },
+  txHistoryStorage: new InMemoryTransactionHistoryStorage(),
+};
+
+// Create a keystore from a random unshielded seed
+const seed = randomBytes(32);
+const keystore = createKeystore(seed, configuration.networkId);
+
+// Create and start the wallet
+const unshieldedWallet = UnshieldedWallet(configuration).startWithPublicKey(PublicKey.fromKeyStore(keystore));
+
+// Start syncing with the network
+await unshieldedWallet.start();
+```
+
+### Restoring from Serialized State
+
+```typescript
+// Restore a wallet from previously serialized state
+const unshieldedWallet = UnshieldedWallet(configuration).restore(serializedState);
+await unshieldedWallet.start();
+```
+
+### Observing State
+
+```typescript
+unshieldedWallet.state.subscribe((state) => {
+  console.log('Progress:', state.progress);
+  console.log('Balances:', state.balances);
+});
+
+// Or wait for sync
+const syncedState = await unshieldedWallet.waitForSyncedState();
+```
+
+### Creating Transfer Transactions
+
+```typescript
+const tx = await unshieldedWallet.transferTransaction(
+  [{ type: 'TOKEN_A', receiverAddress: '...', amount: 1000n }],
+  ttl,
+);
+```
+
+### Balancing Transactions
+
+```typescript
+// Balance a finalized transaction
+const balancingTx = await unshieldedWallet.balanceFinalizedTransaction(finalizedTx);
+
+// Balance an unbound transaction (in-place)
+const balancedTx = await unshieldedWallet.balanceUnboundTransaction(unboundTx);
+
+// Balance an unproven transaction (in-place)
+const balancedUnprovenTx = await unshieldedWallet.balanceUnprovenTransaction(unprovenTx);
+```
+
+### Signing Transactions
+
+```typescript
+// Sign an unproven transaction
+const signedTx = await unshieldedWallet.signUnprovenTransaction(tx, signSegment);
+
+// Sign an unbound transaction
+const signedUnboundTx = await unshieldedWallet.signUnboundTransaction(tx, signSegment);
+```
+
+### Creating Swap Offers
+
+```typescript
+const swapTx = await unshieldedWallet.initSwap(
+  { TOKEN_A: 500n }, // inputs
+  [{ type: 'TOKEN_B', receiverAddress, amount: 100n }], // outputs
+  ttl,
+);
+```
+
+## Exports
+
+- `UnshieldedWallet` - Main wallet class
+- `UnshieldedWalletState` - Wallet state type
+- `KeyStore` - Key storage utilities
+- Storage utilities for persistence
+
+## License
+
+Apache-2.0

package/dist/KeyStore.d.ts

@@ -0,0 +1,19 @@
+import { type MidnightBech32m } from '@midnightntwrk/wallet-sdk-address-format';
+import { type Signature, type SignatureVerifyingKey, type UserAddress } from '@midnight-ntwrk/ledger-v8';
+import { type NetworkId } from '@midnightntwrk/wallet-sdk-abstractions';
+export type PublicKey = {
+    publicKey: SignatureVerifyingKey;
+    addressHex: UserAddress;
+    address: string;
+};
+export declare const PublicKey: {
+    fromKeyStore: (keystore: UnshieldedKeystore) => PublicKey;
+};
+export interface UnshieldedKeystore {
+    getSecretKey(): Buffer;
+    getBech32Address(): MidnightBech32m;
+    getPublicKey(): SignatureVerifyingKey;
+    getAddress(): UserAddress;
+    signData(data: Uint8Array): Signature;
+}
+export declare const createKeystore: (secretKey: Uint8Array<ArrayBufferLike>, networkId: NetworkId.NetworkId) => UnshieldedKeystore;

package/dist/KeyStore.js

@@ -0,0 +1,37 @@
+// 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 { UnshieldedAddress } from '@midnightntwrk/wallet-sdk-address-format';
+import { addressFromKey, signData, signatureVerifyingKey, } from '@midnight-ntwrk/ledger-v8';
+export const PublicKey = {
+    fromKeyStore: (keystore) => {
+        return {
+            publicKey: keystore.getPublicKey(),
+            addressHex: keystore.getAddress(),
+            address: keystore.getBech32Address().asString(),
+        };
+    },
+};
+export const createKeystore = (secretKey, networkId) => {
+    const keystore = {
+        getSecretKey: () => Buffer.from(secretKey),
+        getBech32Address: () => {
+            const address = keystore.getAddress();
+            const addressBuffer = Buffer.from(address, 'hex');
+            return UnshieldedAddress.codec.encode(networkId, new UnshieldedAddress(addressBuffer));
+        },
+        getPublicKey: () => signatureVerifyingKey(keystore.getSecretKey().toString('hex')),
+        getAddress: () => addressFromKey(keystore.getPublicKey()),
+        signData: (data) => signData(keystore.getSecretKey().toString('hex'), data),
+    };
+    return keystore;
+};

package/dist/UnshieldedWallet.d.ts

@@ -0,0 +1,72 @@
+import { type ProtocolState, ProtocolVersion } from '@midnightntwrk/wallet-sdk-abstractions';
+import { type BaseV1Configuration, type DefaultV1Configuration, type V1Variant, CoreWallet, type UnboundTransaction } from './v1/index.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import * as rx from 'rxjs';
+import { type SerializationCapability } from './v1/Serialization.js';
+import { type TransactionHistoryService } from './v1/TransactionHistory.js';
+import { type CoinsAndBalancesCapability } from './v1/CoinsAndBalances.js';
+import { type KeysCapability } from './v1/Keys.js';
+import { type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './v1/Transacting.js';
+import { type WalletSyncUpdate } from './v1/SyncSchema.js';
+import { type UtxoWithMeta } from './v1/UnshieldedState.js';
+import { type Variant, type VariantBuilder, type WalletLike } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
+import { type PublicKey } from './KeyStore.js';
+import { type SyncProgress } from './v1/SyncProgress.js';
+import { type UnshieldedAddress } from '@midnightntwrk/wallet-sdk-address-format';
+export type UnshieldedWalletCapabilities<TSerialized = string> = {
+    serialization: SerializationCapability<CoreWallet, TSerialized>;
+    coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
+    keys: KeysCapability<CoreWallet>;
+};
+export type UnshieldedWalletServices = {
+    transactionHistory: TransactionHistoryService;
+};
+export declare class UnshieldedWalletState<TSerialized = string> {
+    static readonly mapState: <TSerialized_1 = string>(variant: UnshieldedWalletCapabilities<TSerialized_1> & UnshieldedWalletServices) => (state: ProtocolState.ProtocolState<CoreWallet>) => UnshieldedWalletState<TSerialized_1>;
+    readonly protocolVersion: ProtocolVersion.ProtocolVersion;
+    readonly state: CoreWallet;
+    readonly capabilities: UnshieldedWalletCapabilities<TSerialized>;
+    readonly services: UnshieldedWalletServices;
+    get balances(): Record<ledger.RawTokenType, bigint>;
+    get totalCoins(): readonly UtxoWithMeta[];
+    get availableCoins(): readonly UtxoWithMeta[];
+    get pendingCoins(): readonly UtxoWithMeta[];
+    get address(): UnshieldedAddress;
+    get progress(): SyncProgress;
+    constructor(state: ProtocolState.ProtocolState<CoreWallet>, capabilities: UnshieldedWalletCapabilities<TSerialized>, services: UnshieldedWalletServices);
+    serialize(): TSerialized;
+}
+export type UnshieldedWallet = CustomizedUnshieldedWallet<WalletSyncUpdate, string>;
+export type DefaultUnshieldedConfiguration = DefaultV1Configuration;
+export type UnshieldedWalletClass = CustomizedUnshieldedWalletClass<WalletSyncUpdate, string, DefaultUnshieldedConfiguration>;
+export type UnshieldedWalletAPI<TSerialized = string> = {
+    readonly state: rx.Observable<UnshieldedWalletState<TSerialized>>;
+    start(): Promise<void>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Promise<FinalizedTransactionBalanceResult>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Promise<UnboundTransactionBalanceResult>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Promise<UnprovenTransactionBalanceResult>;
+    transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    /**
+     * Books a caller-supplied set of Night UTxOs and returns an unproven transaction that moves them back to the same
+     * owner, split between the guaranteed (segment 0) and fallible (segment 1) sections of a single intent. Booking moves
+     * the UTxOs from available to pending so a concurrent build call cannot reuse them. The fallible section is available
+     * for callers that want to attach further actions (e.g. a Dust registration) at segment 1.
+     */
+    rotateUtxos(guaranteedUtxos: readonly UtxoWithMeta[], fallibleUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Promise<ledger.UnprovenTransaction>;
+    initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
+    serializeState(): Promise<TSerialized>;
+    waitForSyncedState(allowedGap?: bigint): Promise<UnshieldedWalletState<TSerialized>>;
+    revertTransaction(transaction: ledger.Transaction<ledger.Signaturish, ledger.Proofish, ledger.Bindingish>): Promise<void>;
+    getAddress(): Promise<UnshieldedAddress>;
+    stop(): Promise<void>;
+};
+export type CustomizedUnshieldedWallet<TSyncUpdate = WalletSyncUpdate, TSerialized = string> = UnshieldedWalletAPI<TSerialized> & WalletLike.WalletLike<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]>;
+export interface CustomizedUnshieldedWalletClass<TSyncUpdate = WalletSyncUpdate, TSerialized = string, TConfig extends BaseV1Configuration = DefaultV1Configuration> extends WalletLike.BaseWalletClass<[Variant.VersionedVariant<V1Variant<TSerialized, TSyncUpdate>>]> {
+    configuration: TConfig;
+    startWithPublicKey(publicKey: PublicKey): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
+    restore(serializedState: TSerialized): CustomizedUnshieldedWallet<TSyncUpdate, TSerialized>;
+}
+export declare function UnshieldedWallet(configuration: DefaultV1Configuration): UnshieldedWalletClass;
+export declare function CustomUnshieldedWallet<TConfig extends BaseV1Configuration = DefaultV1Configuration, TSyncUpdate = WalletSyncUpdate, TSerialized = string>(configuration: TConfig, builder: VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate>, TConfig>): CustomizedUnshieldedWalletClass<TSyncUpdate, TSerialized, TConfig>;

package/dist/UnshieldedWallet.js

@@ -0,0 +1,156 @@
+// 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 { Effect, Either } from 'effect';
+import * as rx from 'rxjs';
+import { WalletBuilder } from '@midnightntwrk/wallet-sdk-runtime';
+export class UnshieldedWalletState {
+    static mapState = (variant) => (state) => {
+        const { serialization, coinsAndBalances, keys } = variant;
+        const { transactionHistory } = variant;
+        return new UnshieldedWalletState(state, { serialization, coinsAndBalances, keys }, { transactionHistory });
+    };
+    protocolVersion;
+    state;
+    capabilities;
+    services;
+    get balances() {
+        return this.capabilities.coinsAndBalances.getAvailableBalances(this.state);
+    }
+    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;
+    }
+    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 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);
+        }
+        balanceFinalizedTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceFinalizedTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnboundTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnboundTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        balanceUnprovenTransaction(tx) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.balanceUnprovenTransaction(tx),
+            })
+                .pipe(Effect.runPromise);
+        }
+        transferTransaction(outputs, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.transferTransaction(outputs, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
+        rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
+        initSwap(desiredInputs, desiredOutputs, ttl) {
+            return this.runtime
+                .dispatch({ [V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl) })
+                .pipe(Effect.runPromise);
+        }
+        signUnprovenTransaction(transaction, signSegment) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.signUnprovenTransaction(transaction, signSegment),
+            })
+                .pipe(Effect.runPromise);
+        }
+        signUnboundTransaction(transaction, signSegment) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.signUnboundTransaction(transaction, signSegment),
+            })
+                .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 [[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

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

package/dist/index.js

@@ -0,0 +1,15 @@
+// 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 './UnshieldedWallet.js';
+export { UnshieldedSectionSchema } from './v1/TransactionHistory.js';
+export * from './KeyStore.js';

package/dist/v1/CoinsAndBalances.d.ts

@@ -0,0 +1,13 @@
+import { type CoreWallet } from './CoreWallet.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { type UtxoWithMeta } from './UnshieldedState.js';
+export type Balances = Record<ledger.RawTokenType, bigint>;
+export type CoinsAndBalancesCapability<TState> = {
+    getAvailableBalances(state: TState): Balances;
+    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 '@midnightntwrk/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 '@midnightntwrk/wallet-sdk-abstractions';
+import { type SyncProgress, type SyncProgressData } from './SyncProgress.js';
+import { type PublicKey } from '../KeyStore.js';
+import { UnshieldedState, type UnshieldedUpdate } from './UnshieldedState.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { Either } from 'effect';
+import { type 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) 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 { 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 '@midnightntwrk/wallet-sdk-address-format';
+import type { CoreWallet } from './CoreWallet.js';
+import { type SignatureVerifyingKey } from '@midnight-ntwrk/ledger-v8';
+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) 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 '@midnightntwrk/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,48 @@
+import { Effect, Scope, Stream } from 'effect';
+import { type WalletRuntimeError, type Variant, StateChange } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
+import { type SerializationCapability } from './Serialization.js';
+import { type SyncCapability, type SyncService } from './Sync.js';
+import { type WalletSyncUpdate } from './SyncSchema.js';
+import { type TransactingCapability, type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './Transacting.js';
+import { type UtxoWithMeta } from './UnshieldedState.js';
+import { type UnboundTransaction } from './TransactionOps.js';
+import { type WalletError } from './WalletError.js';
+import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { type KeysCapability } from './Keys.js';
+import { type CoinSelection } from '@midnightntwrk/wallet-sdk-capabilities';
+import { type CoreWallet } from './CoreWallet.js';
+import { type TransactionHistoryService } from './TransactionHistory.js';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+export declare namespace RunningV1Variant {
+    type Context<TSerialized, TSyncUpdate> = {
+        serializationCapability: SerializationCapability<CoreWallet, TSerialized>;
+        syncService: SyncService<CoreWallet, TSyncUpdate>;
+        syncCapability: SyncCapability<CoreWallet, TSyncUpdate>;
+        transactingCapability: TransactingCapability<CoreWallet>;
+        coinsAndBalancesCapability: CoinsAndBalancesCapability<CoreWallet>;
+        keysCapability: KeysCapability<CoreWallet>;
+        coinSelection: CoinSelection<ledger.Utxo>;
+        transactionHistoryService: TransactionHistoryService;
+    };
+    type AnyContext = Context<any, any>;
+}
+export declare const V1Tag: unique symbol;
+export type DefaultRunningV1 = RunningV1Variant<string, WalletSyncUpdate>;
+export declare class RunningV1Variant<TSerialized, TSyncUpdate> 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>);
+    startSyncInBackground(): Effect.Effect<void>;
+    startSync(): Stream.Stream<void, WalletError, Scope.Scope>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction): Effect.Effect<FinalizedTransactionBalanceResult, WalletError>;
+    balanceUnboundTransaction(tx: UnboundTransaction): Effect.Effect<UnboundTransactionBalanceResult, WalletError>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Effect.Effect<UnprovenTransactionBalanceResult, WalletError>;
+    transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    rotateUtxos(guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<UnboundTransaction, WalletError>;
+    revertTransaction(transaction: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>): Effect.Effect<void, WalletError>;
+    serializeState(state: CoreWallet): TSerialized;
+}