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

package/dist/v1/V1Builder.d.ts

@@ -0,0 +1,97 @@
+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 { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { SerializationCapability } from './Serialization.js';
+import { DefaultSyncContext, DefaultSyncConfiguration, SyncCapability, SyncService } from './Sync.js';
+import { WalletSyncUpdate, UnshieldedUpdate } from './SyncSchema.js';
+import { DefaultTransactingConfiguration, DefaultTransactingContext, TransactingCapability } from './Transacting.js';
+import { WalletError } from './WalletError.js';
+import { CoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { KeysCapability } from './Keys.js';
+import { CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet } from './CoreWallet.js';
+import { DefaultTransactionHistoryConfiguration, TransactionHistoryService } from './TransactionHistory.js';
+export type BaseV1Configuration = {
+    networkId: NetworkId.NetworkId;
+};
+export type DefaultV1Configuration = BaseV1Configuration & DefaultSyncConfiguration & DefaultTransactingConfiguration & DefaultTransactionHistoryConfiguration;
+declare const V1BuilderSymbol: {
+    readonly typeId: unique symbol;
+};
+export type V1Variant<TSerialized, TSyncUpdate, TTransaction> = Variant.Variant<typeof V1Tag, CoreWallet, null, RunningV1Variant<TSerialized, TSyncUpdate, TTransaction>> & {
+    deserializeState: (serialized: TSerialized) => Either.Either<CoreWallet, WalletError>;
+    coinsAndBalances: CoinsAndBalancesCapability<CoreWallet>;
+    keys: KeysCapability<CoreWallet>;
+    serialization: SerializationCapability<CoreWallet, TSerialized>;
+    transactionHistory: TransactionHistoryService<UnshieldedUpdate>;
+};
+export type AnyV1Variant = V1Variant<any, any, any>;
+export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+export type TransactionOf<T extends AnyV1Variant> = T extends V1Variant<any, any, infer TTransaction> ? TTransaction : never;
+export type SerializedStateOf<T extends AnyV1Variant> = T extends V1Variant<infer TSerialized, any, any> ? TSerialized : never;
+export type DefaultV1Builder = V1Builder<DefaultV1Configuration, RunningV1Variant.Context<string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>, string, WalletSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+export declare class V1Builder<TConfig extends BaseV1Configuration = BaseV1Configuration, TContext extends Partial<RunningV1Variant.AnyContext> = object, TSerialized = never, TSyncUpdate = never, TTransaction = never> implements VariantBuilder.VariantBuilder<V1Variant<TSerialized, TSyncUpdate, TTransaction>, TConfig> {
+    #private;
+    constructor(buildState?: V1Builder.PartialBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>);
+    withDefaults(): DefaultV1Builder;
+    withTransactionType<Transaction>(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, Transaction>;
+    withDefaultTransactionType(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+    withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext & DefaultSyncContext, TSerialized, WalletSyncUpdate, TTransaction>;
+    withSync<TSyncConfig, TSyncContext extends Partial<RunningV1Variant.AnyContext>, TSyncUpdate>(syncService: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncService<CoreWallet, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<CoreWallet, TSyncUpdate>): V1Builder<TConfig & TSyncConfig, TContext & TSyncContext, TSerialized, TSyncUpdate, TTransaction>;
+    withSerializationDefaults(): V1Builder<TConfig, TContext, string, TSyncUpdate, TTransaction>;
+    withSerialization<TSerializationConfig, TSerializationContext extends Partial<RunningV1Variant.AnyContext>, TSerialized>(serializationCapability: (configuration: TSerializationConfig, getContext: () => TSerializationContext) => SerializationCapability<CoreWallet, TSerialized>): V1Builder<TConfig & TSerializationConfig, TContext & TSerializationContext, TSerialized, TSyncUpdate, TTransaction>;
+    withTransactingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate, ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>>;
+    withTransacting<TTransactingConfig, TTransactingContext extends Partial<RunningV1Variant.AnyContext>>(transactingCapability: (config: TTransactingConfig, getContext: () => TTransactingContext) => TransactingCapability<TTransaction, CoreWallet>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate, TTransaction>;
+    withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection<ledger.Utxo>): V1Builder<TConfig & TCoinSelectionConfig, TContext & TCoinSelectionContext, TSerialized, TSyncUpdate, TTransaction>;
+    withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
+    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
+    withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<CoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, TSerialized, TSyncUpdate, TTransaction>;
+    withTransactionHistoryDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction>): V1Builder<TConfig & DefaultTransactionHistoryConfiguration, TContext, TSerialized, TSyncUpdate, ledger.FinalizedTransaction>;
+    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryService: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryService<UnshieldedUpdate>): V1Builder<TConfig & TTransactionHistoryConfig, TContext & TTransactionHistoryContext, TSerialized, TSyncUpdate, TTransaction>;
+    withKeysDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>;
+    withKeys<TKeysConfig, TKeysContext extends Partial<RunningV1Variant.AnyContext>>(keysCapability: (configuration: TKeysConfig, getContext: () => TKeysContext) => KeysCapability<CoreWallet>): V1Builder<TConfig & TKeysConfig, TContext & TKeysContext, TSerialized, TSyncUpdate, TTransaction>;
+    build(this: V1Builder<TConfig, RunningV1Variant.Context<TSerialized, TSyncUpdate, TTransaction>, TSerialized, TSyncUpdate, TTransaction>, configuration: TConfig): V1Variant<TSerialized, TSyncUpdate, TTransaction>;
+}
+/** @internal */
+declare namespace V1Builder {
+    type HasSync<TConfig, TContext, TSyncUpdate> = {
+        readonly syncService: (configuration: TConfig, getContext: () => TContext) => SyncService<CoreWallet, TSyncUpdate>;
+        readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<CoreWallet, TSyncUpdate>;
+    };
+    type HasTransacting<TConfig, TContext, TTransaction> = {
+        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<TTransaction, CoreWallet>;
+    };
+    type HasCoinSelection<TConfig, TContext> = {
+        readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection<ledger.Utxo>;
+    };
+    type HasSerialization<TConfig, TContext, TSerialized> = {
+        readonly serializationCapability: (configuration: TConfig, getContext: () => TContext) => SerializationCapability<CoreWallet, TSerialized>;
+    };
+    type HasCoinsAndBalances<TConfig, TContext> = {
+        readonly coinsAndBalancesCapability: (configuration: TConfig, getContext: () => TContext) => CoinsAndBalancesCapability<CoreWallet>;
+    };
+    type HasTransactionHistory<TConfig, TContext> = {
+        readonly transactionHistoryService: (configuration: TConfig, getContext: () => TContext) => TransactionHistoryService<UnshieldedUpdate>;
+    };
+    type HasKeys<TConfig, TContext> = {
+        readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<CoreWallet>;
+    };
+    /**
+     * The internal build state of {@link V1Builder}.
+     */
+    type FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate> & HasSerialization<TConfig, TContext, TSerialized> & HasTransacting<TConfig, TContext, TTransaction> & HasCoinSelection<TConfig, TContext> & HasCoinsAndBalances<TConfig, TContext> & HasKeys<TConfig, TContext> & HasTransactionHistory<TConfig, TContext>>;
+    type PartialBuildState<TConfig = object, TContext = object, TSerialized = never, TSyncUpdate = never, TTransaction = never> = {
+        [K in keyof FullBuildState<never, never, never, never, never>]?: FullBuildState<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction>[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,160 @@
+import { Effect, Scope } from 'effect';
+import { WalletSeed } from '@midnight-ntwrk/wallet-sdk-abstractions';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { makeDefaultV1SerializationCapability } from './Serialization.js';
+import { makeDefaultSyncService, makeDefaultSyncCapability, } from './Sync.js';
+import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultCoinsAndBalancesCapability } from './CoinsAndBalances.js';
+import { makeDefaultKeysCapability } from './Keys.js';
+import { chooseCoin } from '@midnight-ntwrk/wallet-sdk-capabilities';
+import { CoreWallet } from './CoreWallet.js';
+import { makeDefaultTransactionHistoryService, } from './TransactionHistory.js';
+import { createKeystore, PublicKey } from '../KeyStore.js';
+const V1BuilderSymbol = {
+    typeId: Symbol('@midnight-ntwrk/unshielded-wallet#V1Builder'),
+};
+export class V1Builder {
+    #buildState;
+    constructor(buildState = {}) {
+        this.#buildState = buildState;
+    }
+    withDefaults() {
+        return this.withDefaultTransactionType()
+            .withSyncDefaults()
+            .withSerializationDefaults()
+            .withTransactingDefaults()
+            .withCoinsAndBalancesDefaults()
+            .withTransactionHistoryDefaults()
+            .withKeysDefaults()
+            .withCoinSelectionDefaults();
+    }
+    withTransactionType() {
+        return new V1Builder({
+            ...this.#buildState,
+            transactingCapability: undefined,
+            transactionHistoryService: undefined,
+        });
+    }
+    withDefaultTransactionType() {
+        return this.withTransactionType();
+    }
+    withSyncDefaults() {
+        return this.withSync(makeDefaultSyncService, makeDefaultSyncCapability);
+    }
+    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);
+    }
+    withCoinsAndBalancesDefaults() {
+        return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+    }
+    withCoinsAndBalances(coinsAndBalancesCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinsAndBalancesCapability,
+        });
+    }
+    withTransactionHistoryDefaults() {
+        return this.withTransactionHistory(makeDefaultTransactionHistoryService);
+    }
+    withTransactionHistory(transactionHistoryService) {
+        return new V1Builder({
+            ...this.#buildState,
+            transactionHistoryService,
+        });
+    }
+    withKeysDefaults() {
+        return this.withKeys(makeDefaultKeysCapability);
+    }
+    withKeys(keysCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            keysCapability,
+        });
+    }
+    build(configuration) {
+        const v1Context = this.#buildContextFromBuildState(configuration);
+        const { networkId } = configuration;
+        return {
+            __polyTag__: V1Tag,
+            coinsAndBalances: v1Context.coinsAndBalancesCapability,
+            keys: v1Context.keysCapability,
+            serialization: v1Context.serializationCapability,
+            transactionHistory: v1Context.transactionHistoryService,
+            start(context) {
+                return Effect.gen(function* () {
+                    const scope = yield* Scope.Scope;
+                    return new RunningV1Variant(scope, context, v1Context);
+                });
+            },
+            migrateState(_previousState) {
+                const seed = WalletSeed.fromString('0000000000000000000000000000000000000000000000000000000000000001');
+                return Effect.succeed(CoreWallet.init(PublicKey.fromKeyStore(createKeystore(seed, networkId)), networkId));
+            },
+            deserializeState: (serialized) => {
+                return v1Context.serializationCapability.deserialize(serialized);
+            },
+        };
+    }
+    #buildContextFromBuildState(configuration) {
+        if (!isBuildStateFull(this.#buildState)) {
+            throw new Error('Not all components are configured in V1 Builder');
+        }
+        const { syncCapability, syncService, transactingCapability, serializationCapability, coinSelection, coinsAndBalancesCapability, keysCapability, transactionHistoryService, } = 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),
+            coinSelection: coinSelection(configuration, getContext),
+            transactionHistoryService: transactionHistoryService(configuration, getContext),
+        };
+        return context;
+    }
+}
+const isBuildStateFull = (buildState) => {
+    const allBuildStateKeys = [
+        'syncService',
+        'syncCapability',
+        'transactingCapability',
+        'coinSelection',
+        'serializationCapability',
+        'coinsAndBalancesCapability',
+        'keysCapability',
+        'transactionHistoryService',
+    ];
+    return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');
+};

