@midnightntwrk/wallet-sdk-dust-wallet 4.2.0

package/dist/v1/TransactionHistory.d.ts

@@ -0,0 +1,69 @@
+import { TransactionHistoryStorage } from '@midnightntwrk/wallet-sdk-abstractions';
+import type * as ledger from '@midnight-ntwrk/ledger-v8';
+import { Effect, Schema } from 'effect';
+import { TransactionHistoryError } from './WalletError.js';
+export declare const DustUtxoInfoSchema: Schema.Struct<{
+    initialValue: typeof Schema.BigInt;
+    nonce: typeof Schema.BigInt;
+    seq: typeof Schema.Number;
+    backingNight: typeof Schema.String;
+    mtIndex: typeof Schema.BigInt;
+}>;
+export declare const DustSectionSchema: Schema.Struct<{
+    receivedUtxos: Schema.Array$<Schema.Struct<{
+        initialValue: typeof Schema.BigInt;
+        nonce: typeof Schema.BigInt;
+        seq: typeof Schema.Number;
+        backingNight: typeof Schema.String;
+        mtIndex: typeof Schema.BigInt;
+    }>>;
+    spentUtxos: Schema.Array$<Schema.Struct<{
+        initialValue: typeof Schema.BigInt;
+        nonce: typeof Schema.BigInt;
+        seq: typeof Schema.Number;
+        backingNight: typeof Schema.String;
+        mtIndex: typeof Schema.BigInt;
+    }>>;
+}>;
+type DustSection = Schema.Schema.Type<typeof DustSectionSchema>;
+export declare const DustTransactionHistoryEntrySchema: Schema.Struct<{
+    hash: typeof Schema.String;
+    protocolVersion: typeof Schema.Number;
+    status: Schema.Literal<["SUCCESS", "FAILURE", "PARTIAL_SUCCESS"]>;
+    dust: Schema.Struct<{
+        receivedUtxos: Schema.Array$<Schema.Struct<{
+            initialValue: typeof Schema.BigInt;
+            nonce: typeof Schema.BigInt;
+            seq: typeof Schema.Number;
+            backingNight: typeof Schema.String;
+            mtIndex: typeof Schema.BigInt;
+        }>>;
+        spentUtxos: Schema.Array$<Schema.Struct<{
+            initialValue: typeof Schema.BigInt;
+            nonce: typeof Schema.BigInt;
+            seq: typeof Schema.Number;
+            backingNight: typeof Schema.String;
+            mtIndex: typeof Schema.BigInt;
+        }>>;
+    }>;
+}>;
+export type DustTransactionHistoryEntry = Schema.Schema.Type<typeof DustTransactionHistoryEntrySchema>;
+export type DefaultTransactionHistoryConfiguration = {
+    txHistoryStorage: TransactionHistoryStorage.TransactionHistoryStorage<TransactionHistoryStorage.TransactionHistoryEntryWithHash>;
+    indexerClientConnection: {
+        indexerHttpUrl: string;
+    };
+};
+export type TransactionDetails = {
+    hash: string;
+    timestamp: number;
+    status: 'SUCCESS' | 'FAILURE' | 'PARTIAL_SUCCESS';
+};
+export type TransactionHistoryService = {
+    put(changes: ledger.DustStateChanges, metadata: TransactionDetails, protocolVersion: number): Effect.Effect<void, TransactionHistoryError>;
+    getTransactionDetails(hash: TransactionHistoryStorage.TransactionHash): Effect.Effect<TransactionDetails, TransactionHistoryError>;
+};
+export declare const mergeDustSections: (existing: DustSection, incoming: DustSection) => DustSection;
+export declare const makeDefaultTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService;
+export declare const makeSimulatorTransactionHistoryService: (config: DefaultTransactionHistoryConfiguration, _getContext: () => unknown) => TransactionHistoryService;
+export {};

package/dist/v1/TransactionHistory.js

