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

package/dist/v1/Transaction.js

@@ -0,0 +1,76 @@
+// 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 { pipe } from 'effect';
+import { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
+export const TransactionTrait = new (class {
+    default = {
+        getImbalances(tx) {
+            return TransactionTrait.shared.getImbalances(tx);
+        },
+        id(tx) {
+            return tx.identifiers().at(0);
+        },
+    };
+    proofErased = {
+        getImbalances(tx) {
+            return TransactionTrait.shared.getImbalances(tx);
+        },
+        id(tx) {
+            return tx.identifiers().at(0);
+        },
+    };
+    unproven = {
+        getImbalances(tx) {
+            return TransactionTrait.shared.getImbalances(tx);
+        },
+        id(tx) {
+            return tx.identifiers().at(0);
+        },
+    };
+    shared = {
+        getImbalances(tx) {
+            const guaranteedImbalances = TransactionTrait.shared.getGuaranteedImbalances(tx);
+            const fallibleImbalances = TransactionTrait.shared.getFallibleImbalances(tx);
+            return pipe({
+                guaranteed: guaranteedImbalances,
+                fallible: fallibleImbalances,
+                fees: 0n,
+            });
+        },
+        getGuaranteedImbalances: (tx) => {
+            const rawGuaranteedImbalances = tx
+                .imbalances(0)
+                .entries()
+                .filter(([token]) => token.tag === 'shielded')
+                .map(([token, value]) => {
+                return [token.raw.toString(), value];
+            });
+            return Imbalances.fromEntries(rawGuaranteedImbalances);
+        },
+        getFallibleImbalances: (tx) => {
+            try {
+                const rawFallibleImbalances = tx
+                    .imbalances(1)
+                    .entries()
+                    .filter(([token]) => token.tag === 'shielded')
+                    .map(([token, value]) => {
+                    return [token.raw.toString(), value];
+                });
+                return Imbalances.fromEntries(rawFallibleImbalances);
+            }
+            catch {
+                return Imbalances.empty();
+            }
+        },
+    };
+})();

package/dist/v1/TransactionHistory.d.ts

@@ -0,0 +1,16 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { CoreWallet } from './CoreWallet.js';
+export type ProgressUpdate = {
+    appliedIndex: bigint | undefined;
+    highestRelevantWalletIndex: bigint | undefined;
+    highestIndex: bigint | undefined;
+    highestRelevantIndex: bigint | undefined;
+};
+export type TransactionHistoryCapability<TState, TTransaction> = {
+    updateTxHistory(state: TState, newTxs: TTransaction[]): TState;
+    transactionHistory(state: TState): readonly TTransaction[];
+    progress(state: TState): ProgressUpdate;
+};
+export declare const makeDefaultTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;
+export declare const makeSimulatorTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.ProofErasedTransaction>;
+export declare const makeDiscardTransactionHistoryCapability: () => TransactionHistoryCapability<CoreWallet, ledger.FinalizedTransaction>;

package/dist/v1/TransactionHistory.js

@@ -0,0 +1,55 @@
+import { CoreWallet } from './CoreWallet.js';
+export const makeDefaultTransactionHistoryCapability = () => {
+    return {
+        updateTxHistory: (state, newTxs) => {
+            return newTxs.reduce((acc, tx) => CoreWallet.addTransaction(acc, tx), state);
+        },
+        transactionHistory: (state) => {
+            return state.txHistoryArray;
+        },
+        progress: (state) => {
+            return {
+                appliedIndex: state.progress.appliedIndex,
+                highestRelevantWalletIndex: state.progress.highestRelevantWalletIndex,
+                highestIndex: state.progress.highestIndex,
+                highestRelevantIndex: state.progress.highestRelevantIndex,
+            };
+        },
+    };
+};
+export const makeSimulatorTransactionHistoryCapability = () => {
+    return {
+        updateTxHistory: (state, newTxs) => {
+            return CoreWallet.updateTxHistory(state, newTxs); // @TODO fix this cast
+        },
+        transactionHistory: (state) => {
+            return state.txHistoryArray; // @TODO fix this cast
+        },
+        progress: (state) => {
+            return {
+                appliedIndex: state.progress.appliedIndex,
+                highestRelevantWalletIndex: state.progress.highestRelevantWalletIndex,
+                highestIndex: state.progress.highestIndex,
+                highestRelevantIndex: state.progress.highestRelevantIndex,
+            };
+        },
+    };
+};
+export const makeDiscardTransactionHistoryCapability = () => {
+    return {
+        updateTxHistory: (state) => {
+            return state;
+        },
+        transactionHistory: (state) => {
+            return state.txHistoryArray;
+        },
+        progress: (state) => {
+            return {
+                appliedIndex: state.progress.appliedIndex,
+                highestRelevantWalletIndex: state.progress.highestRelevantWalletIndex,
+                highestIndex: state.progress.highestIndex,
+                highestRelevantIndex: state.progress.highestRelevantIndex,
+            };
+        },
+    };
+};

package/dist/v1/TransactionImbalances.d.ts

@@ -0,0 +1,10 @@
+import { Imbalances, TransactionCostModel } from '@midnight-ntwrk/wallet-sdk-capabilities';
+export declare const ShieldedCostModel: TransactionCostModel;
+export type TransactionImbalances = Readonly<{
+    guaranteed: Imbalances;
+    fallible: Imbalances;
+}>;
+export declare const TransactionImbalances: {
+    empty: () => TransactionImbalances;
+    areBalanced: (imbalances: TransactionImbalances) => boolean;
+};

package/dist/v1/TransactionImbalances.js

@@ -0,0 +1,30 @@
+// 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 { Imbalances } from '@midnight-ntwrk/wallet-sdk-capabilities';
+export const ShieldedCostModel = {
+    inputFeeOverhead: 0n,
+    outputFeeOverhead: 0n,
+};
+export const TransactionImbalances = new (class {
+    empty = () => {
+        return {
+            guaranteed: Imbalances.empty(),
+            fallible: Imbalances.empty(),
+        };
+    };
+    areBalanced = (imbalances) => {
+        const areFallibleAllZeroes = imbalances.fallible.entries().every(([, value]) => value === 0n);
+        const areGuaranteedAllZeroes = imbalances.guaranteed.entries().every(([, value]) => value === 0n);
+        return areFallibleAllZeroes && areGuaranteedAllZeroes;
+    };
+})();

package/dist/v1/V1Builder.d.ts

@@ -0,0 +1,109 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { Either, Types } from 'effect';
+import { NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { Variant, VariantBuilder } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { DefaultProvingConfiguration, ProvingService } from './Proving.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { SerializationCapability } from './Serialization.js';
+import { DefaultSyncContext, DefaultSyncConfiguration, SyncCapability, SyncService, WalletSyncUpdate } from './Sync.js';
+import { DefaultTransactingConfiguration, DefaultTransactingContext, TransactingCapability } from './Transacting.js';
+import { WalletError } from './WalletError.js';
+import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { KeysCapability } from './Keys.js';
+import { DefaultSubmissionConfiguration, SubmissionService } from './Submission.js';
+import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet } from './CoreWallet.js';
+import { TransactionHistoryCapability } from './TransactionHistory.js';
+export type BaseV1Configuration = {
+    networkId: NetworkId.NetworkId;
+};
+export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultProvingConfiguration & DefaultTransactingConfiguration & DefaultSubmissionConfiguration;
+declare const V1BuilderSymbol: {
+    readonly typeId: unique symbol;
+};
+export type V1Variant<TSerialized, TSyncUpdate, TTransaction, TAuxData> = Variant.Variant<typeof V1Tag, CoreWallet, null, RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TAuxData>> & {
+    deserializeState: (serialized: TSerialized) => Either.Either<CoreWallet, WalletError>;
+    coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
+    keys: KeysCapability<CoreWallet>;
+    serialization: SerializationCapability<CoreWallet, null, TSerialized>;
+    transactionHistory: TransactionHistoryCapability<CoreWallet, TTransaction>;
+};
+export type AnyV1Variant = V1Variant<any, any, any, any>;
+export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate, ledger.FinalizedTransaction, ledger.ZswapSecretKeys>;
+export type TransactionOf<T extends AnyV1Variant> = T extends V1Variant<any, any, infer TTransaction, any> ? TTransaction : never;
+export type AuxDataOf<T extends AnyV1Variant> = T extends V1Variant<any, any, any, infer TAuxData> ? TAuxData : never;
+export type SerializedStateOf<T extends AnyV1Variant> = T extends V1Variant<infer TSerialized, any, any, any> ? TSerialized : never;
+export type DefaultV1Builder = V1Builder<DefaultV1Configuration, RunningV1Variant.Context<string, WalletSyncUpdate, ledger.FinalizedTransaction, ledger.ZswapSecretKeys>, string, WalletSyncUpdate, ledger.FinalizedTransaction, ledger.ZswapSecretKeys>;
+export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Configuration, TContext extends Partial<RunningV1Variant.AnyContext> = object, TSerialized = never, TSyncUpdate = never, TTransaction = never, TStartAux extends object = object> implements VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TConfig> {
+    #private;
+    constructor(buildState?: V1Builder.PartialBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>);
+    withDefaults(): DefaultV1Builder;
+    withTransactionType<Transaction>(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, Transaction, TStartAux>;
+    withDefaultTransactionType(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext & DefaultSyncContext, TSerialized, WalletSyncUpdate, TTransaction, ledger.ZswapSecretKeys>;
+    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate, TStartAux extends object>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TStartAux, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withSerializationDefaults(): V1Builder<TConfig, TContext, string, TSyncUpdate, TTransaction, TStartAux>;
+    withSerialization<TSerializationConfig, TSerializationContext extends Partial<RunningV1Variant.AnyContext>, TSerialized>(serializationCapability: (configuration: TSerializationConfig, getContext: () => TSerializationContext) => SerializationCapability<CoreWallet, null, TSerialized>): V1Builder<TConfig & TSerializationConfig, TContext & TSerializationContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withTransactingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    withTransacting<TTransactingConfig, TTransactingContext extends Partial<RunningV1Variant.AnyContext>>(transactingCapability: (config: TTransactingConfig, getContext: () => TTransactingContext) => TransactingCapability<ledger.ZswapSecretKeys, CoreWallet, TTransaction>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection<ledger.QualifiedShieldedCoinInfo>): V1Builder<TConfig & TCoinSelectionConfig, TContext & TCoinSelectionContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withProving<TProvingConfig, TProvingContext extends Partial<RunningV1Variant.AnyContext>>(provingService: (config: TProvingConfig, getContext: () => TProvingContext) => ProvingService<TTransaction>): V1Builder<TConfig & TProvingConfig, TContext & TProvingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withProvingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultProvingConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<CoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryCapability: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryCapability<CoreWallet, TTransaction>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withSubmission<TSubmissionConfig, TSubmissionContext extends Partial<RunningV1Variant.AnyContext>>(submissionService: (config: TSubmissionConfig, getContext: () => TSubmissionContext) => SubmissionService<TTransaction>): V1Builder<TConfig & TSubmissionConfig, TContext & TSubmissionContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withSubmissionDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultSubmissionConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction, TStartAux>;
+    build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction, TStartAux>, TSerialized, TSyncUpdate, TTransaction, TStartAux>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+}
+/** @internal */
+declare namespace V1Builder {
+    type HasSync<TConfig, TContext, TSyncUpdate, TStartAux> = {
+        readonly syncService: (configuration: TConfig, getContext: () => TContext) => SyncService<CoreWallet, TStartAux, TSyncUpdate>;
+        readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<CoreWallet, TSyncUpdate>;
+    };
+    type HasTransacting<TConfig, TContext, TTransaction> = {
+        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<ledger.ZswapSecretKeys, CoreWallet, TTransaction>;
+    };
+    type HasCoinSelection<TConfig, TContext> = {
+        readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection<ledger.QualifiedShieldedCoinInfo>;
+    };
+    type HasSerialization<TConfig, TContext, TSerialized> = {
+        readonly serializationCapability: (configuration: TConfig, getContext: () => TContext) => SerializationCapability<CoreWallet, null, TSerialized>;
+    };
+    type HasProving<TConfig, TContext, TTransaction> = {
+        readonly provingService: (configuration: TConfig, getContext: () => TContext) => ProvingService<TTransaction>;
+    };
+    type HasCoinsAndBalances<TConfig, TContext> = {
+        readonly coinsAndBalancesCapability: (configuration: TConfig, getContext: () => TContext) => CoinsAndBalancesCapability<CoreWallet>;
+    };
+    type HasTransactionHistory<TConfig, TContext, TTransaction> = {
+        readonly transactionHistoryCapability: (configuration: TConfig, getContext: () => TContext) => TransactionHistoryCapability<CoreWallet, TTransaction>;
+    };
+    type HasKeys<TConfig, TContext> = {
+        readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<CoreWallet>;
+    };
+    type HasSubmission<TConfig, TContext, TTransaction> = {
+        readonly submissionService: (configuration: TConfig, getContext: () => TContext) => SubmissionService<TTransaction>;
+    };
+    /**
+     * The internal build state of {@link V1Builder}.
+     */
+    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasProving<TConfig, TContext, TTransaction> & HasSubmission<TConfig, TContext, TTransaction> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext, TTransaction>>;
+    type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never, TTransaction = never, TStartAux = object> = {
+        [K in keyof FullBuildState<never, never, never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>[K] | undefined;
+    };
+    /**
+     * Utility interface that manages the type variance of {@link V1Builder}.
+     */
+    interface Variance<R> {
+        readonly [V1BuilderSymbol.typeId]: {
+            readonly _R: Types.Covariant<R>;
+        };
+    }
+}
+export {};

package/dist/v1/V1Builder.js

@@ -0,0 +1,201 @@
+// 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 { Effect, Scope } from 'effect';
+import { WalletSeed } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { makeDefaultProvingService } from './Proving.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { makeDefaultV1SerializationCapability } from './Serialization.js';
+import { makeEventsSyncService, makeEventsSyncCapability, } from './Sync.js';
+import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { makeDefaultKeysCapability } from './Keys.js';
+import { makeDefaultSubmissionService } from './Submission.js';
+import { chooseCoin } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet, PublicKeys } from './CoreWallet.js';
+import { makeDefaultTransactionHistoryCapability } from './TransactionHistory.js';
+const V1BuilderSymbol = {
+    typeId: Symbol('@midnight-ntwrk/wallet#V1Builder'),
+};
+export class V1Builder {
+    #buildState;
+    constructor(buildState = {}) {
+        this.#buildState = buildState;
+    }
+    withDefaults() {
+        return this.withDefaultTransactionType()
+            .withSyncDefaults()
+            .withSerializationDefaults()
+            .withTransactingDefaults()
+            .withCoinsAndBalancesDefaults()
+            .withTransactionHistoryDefaults()
+            .withKeysDefaults()
+            .withProvingDefaults()
+            .withSubmissionDefaults()
+            .withCoinSelectionDefaults();
+    }
+    withTransactionType() {
+        return new V1Builder({
+            ...this.#buildState,
+            provingService: undefined,
+            transactingCapability: undefined,
+            submissionService: undefined,
+            transactionHistoryCapability: undefined,
+        });
+    }
+    withDefaultTransactionType() {
+        return this.withTransactionType();
+    }
+    withSyncDefaults() {
+        return this.withSync(makeEventsSyncService, makeEventsSyncCapability);
+    }
+    withSync(syncService, syncCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            syncService,
+            syncCapability,
+        });
+    }
+    withSerializationDefaults() {
+        return this.withSerialization(makeDefaultV1SerializationCapability);
+    }
+    withSerialization(serializationCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            serializationCapability,
+        });
+    }
+    withTransactingDefaults() {
+        return this.withTransacting(makeDefaultTransactingCapability);
+    }
+    withTransacting(transactingCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            transactingCapability,
+        });
+    }
+    withCoinSelection(coinSelection) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinSelection,
+        });
+    }
+    withCoinSelectionDefaults() {
+        return this.withCoinSelection(() => chooseCoin);
+    }
+    withProving(provingService) {
+        return new V1Builder({
+            ...this.#buildState,
+            provingService,
+        });
+    }
+    withProvingDefaults() {
+        return this.withProving(makeDefaultProvingService);
+    }
+    withCoinsAndBalancesDefaults() {
+        return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+    }
+    withCoinsAndBalances(coinsAndBalancesCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinsAndBalancesCapability,
+        });
+    }
+    withTransactionHistoryDefaults() {
+        return this.withTransactionHistory(makeDefaultTransactionHistoryCapability);
+    }
+    withTransactionHistory(transactionHistoryCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            transactionHistoryCapability,
+        });
+    }
+    withKeysDefaults() {
+        return this.withKeys(makeDefaultKeysCapability);
+    }
+    withKeys(keysCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            keysCapability,
+        });
+    }
+    withSubmission(submissionService) {
+        return new V1Builder({
+            ...this.#buildState,
+            submissionService,
+        });
+    }
+    withSubmissionDefaults() {
+        return this.withSubmission(makeDefaultSubmissionService);
+    }
+    build(configuration) {
+        const v1Context = this.#buildContextFromBuildState(configuration);
+        const { networkId } = configuration;
+        return {
+            __polyTag__: V1Tag,
+            coinsAndBalances: v1Context.coinsAndBalancesCapability,
+            keys: v1Context.keysCapability,
+            serialization: v1Context.serializationCapability,
+            transactionHistory: v1Context.transactionHistoryCapability,
+            start(context) {
+                return Effect.gen(function* () {
+                    yield* Effect.addFinalizer(() => v1Context.submissionService.close());
+                    const scope = yield* Scope.Scope;
+                    return new RunningV1Variant(scope, context, v1Context);
+                });
+            },
+            migrateState(_previousState) {
+                const seed = WalletSeed.fromString('0000000000000000000000000000000000000000000000000000000000000001');
+                return Effect.succeed(CoreWallet.empty(PublicKeys.fromSecretKeys(ledger.ZswapSecretKeys.fromSeed(seed)), networkId));
+            },
+            deserializeState: (serialized) => {
+                return v1Context.serializationCapability.deserialize(null, serialized);
+            },
+        };
+    }
+    #buildContextFromBuildState(configuration) {
+        if (!isBuildStateFull(this.#buildState)) {
+            throw new Error('Not all components are configured in V1 Builder');
+        }
+        const { syncCapability, syncService, transactingCapability, serializationCapability, provingService, coinSelection, coinsAndBalancesCapability, keysCapability, submissionService, transactionHistoryCapability, } = this.#buildState;
+        const getContext = () => context;
+        const context = {
+            serializationCapability: serializationCapability(configuration, getContext),
+            syncCapability: syncCapability(configuration, getContext),
+            syncService: syncService(configuration, getContext),
+            transactingCapability: transactingCapability(configuration, getContext),
+            coinsAndBalancesCapability: coinsAndBalancesCapability(configuration, getContext),
+            keysCapability: keysCapability(configuration, getContext),
+            provingService: provingService(configuration, getContext),
+            coinSelection: coinSelection(configuration, getContext),
+            submissionService: submissionService(configuration, getContext),
+            transactionHistoryCapability: transactionHistoryCapability(configuration, getContext),
+        };
+        return context;
+    }
+}
+const isBuildStateFull = (buildState) => {
+    const allBuildStateKeys = [
+        'syncService',
+        'syncCapability',
+        'transactingCapability',
+        'coinSelection',
+        'serializationCapability',
+        'provingService',
+        'coinsAndBalancesCapability',
+        'keysCapability',
+        'submissionService',
+        'transactionHistoryCapability',
+    ];
+    return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');
+};