package/dist/v1/WalletError.d.ts

@@ -0,0 +1,89 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+export declare const WalletError: {
+    other(err: unknown): WalletError;
+};
+export type WalletError = OtherWalletError | InsufficientFundsError | AddressError | SyncWalletError | TransactingError | SignError | ApplyTransactionError | RollbackUtxoError | SpendUtxoError;
+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 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 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;
+}> {
+}
+declare const SignError_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.Sign";
+} & Readonly<A>;
+export declare class SignError extends SignError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const ApplyTransactionError_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.ApplyTransaction";
+} & Readonly<A>;
+export declare class ApplyTransactionError extends ApplyTransactionError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+declare const RollbackUtxoError_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.RollbackUtxo";
+} & Readonly<A>;
+export declare class RollbackUtxoError extends RollbackUtxoError_base<{
+    message: string;
+    utxo: ledger.Utxo;
+    cause?: unknown;
+}> {
+}
+declare const SpendUtxoError_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.SpendUtxo";
+} & Readonly<A>;
+export declare class SpendUtxoError extends SpendUtxoError_base<{
+    message: string;
+    utxo: ledger.Utxo;
+    cause?: unknown;
+}> {
+}
+declare const UtxoNotFoundError_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: "UtxoNotFoundError";
+} & Readonly<A>;
+export declare class UtxoNotFoundError extends UtxoNotFoundError_base<{
+    readonly utxo: ledger.Utxo;
+}> {
+}
+export {};