@@ -0,0 +1,106 @@
+// 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 { TransactionHistoryStorage } from '@midnightntwrk/wallet-sdk-abstractions';
+import { Duration, Array as EArray, Effect, Schedule, Schema } from 'effect';
+import { TransactionHistoryDetail } from '@midnightntwrk/wallet-sdk-indexer-client';
+import { HttpQueryClient } from '@midnightntwrk/wallet-sdk-indexer-client/effect';
+import { TransactionHistoryError } from './WalletError.js';
+export const DustUtxoInfoSchema = Schema.Struct({
+    initialValue: Schema.BigInt,
+    nonce: Schema.BigInt,
+    seq: Schema.Number,
+    backingNight: Schema.String,
+    mtIndex: Schema.BigInt,
+});
+export const DustSectionSchema = Schema.Struct({
+    receivedUtxos: Schema.Array(DustUtxoInfoSchema),
+    spentUtxos: Schema.Array(DustUtxoInfoSchema),
+});
+export const DustTransactionHistoryEntrySchema = Schema.Struct({
+    hash: TransactionHistoryStorage.TransactionHashSchema,
+    protocolVersion: Schema.Number,
+    status: TransactionHistoryStorage.TransactionHistoryStatusSchema,
+    dust: DustSectionSchema,
+});
+const utxoEquals = Schema.equivalence(DustUtxoInfoSchema);
+export const mergeDustSections = (existing, incoming) => ({
+    receivedUtxos: EArray.unionWith(existing.receivedUtxos, incoming.receivedUtxos, utxoEquals),
+    spentUtxos: EArray.unionWith(existing.spentUtxos, incoming.spentUtxos, utxoEquals),
+});
+const convertQualifiedDustOutput = (utxo) => ({
+    initialValue: utxo.initialValue,
+    nonce: utxo.nonce,
+    seq: utxo.seq,
+    backingNight: utxo.backingNight,
+    mtIndex: utxo.mtIndex,
+});
+const convertUpdateToStorageEntry = (changes, metadata, protocolVersion) => ({
+    hash: changes.source,
+    protocolVersion,
+    status: metadata.status,
+    dust: {
+        receivedUtxos: changes.receivedUtxos.map(convertQualifiedDustOutput),
+        spentUtxos: changes.spentUtxos.map(convertQualifiedDustOutput),
+    },
+});
+const upsertDustEntry = (txHistoryStorage, entry) => Effect.tryPromise({
+    try: () => txHistoryStorage.upsert(entry),
+    catch: (e) => new TransactionHistoryError({ message: `Failed to upsert history entry for ${entry.hash}`, cause: e }),
+});
+export const makeDefaultTransactionHistoryService = (config, _getContext) => {
+    const txHistoryStorage = config.txHistoryStorage;
+    const queryClientLayer = HttpQueryClient.layer({ url: config.indexerClientConnection.indexerHttpUrl });
+    return {
+        put: (changes, metadata, protocolVersion) => {
+            const entry = convertUpdateToStorageEntry(changes, metadata, protocolVersion);
+            return upsertDustEntry(txHistoryStorage, entry);
+        },
+        getTransactionDetails: (hash) => Effect.gen(function* () {
+            const statusQuery = yield* TransactionHistoryDetail;
+            const result = yield* statusQuery({ transactionHash: hash });
+            const tx = result.transactions[0];
+            const rawStatus = tx.__typename === 'RegularTransaction' ? tx.transactionResult.status : undefined;
+            const status = rawStatus === 'FAILURE' || rawStatus === 'PARTIAL_SUCCESS' ? rawStatus : 'SUCCESS';
+            return {
+                hash: tx.hash,
+                timestamp: tx.block.timestamp,
+                status,
+            };
+        }).pipe(Effect.provide(queryClientLayer), Effect.scoped, Effect.retry(Schedule.exponential(Duration.seconds(1)).pipe(Schedule.compose(Schedule.recurs(3)))), Effect.mapError((cause) => new TransactionHistoryError({
+            message: `Failed to fetch transaction metadata for ${hash}`,
+            cause,
+        }))),
+    };
+};
+export const makeSimulatorTransactionHistoryService = (config, _getContext) => {
+    const txHistoryStorage = config.txHistoryStorage;
+    return {
+        put: (changes, metadata, protocolVersion) => {
+            const entry = convertUpdateToStorageEntry(changes, metadata, protocolVersion);
+            return upsertDustEntry(txHistoryStorage, {
+                ...entry,
+                timestamp: new Date(metadata.timestamp),
+            });
+        },
+        getTransactionDetails: (hash) => Effect.tryPromise({
+            try: () => txHistoryStorage.get(hash),
+            catch: (e) => new TransactionHistoryError({ message: `Failed to get transaction details for ${hash}`, cause: e }),
+        }).pipe(Effect.flatMap((entry) => entry
+            ? Effect.succeed({
+                hash: entry.hash,
+                timestamp: entry.timestamp ? entry.timestamp.getTime() : Date.now(),
+                status: entry.status,
+            })
+            : Effect.fail(new TransactionHistoryError({ message: `No transaction found in storage for hash: ${hash}` })))),
+    };
+};