package/dist/v1/WalletError.d.ts

@@ -0,0 +1,75 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+export declare const WalletError: {
+    proving(err: Error): WalletError;
+    other(err: unknown): WalletError;
+    submission(err: unknown): WalletError;
+};
+export type WalletError = ProvingError | OtherWalletError | InsufficientFundsError | SubmissionError | AddressError | SyncWalletError | InvalidCoinHashesError | TransactingError | LedgerOps.LedgerError;
+declare const ProvingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Proving";
+} & Readonly<A>;
+export declare class ProvingError extends ProvingError_base<{
+    message: string;
+    cause: Error;
+}> {
+}
+declare const OtherWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Other";
+} & Readonly<A>;
+export declare class OtherWalletError extends OtherWalletError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const SyncWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Sync";
+} & Readonly<A>;
+export declare class SyncWalletError extends SyncWalletError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const SubmissionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.SubmissionWalletError";
+} & Readonly<A>;
+export declare class SubmissionError extends SubmissionError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const InsufficientFundsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.InsufficientFunds";
+} & Readonly<A>;
+export declare class InsufficientFundsError extends InsufficientFundsError_base<{
+    message: string;
+    tokenType: ledger.RawTokenType;
+    amount: bigint;
+}> {
+}
+declare const AddressError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Address";
+} & Readonly<A>;
+export declare class AddressError extends AddressError_base<{
+    message: string;
+    originalAddress: string;
+    cause?: unknown;
+}> {
+}
+declare const InvalidCoinHashesError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.InvalidCoinHashes";
+} & Readonly<A>;
+export declare class InvalidCoinHashesError extends InvalidCoinHashesError_base<{
+    message: string;
+    missingNonces: Set<ledger.Nonce>;
+}> {
+}
+declare const TransactingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.Transacting";
+} & Readonly<A>;
+export declare class TransactingError extends TransactingError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export {};