package/dist/v1/WalletError.js

@@ -0,0 +1,53 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Data } from 'effect';
+export const WalletError = {
+    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 });
+    },
+};
+export class OtherWalletError extends Data.TaggedError('Wallet.Other') {
+}
+export class SyncWalletError extends Data.TaggedError('Wallet.Sync') {
+}
+export class InsufficientFundsError extends Data.TaggedError('Wallet.InsufficientFunds') {
+}
+export class AddressError extends Data.TaggedError('Wallet.Address') {
+}
+export class TransactingError extends Data.TaggedError('Wallet.Transacting') {
+}
+export class SignError extends Data.TaggedError('Wallet.Sign') {
+}
+export class ApplyTransactionError extends Data.TaggedError('Wallet.ApplyTransaction') {
+}
+export class RollbackUtxoError extends Data.TaggedError('Wallet.RollbackUtxo') {
+}
+export class SpendUtxoError extends Data.TaggedError('Wallet.SpendUtxo') {
+}
+export class UtxoNotFoundError extends Data.TaggedError('UtxoNotFoundError') {
+}

package/dist/v1/index.d.ts

@@ -0,0 +1,15 @@
+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 CoinsAndBalances from './CoinsAndBalances.js';
+export * as Keys from './Keys.js';
+export * from './RunningV1Variant.js';
+export * as Simulator from './Simulator.js';
+export * as WalletError from './WalletError.js';
+export * from './CoreWallet.js';
+export * from './Transaction.js';
+export * as TransactionHistoryStorage from '../storage/index.js';
+export * as UnshieldedState from './UnshieldedState.js';