package/dist/v1/Utils.d.ts

@@ -0,0 +1,14 @@
+export declare const SignatureMarker: {
+    readonly signature: "signature";
+    readonly signatureErased: "signature-erased";
+};
+export declare const ProofMarker: {
+    readonly proof: "proof";
+    readonly preProof: "pre-proof";
+    readonly noProof: "no-proof";
+};
+export declare const BindingMarker: {
+    readonly binding: "binding";
+    readonly preBinding: "pre-binding";
+    readonly noBinding: "no-binding";
+};

package/dist/v1/Utils.js

@@ -0,0 +1,26 @@
+// 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 const SignatureMarker = {
+    signature: 'signature',
+    signatureErased: 'signature-erased',
+};
+export const ProofMarker = {
+    proof: 'proof',
+    preProof: 'pre-proof',
+    noProof: 'no-proof',
+};
+export const BindingMarker = {
+    binding: 'binding',
+    preBinding: 'pre-binding',
+    noBinding: 'no-binding',
+};

package/dist/v1/V1Builder.d.ts

@@ -0,0 +1,91 @@
+import { type Types, type Either } from 'effect';
+import { type DustSecretKey, type FinalizedTransaction } from '@midnight-ntwrk/ledger-v8';
+import { type VariantBuilder, type Variant } from '@midnightntwrk/wallet-sdk-runtime/abstractions';
+import { type WalletError } from './WalletError.js';
+import { type SyncService, type SyncCapability, type ChangesResult, type DefaultSyncConfiguration, type WalletSyncUpdate } from './Sync.js';
+import { type DefaultTransactionHistoryConfiguration, type TransactionHistoryService } from './TransactionHistory.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { type CoreWallet } from './CoreWallet.js';
+import { type KeysCapability } from './Keys.js';
+import { type CoinsAndBalancesCapability, type CoinSelection, type DefaultCoinsAndBalancesContext } from './CoinsAndBalances.js';
+import { type DefaultTransactingConfiguration, type DefaultTransactingContext, type TransactingCapability } from './Transacting.js';
+import { type NetworkId } from './types/ledger.js';
+import { type SerializationCapability } from './Serialization.js';
+import { type TotalCostParameters } from './types/transaction.js';
+export type BaseV1Configuration = {
+    networkId: NetworkId;
+    costParameters: TotalCostParameters;
+};
+export type DefaultV1Configuration = BaseV1Configuration & DefaultTransactionHistoryConfiguration;
+declare const V1BuilderSymbol: {
+    readonly typeId: unique symbol;
+};
+export type DefaultV1Variant = V1Variant<string, WalletSyncUpdate, FinalizedTransaction, DustSecretKey>;
+export type V1Variant<TSerialized, TSyncUpdate, TTransaction, TAuxData> = Variant.Variant<typeof V1Tag, CoreWallet, 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: TransactionHistoryService;
+};
+export type DefaultV1Builder = V1Builder<DefaultV1Configuration, RunningV1Variant.Context<string, WalletSyncUpdate, FinalizedTransaction, DustSecretKey>, string, WalletSyncUpdate, FinalizedTransaction>;
+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, FinalizedTransaction, TStartAux>;
+    withSyncDefaults(): V1Builder<TConfig & DefaultSyncConfiguration, TContext, TSerialized, WalletSyncUpdate, TTransaction, DustSecretKey>;
+    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, ChangesResult>): 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, FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultTransactingConfiguration, TContext & DefaultTransactingContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>;
+    withTransacting<TTransactingConfig, TTransactingContext extends Partial<RunningV1Variant.AnyContext>>(transactingCapability: (config: TTransactingConfig, getContext: () => TTransactingContext) => TransactingCapability<DustSecretKey, CoreWallet, TTransaction>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection): V1Builder<TConfig & TCoinSelectionConfig, TContext & TCoinSelectionContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinSelectionDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext & DefaultCoinsAndBalancesContext, 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, FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultTransactionHistoryConfiguration, TContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>;
+    withTransactionHistory<TTransactionHistoryConfig, TTransactionHistoryContext extends Partial<RunningV1Variant.AnyContext>>(transactionHistoryService: (configuration: TTransactionHistoryConfig, getContext: () => TTransactionHistoryContext) => TransactionHistoryService): 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>;
+    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, ChangesResult>;
+    };
+    type HasTransacting<TConfig, TContext, TTransaction> = {
+        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<DustSecretKey, CoreWallet, TTransaction>;
+    };
+    type HasSerialization<TConfig, TContext, TSerialized> = {
+        readonly serializationCapability: (configuration: TConfig, getContext: () => TContext) => SerializationCapability<CoreWallet, null, TSerialized>;
+    };
+    type HasCoinSelection<TConfig, TContext> = {
+        readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection;
+    };
+    type HasCoinsAndBalances<TConfig, TContext> = {
+        readonly coinsAndBalancesCapability: (configuration: TConfig, getContext: () => TContext) => CoinsAndBalancesCapability<CoreWallet>;
+    };
+    type HasTransactionHistory<TConfig, TContext> = {
+        readonly transactionHistoryService: (configuration: TConfig, getContext: () => TContext) => TransactionHistoryService;
+    };
+    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, TStartAux> = Types.Simplify<HasSync<TConfig, TContext, TSyncUpdate, TStartAux> & 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, 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,166 @@
+// 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 { Effect, Scope } from 'effect';
+import { makeDefaultSyncCapability, makeDefaultSyncService, } from './Sync.js';
+import { makeDefaultTransactionHistoryService, } from './TransactionHistory.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { makeDefaultKeysCapability } from './Keys.js';
+import { chooseCoin, makeDefaultCoinsAndBalancesCapability, } from './CoinsAndBalances.js';
+import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultV1SerializationCapability } from './Serialization.js';
+const V1BuilderSymbol = {
+    typeId: Symbol('@midnight-ntwrk/dustWallet#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,
+        });
+    }
+    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);
+        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(prevState) {
+                // TODO: re-implement
+                return Effect.succeed(prevState);
+            },
+            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, 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,43 @@
+import { type LedgerOps } from '@midnightntwrk/wallet-sdk-utilities';
+declare const OtherWalletError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ 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").VoidIfEmpty<{ 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 TransactingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ 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 InsufficientFundsError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ 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: string;
+}> {
+}
+declare const TransactionHistoryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Wallet.TransactionHistory";
+} & Readonly<A>;
+export declare class TransactionHistoryError extends TransactionHistoryError_base<{
+    message: string;
+    cause?: unknown;
+}> {
+}
+export type WalletError = OtherWalletError | SyncWalletError | TransactingError | InsufficientFundsError | TransactionHistoryError | LedgerOps.LedgerError;
+export {};