package/dist/v1/WalletError.js

@@ -0,0 +1,59 @@
+// 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 { Data } from 'effect';
+export const WalletError = {
+    proving(err) {
+        return new ProvingError({
+            message: `Wallet proving error: ${err.message}`,
+            cause: err,
+        });
+    },
+    other(err) {
+        let message;
+        if (err) {
+            if (typeof err == 'object' && 'message' in err) {
+                message = String(err.message);
+            }
+            else if (typeof err == 'string') {
+                message = err;
+            }
+            else {
+                message = '';
+            }
+        }
+        else {
+            message = '';
+        }
+        return new OtherWalletError({ message: `Other wallet error: ${message}`, cause: err });
+    },
+    submission(err) {
+        const message = err && typeof err == 'object' && 'message' in err ? String(err.message) : '';
+        return new SubmissionError({ message: `Transaction submission error: ${message}`, cause: err });
+    },
+};
+export class ProvingError extends Data.TaggedError('Wallet.Proving') {
+}
+export class OtherWalletError extends Data.TaggedError('Wallet.Other') {
+}
+export class SyncWalletError extends Data.TaggedError('Wallet.Sync') {
+}
+export class SubmissionError extends Data.TaggedError('Wallet.SubmissionWalletError') {
+}
+export class InsufficientFundsError extends Data.TaggedError('Wallet.InsufficientFunds') {
+}
+export class AddressError extends Data.TaggedError('Wallet.Address') {
+}
+export class InvalidCoinHashesError extends Data.TaggedError('Wallet.InvalidCoinHashes') {
+}
+export class TransactingError extends Data.TaggedError('Wallet.Transacting') {
+}

package/dist/v1/index.d.ts

@@ -0,0 +1,16 @@
+export * from './V1Builder.js';
+export * as Sync from './Sync.js';
+export * as SyncProgress from './SyncProgress.js';
+export * as Transacting from './Transacting.js';
+export * as TransactionHistory from './TransactionHistory.js';
+export * as Serialization from './Serialization.js';
+export * as Proving from './Proving.js';
+export * as ProvingRecipe from './ProvingRecipe.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';
+export * as Keys from './Keys.js';
+export * from './RunningV1Variant.js';
+export * as Simulator from './Simulator.js';
+export * as Submission from './Submission.js';
+export * as WalletError from './WalletError.js';
+export * from './CoreWallet.js';
+export * from './Transaction.js';