package/dist/v1/index.js

@@ -0,0 +1,27 @@
+// This file is part of MIDNIGHT-WALLET-SDK.
+// Copyright (C) 2025 Midnight Foundation
+// SPDX-License-Identifier: Apache-2.0
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+export * from './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 CoinsAndBalances from './CoinsAndBalances.js';
+export * as Keys from './Keys.js';
+export * from './RunningV1Variant.js';
+export * as Simulator from './Simulator.js';
+export * as WalletError from './WalletError.js';
+export * from './CoreWallet.js';
+export * from './Transaction.js';
+export * as TransactionHistoryStorage from '../storage/index.js';
+export * as UnshieldedState from './UnshieldedState.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-unshielded-wallet",
-  "version": "1.0.0-beta.12",
+  "version": "1.0.0-beta.14",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,13 +23,13 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.5",
+    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.6",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.9",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.8",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.9",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "3.0.0-beta.9",
     "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.12",
-    "@midnight-ntwrk/wallet-sdk-unshielded-state": "1.0.0-beta.10",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.0.0-beta.13",
+    "@midnight-ntwrk/wallet-sdk-unshielded-state": "1.0.0-beta.11",
     "@midnight-ntwrk/wallet-sdk-utilities": "1.0.0-beta.7",
     "effect": "^3.17.3",
     "rxjs": "^7.5"
@@ -38,8 +38,8 @@
     "typecheck": "tsc -b ./tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
-    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml}\"",
-    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml}\"",
+    "format": "prettier --write \"**/*.{ts,js,json,yaml,yml,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,yaml,yml,md}\"",
     "dist": "tsc -b ./tsconfig.build.json",
     "dist:publish": "tsc -b ./tsconfig.publish.json",
     "clean": "rimraf --glob dist 'tsconfig.*.tsbuildinfo' && date +%s > .clean-timestamp",

package/dist/State.d.ts

@@ -1,21 +0,0 @@
-import { Effect, Stream } from 'effect';
-import { UnshieldedStateAPI, Utxo } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
-import { ParseError } from 'effect/ParseResult';
-export interface State {
-    address: string;
-    balances: Map<string, bigint>;
-    pendingCoins: readonly Utxo[];
-    availableCoins: readonly Utxo[];
-    totalCoins: readonly Utxo[];
-    syncProgress: {
-        applyGap: number;
-        synced: boolean;
-    } | undefined;
-}
-export declare class StateImpl {
-    unshieldedState: UnshieldedStateAPI;
-    address: string;
-    constructor(unshieldedState: UnshieldedStateAPI, address: string);
-    updates(): Stream.Stream<State>;
-    serialize(): Effect.Effect<string, ParseError>;
-}

package/dist/State.js