package/dist/v1/WalletError.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 { Data } from 'effect';
+export class OtherWalletError extends Data.TaggedError('Wallet.Other') {
+}
+export class SyncWalletError extends Data.TaggedError('Wallet.Sync') {
+}
+export class TransactingError extends Data.TaggedError('Wallet.Transacting') {
+}
+export class InsufficientFundsError extends Data.TaggedError('Wallet.InsufficientFunds') {
+}
+export class TransactionHistoryError extends Data.TaggedError('Wallet.TransactionHistory') {
+}

package/dist/v1/index.d.ts

@@ -0,0 +1,12 @@
+export * from './CoreWallet.js';
+export * from '../DustWallet.js';
+export * as Keys from './Keys.js';
+export * as Simulator from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+export * as SyncService from './Sync.js';
+export * as Transacting from './Transacting.js';
+export * from './RunningV1Variant.js';
+export * from './V1Builder.js';
+export * from './types/index.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';
+export * as TransactionHistory from './TransactionHistory.js';
+export * as WalletError from './WalletError.js';

package/dist/v1/index.js

@@ -0,0 +1,24 @@
+// 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 './CoreWallet.js';
+export * from '../DustWallet.js';
+export * as Keys from './Keys.js';
+export * as Simulator from '@midnightntwrk/wallet-sdk-capabilities/simulation';
+export * as SyncService from './Sync.js';
+export * as Transacting from './Transacting.js';
+export * from './RunningV1Variant.js';
+export * from './V1Builder.js';
+export * from './types/index.js';
+export * as CoinsAndBalances from './CoinsAndBalances.js';
+export * as TransactionHistory from './TransactionHistory.js';
+export * as WalletError from './WalletError.js';