@@ -1,43 +0,0 @@
-// This file is part of MIDNIGHT-WALLET-SDK.
-// Copyright (C) 2025 Midnight Foundation
-// SPDX-License-Identifier: Apache-2.0
-// Licensed under the Apache License, Version 2.0 (the "License");
-// You may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-import { Effect, HashSet, pipe, Stream } from 'effect';
-import { UnshieldedStateEncoder } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
-export class StateImpl {
-    unshieldedState;
-    address;
-    constructor(unshieldedState, address) {
-        this.unshieldedState = unshieldedState;
-        this.address = address;
-    }
-    updates() {
-        return this.unshieldedState.state.pipe(Stream.map((state) => ({
-            address: this.address,
-            balances: HashSet.reduce(state.utxos, new Map(), (acc, utxo) => {
-                acc.set(utxo.type, (acc.get(utxo.type) || 0n) + utxo.value);
-                return acc;
-            }),
-            pendingCoins: HashSet.toValues(state.pendingUtxos),
-            availableCoins: HashSet.toValues(state.utxos),
-            totalCoins: HashSet.toValues(HashSet.union(state.utxos, state.pendingUtxos)),
-            syncProgress: state.syncProgress
-                ? {
-                    applyGap: (state.syncProgress?.highestTransactionId ?? 0) - (state.syncProgress?.currentTransactionId ?? 0),
-                    synced: state.syncProgress?.highestTransactionId === state.syncProgress?.currentTransactionId,
-                }
-                : undefined,
-        })));
-    }
-    serialize() {
-        return pipe(this.unshieldedState.getLatestState(), Effect.flatMap((state) => UnshieldedStateEncoder(state)), Effect.map((encoded) => JSON.stringify(encoded)));
-    }
-}

package/dist/SyncService.d.ts

@@ -1,55 +0,0 @@
-import { Layer, Context, Stream, Schema, Scope } from 'effect';
-export declare const UnshieldedUpdateSchema: Schema.Union<[Schema.Struct<{
-    type: Schema.Literal<["UnshieldedTransaction"]>;
-    transaction: Schema.Data<Schema.Struct<{
-        id: typeof Schema.Number;
-        hash: typeof Schema.String;
-        type: Schema.Literal<["RegularTransaction", "SystemTransaction"]>;
-        protocolVersion: typeof Schema.Number;
-        identifiers: Schema.Array$<typeof Schema.String>;
-        transactionResult: Schema.NullOr<Schema.Struct<{
-            status: typeof Schema.String;
-            segments: Schema.NullOr<Schema.Array$<Schema.Struct<{
-                id: typeof Schema.String;
-                success: typeof Schema.Boolean;
-            }>>>;
-        }>>;
-        createdUtxos: Schema.Array$<Schema.Data<Schema.Struct<{
-            value: Schema.Schema<bigint, string, never>;
-            owner: typeof Schema.String;
-            type: typeof Schema.String;
-            intentHash: typeof Schema.String;
-            outputNo: typeof Schema.Number;
-            ctime: typeof Schema.Number;
-            registeredForDustGeneration: typeof Schema.Boolean;
-        }>>>;
-        spentUtxos: Schema.Array$<Schema.Data<Schema.Struct<{
-            value: Schema.Schema<bigint, string, never>;
-            owner: typeof Schema.String;
-            type: typeof Schema.String;
-            intentHash: typeof Schema.String;
-            outputNo: typeof Schema.Number;
-            ctime: typeof Schema.Number;
-            registeredForDustGeneration: typeof Schema.Boolean;
-        }>>>;
-    }>>;
-}>, Schema.Struct<{
-    type: Schema.Literal<["UnshieldedTransactionsProgress"]>;
-    highestTransactionId: typeof Schema.Number;
-}>]>;
-export type UnshieldedUpdate = Schema.Schema.Type<typeof UnshieldedUpdateSchema>;
-declare const SyncServiceError_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: "SyncServiceError";
-} & Readonly<A>;
-export declare class SyncServiceError extends SyncServiceError_base<{
-    readonly error?: unknown;
-}> {
-}
-export interface SyncServiceLive {
-    readonly startSync: (address: string, transactionId: number) => Stream.Stream<UnshieldedUpdate, SyncServiceError, Scope.Scope>;
-}
-declare const SyncService_base: Context.TagClass<SyncService, "@midnight-ntwrk/wallet-sdk-unshielded-wallet/SyncService", SyncServiceLive>;
-export declare class SyncService extends SyncService_base {
-    static readonly LiveWithIndexer: (indexerUrl: string) => Layer.Layer<SyncService>;
-}
-export {};