package/dist/v1/types/Dust.d.ts

@@ -0,0 +1,39 @@
+import { type DustInitialNonce, type DustNullifier, type DustNonce, type DustPublicKey, type Utxo } from '@midnight-ntwrk/ledger-v8';
+export type Dust = {
+    initialValue: bigint;
+    owner: DustPublicKey;
+    nonce: DustNonce;
+    seq: number;
+    ctime: Date;
+    backingNight: DustInitialNonce;
+    mtIndex: bigint;
+};
+export type DustWithNullifier = Dust & {
+    nullifier: DustNullifier;
+};
+export type DustFullInfo = DustGenerationDetails & {
+    token: Dust;
+};
+/** Details of Dust generation/decay */
+export type DustGenerationDetails = {
+    /** When the backing Night UTxO was spent */
+    dtime: Date | undefined;
+    /** Maximum capacity (in Specks) `gen.value * night_dust_ratio` */
+    maxCap: bigint;
+    /** When the maximum capacity is reached. `ctime + timeToCapSeconds` */
+    maxCapReachedAt: Date;
+    /** Current amount of Dust available (in Specks) */
+    generatedNow: bigint;
+    /** The slope of generation and decay for this specific Dust UTxO (`gen.value * generation_decay_rate`) */
+    rate: bigint;
+};
+export type DustGenerationInfo = {
+    value: bigint;
+    owner: DustPublicKey;
+    nonce: DustInitialNonce;
+    dtime: Date | undefined;
+};
+export type UtxoWithMeta = Utxo & {
+    ctime: Date;
+    registeredForDustGeneration: boolean;
+};

package/dist/v1/types/Dust.js

@@ -0,0 +1 @@
+export {};

package/dist/v1/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Dust.js';
+export * from './ledger.js';
+export * from './transaction.js';

package/dist/v1/types/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 './Dust.js';
+export * from './ledger.js';
+export * from './transaction.js';