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

package/dist/Transacting.js

@@ -0,0 +1,195 @@
+// 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 { Either } from 'effect';
+import { DustActions, DustRegistration, Intent, SignatureEnabled, Transaction, UnshieldedOffer, addressFromKey, } from '@midnight-ntwrk/ledger-v6';
+import { MidnightBech32m, DustAddress } from '@midnight-ntwrk/wallet-sdk-address-format';
+import { ProvingRecipe, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { LedgerOps } from '@midnight-ntwrk/wallet-sdk-utilities';
+import { BindingMarker, ProofMarker, SignatureMarker } from './Utils.js';
+export const makeDefaultTransactingCapability = (config, getContext) => {
+    return new TransactingCapabilityImplementation(config.networkId, config.costParameters, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability);
+};
+export const makeSimulatorTransactingCapability = (config, getContext) => {
+    return new TransactingCapabilityImplementation(config.networkId, config.costParameters, () => getContext().coinSelection, () => getContext().coinsAndBalancesCapability, () => getContext().keysCapability);
+};
+export class TransactingCapabilityImplementation {
+    networkId;
+    costParams;
+    getCoinSelection;
+    getCoins;
+    getKeys;
+    constructor(networkId, costParams, getCoinSelection, getCoins, getKeys) {
+        this.getCoins = getCoins;
+        this.networkId = networkId;
+        this.costParams = costParams;
+        this.getCoinSelection = getCoinSelection;
+        this.getKeys = getKeys;
+    }
+    createDustGenerationTransaction(currentTime, ttl, nightUtxos, nightVerifyingKey, dustReceiverAddress) {
+        return Either.gen(this, function* () {
+            const receiver = dustReceiverAddress ? yield* this.#parseAddress(dustReceiverAddress) : undefined;
+            return yield* LedgerOps.ledgerTry(() => {
+                const network = this.networkId;
+                const intent = Intent.new(ttl);
+                const totalDustValue = nightUtxos.reduce((total, { value }) => total + value, 0n);
+                const inputs = nightUtxos.map(({ token: utxo }) => ({
+                    ...utxo,
+                    owner: nightVerifyingKey,
+                }));
+                const outputs = inputs.map((input) => ({
+                    owner: addressFromKey(nightVerifyingKey),
+                    type: input.type,
+                    value: input.value,
+                }));
+                intent.guaranteedUnshieldedOffer = UnshieldedOffer.new(inputs, outputs, []);
+                const dustRegistration = new DustRegistration(SignatureMarker.signature, nightVerifyingKey, receiver, dustReceiverAddress !== undefined ? totalDustValue : 0n);
+                intent.dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, [], [dustRegistration]);
+                return Transaction.fromParts(network, undefined, undefined, intent);
+            });
+        });
+    }
+    addDustGenerationSignature(transaction, signatureData) {
+        return Either.gen(this, function* () {
+            const intent = transaction.intents?.get(1);
+            if (!intent) {
+                return yield* Either.left(new WalletError.TransactingError({ message: 'No intent found in the transaction intents with segment = 1' }));
+            }
+            const { dustActions, guaranteedUnshieldedOffer } = intent;
+            if (!dustActions) {
+                return yield* Either.left(new WalletError.TransactingError({ message: 'No dustActions found in intent' }));
+            }
+            if (!guaranteedUnshieldedOffer) {
+                return yield* Either.left(new WalletError.TransactingError({ message: 'No guaranteedUnshieldedOffer found in intent' }));
+            }
+            const [registration, ...restRegistrations] = dustActions.registrations;
+            if (!registration) {
+                return yield* Either.left(new WalletError.TransactingError({ message: 'No registrations found in dustActions' }));
+            }
+            return yield* LedgerOps.ledgerTry(() => {
+                const signature = new SignatureEnabled(signatureData);
+                const registrationWithSignature = new DustRegistration(signature.instance, registration.nightKey, registration.dustAddress, registration.allowFeePayment, signature);
+                const newDustActions = new DustActions(signature.instance, ProofMarker.preProof, dustActions.ctime, dustActions.spends, [registrationWithSignature, ...restRegistrations]);
+                // make a copy of intent to avoid mutation
+                const newIntent = Intent.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, intent.serialize());
+                newIntent.dustActions = newDustActions;
+                const inputsLen = guaranteedUnshieldedOffer.inputs.length;
+                const signatures = [];
+                for (let i = 0; i < inputsLen; ++i) {
+                    signatures.push(guaranteedUnshieldedOffer.signatures.at(i) ?? signatureData);
+                }
+                newIntent.guaranteedUnshieldedOffer = guaranteedUnshieldedOffer.addSignatures(signatures);
+                // make a copy of transaction to avoid mutation
+                const newTransaction = Transaction.deserialize(signature.instance, ProofMarker.preProof, BindingMarker.preBinding, transaction.serialize());
+                newTransaction.intents = newTransaction.intents.set(1, newIntent);
+                return {
+                    type: ProvingRecipe.TRANSACTION_TO_PROVE,
+                    transaction: newTransaction,
+                };
+            });
+        });
+    }
+    calculateFee(transaction, ledgerParams) {
+        return (transaction.feesWithMargin(ledgerParams, this.costParams.feeBlocksMargin) + this.costParams.additionalFeeOverhead);
+    }
+    static feeImbalance(transaction, totalFee) {
+        const dustImbalance = transaction
+            .imbalances(0, totalFee)
+            .entries()
+            .find(([tt, _]) => tt.tag === 'dust');
+        return dustImbalance ? -dustImbalance[1] : totalFee;
+    }
+    addFeePayment(secretKey, state, transaction, currentTime, ttl, ledgerParams) {
+        const network = this.networkId;
+        const feeLeft = TransactingCapabilityImplementation.feeImbalance(transaction, this.calculateFee(transaction, ledgerParams));
+        const dustTokens = this.getCoins().getAvailableCoinsWithGeneratedDust(state, currentTime);
+        const selectedTokens = this.getCoinSelection()(dustTokens, feeLeft);
+        if (!selectedTokens.length) {
+            return Either.left(new WalletError.TransactingError({ message: 'No dust tokens found in the wallet state' }));
+        }
+        const totalFeeInSelected = selectedTokens.reduce((total, { value }) => total + value, 0n);
+        const feeDiff = totalFeeInSelected - feeLeft;
+        if (feeDiff < 0n) {
+            // A sanity-check, should never happen
+            return Either.left(new WalletError.TransactingError({ message: 'Error in tokens selection algorithm' }));
+        }
+        // reduce the largest token's value by `feeDiff`
+        const tokensWithFeeToTake = selectedTokens.toSorted((a, b) => Number(b.value - a.value));
+        if (feeDiff > 0n) {
+            const highestByValue = tokensWithFeeToTake[0];
+            tokensWithFeeToTake[0] = {
+                value: highestByValue.value - feeDiff,
+                token: highestByValue.token,
+            };
+        }
+        return LedgerOps.ledgerTry(() => {
+            const intent = Intent.new(ttl);
+            const [spends, updatedState] = state.spendCoins(secretKey, tokensWithFeeToTake, currentTime);
+            intent.dustActions = new DustActions(SignatureMarker.signature, ProofMarker.preProof, currentTime, spends, []);
+            const feeTransaction = Transaction.fromPartsRandomized(network, undefined, undefined, intent);
+            return {
+                newState: updatedState,
+                recipe: {
+                    type: ProvingRecipe.TRANSACTION_TO_PROVE,
+                    transaction: transaction.merge(feeTransaction),
+                },
+            };
+        });
+    }
+    revert(state, tx) {
+        return Either.try({
+            try: () => state.revertTransaction(tx),
+            catch: (err) => {
+                return new WalletError.OtherWalletError({
+                    message: `Error while reverting transaction ${tx.identifiers().at(0)}`,
+                    cause: err,
+                });
+            },
+        });
+    }
+    revertRecipe(state, recipe) {
+        const doRevert = (tx) => {
+            return Either.try({
+                try: () => state.revertTransaction(tx),
+                catch: (err) => {
+                    return new WalletError.OtherWalletError({
+                        message: `Error while reverting transaction ${tx.identifiers().at(0)}`,
+                        cause: err,
+                    });
+                },
+            });
+        };
+        switch (recipe.type) {
+            case ProvingRecipe.TRANSACTION_TO_PROVE:
+                return doRevert(recipe.transaction);
+            case ProvingRecipe.BALANCE_TRANSACTION_TO_PROVE:
+                return doRevert(recipe.transactionToProve);
+            case ProvingRecipe.NOTHING_TO_PROVE:
+                return Either.right(state);
+        }
+    }
+    #parseAddress(addr) {
+        return Either.try({
+            try: () => {
+                const repr = MidnightBech32m.parse(addr);
+                return DustAddress.codec.decode(this.networkId, repr).data;
+            },
+            catch: (err) => {
+                return new WalletError.AddressError({
+                    message: `Address parsing error: ${addr}`,
+                    originalAddress: addr,
+                    cause: err,
+                });
+            },
+        });
+    }
+}

package/dist/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/Utils.js

@@ -0,0 +1,26 @@
+// 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 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/V1Builder.d.ts

@@ -0,0 +1,100 @@
+import { Types, Either } from 'effect';
+import { DustSecretKey, FinalizedTransaction } from '@midnight-ntwrk/ledger-v6';
+import { VariantBuilder, Variant } from '@midnight-ntwrk/wallet-sdk-runtime/abstractions';
+import { Proving, WalletError } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { SyncService, SyncCapability, DefaultSyncConfiguration, WalletSyncUpdate } from './Sync.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { DustCoreWallet } from './DustCoreWallet.js';
+import { KeysCapability } from './Keys.js';
+import { CoinsAndBalancesCapability, CoinSelection } from './CoinsAndBalances.js';
+import { DefaultTransactingConfiguration, DefaultTransactingContext, TransactingCapability } from './Transacting.js';
+import { NetworkId } from './types/ledger.js';
+import { DefaultSubmissionConfiguration, SubmissionService } from './Submission.js';
+import { DustToken } from './types/Dust.js';
+import { SerializationCapability } from './Serialization.js';
+import { TotalCostParameters } from './types/transaction.js';
+export type BaseV1Configuration = {
+    networkId: NetworkId;
+    costParameters: TotalCostParameters;
+};
+export type DefaultV1Configuration = BaseV1Configuration;
+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, DustCoreWallet, DustCoreWallet, // null,
+RunningV1Variant<TSerialized, TSyncUpdate, TTransaction, TAuxData>> & {
+    deserializeState: (serialized: TSerialized) => Either.Either<DustCoreWallet, WalletError.WalletError>;
+    coinsAndBalances: CoinsAndBalancesCapability<DustCoreWallet>;
+    keys: KeysCapability<DustCoreWallet>;
+    serialization: SerializationCapability<DustCoreWallet, null, TSerialized>;
+};
+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<DustCoreWallet, TStartAux, TSyncUpdate>, syncCapability: (configuration: TSyncConfig, getContext: () => TSyncContext) => SyncCapability<DustCoreWallet, 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<DustCoreWallet, 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, DustCoreWallet, TTransaction>): V1Builder<TConfig & TTransactingConfig, TContext & TTransactingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinSelection<TCoinSelectionConfig, TCoinSelectionContext extends Partial<RunningV1Variant.AnyContext>>(coinSelection: (config: TCoinSelectionConfig, getContext: () => TCoinSelectionContext) => CoinSelection<DustToken>): 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) => Proving.ProvingService<TTransaction>): V1Builder<TConfig & TProvingConfig, TContext & TProvingContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withProvingDefaults(this: V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>): V1Builder<TConfig & Proving.DefaultProvingConfiguration, TContext, TSerialized, TSyncUpdate, FinalizedTransaction, TStartAux>;
+    withCoinsAndBalancesDefaults(): V1Builder<TConfig, TContext, TSerialized, TSyncUpdate, TTransaction, TStartAux>;
+    withCoinsAndBalances<TBalancesConfig, TBalancesContext extends Partial<RunningV1Variant.AnyContext>>(coinsAndBalancesCapability: (configuration: TBalancesConfig, getContext: () => TBalancesContext) => CoinsAndBalancesCapability<DustCoreWallet>): V1Builder<TConfig & TBalancesConfig, TContext & TBalancesContext, 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<DustCoreWallet>): 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, FinalizedTransaction, TStartAux>): V1Builder<TConfig & DefaultSubmissionConfiguration, TContext, TSerialized, TSyncUpdate, 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<DustCoreWallet, TStartAux, TSyncUpdate>;
+        readonly syncCapability: (configuration: TConfig, getContext: () => TContext) => SyncCapability<DustCoreWallet, TSyncUpdate>;
+    };
+    type HasTransacting<TConfig, TContext, TTransaction> = {
+        readonly transactingCapability: (configuration: TConfig, getContext: () => TContext) => TransactingCapability<DustSecretKey, DustCoreWallet, TTransaction>;
+    };
+    type HasSerialization<TConfig, TContext, TSerialized> = {
+        readonly serializationCapability: (configuration: TConfig, getContext: () => TContext) => SerializationCapability<DustCoreWallet, null, TSerialized>;
+    };
+    type HasCoinSelection<TConfig, TContext> = {
+        readonly coinSelection: (configuration: TConfig, getContext: () => TContext) => CoinSelection<DustToken>;
+    };
+    type HasProving<TConfig, TContext, TTransaction> = {
+        readonly provingService: (configuration: TConfig, getContext: () => TContext) => Proving.ProvingService<TTransaction>;
+    };
+    type HasCoinsAndBalances<TConfig, TContext> = {
+        readonly coinsAndBalancesCapability: (configuration: TConfig, getContext: () => TContext) => CoinsAndBalancesCapability<DustCoreWallet>;
+    };
+    type HasKeys<TConfig, TContext> = {
+        readonly keysCapability: (configuration: TConfig, getContext: () => TContext) => KeysCapability<DustCoreWallet>;
+    };
+    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>>;
+    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/V1Builder.js

@@ -0,0 +1,181 @@
+// 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, Scope } from 'effect';
+import { Proving } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { makeDefaultSyncCapability, makeDefaultSyncService, } from './Sync.js';
+import { RunningV1Variant, V1Tag } from './RunningV1Variant.js';
+import { makeDefaultKeysCapability } from './Keys.js';
+import { chooseCoin, makeDefaultCoinsAndBalancesCapability, } from './CoinsAndBalances.js';
+import { makeDefaultTransactingCapability, } from './Transacting.js';
+import { makeDefaultSubmissionService } from './Submission.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()
+            .withKeysDefaults()
+            .withSubmissionDefaults()
+            .withProvingDefaults()
+            .withCoinSelectionDefaults();
+    }
+    withTransactionType() {
+        return new V1Builder({
+            ...this.#buildState,
+            provingService: undefined,
+            transactingCapability: undefined,
+            submissionService: 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);
+    }
+    withProving(provingService) {
+        return new V1Builder({
+            ...this.#buildState,
+            provingService,
+        });
+    }
+    withProvingDefaults() {
+        return this.withProving(Proving.makeDefaultProvingService);
+    }
+    withCoinsAndBalancesDefaults() {
+        return this.withCoinsAndBalances(makeDefaultCoinsAndBalancesCapability);
+    }
+    withCoinsAndBalances(coinsAndBalancesCapability) {
+        return new V1Builder({
+            ...this.#buildState,
+            coinsAndBalancesCapability,
+        });
+    }
+    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);
+        return {
+            __polyTag__: V1Tag,
+            coinsAndBalances: v1Context.coinsAndBalancesCapability,
+            keys: v1Context.keysCapability,
+            serialization: v1Context.serializationCapability,
+            start(context) {
+                return Effect.gen(function* () {
+                    yield* Effect.addFinalizer(() => v1Context.submissionService.close());
+                    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, provingService, coinSelection, coinsAndBalancesCapability, keysCapability, submissionService, } = 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),
+        };
+        return context;
+    }
+}
+const isBuildStateFull = (buildState) => {
+    const allBuildStateKeys = [
+        'syncService',
+        'syncCapability',
+        'transactingCapability',
+        'coinSelection',
+        'serializationCapability',
+        'provingService',
+        'coinsAndBalancesCapability',
+        'keysCapability',
+        'submissionService',
+    ];
+    return allBuildStateKeys.every((key) => typeof buildState[key] == 'function');
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './DustCoreWallet.js';
+export * from './DustWallet.js';
+export * as Keys from './Keys.js';
+export * as Simulator from './Simulator.js';
+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';

package/dist/index.js

@@ -0,0 +1,21 @@
+// 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 './DustCoreWallet.js';
+export * from './DustWallet.js';
+export * as Keys from './Keys.js';
+export * as Simulator from './Simulator.js';
+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';

package/dist/types/Dust.d.ts

@@ -0,0 +1,30 @@
+import { DustInitialNonce, DustNullifier, DustNonce, DustPublicKey, Utxo } from '@midnight-ntwrk/ledger-v6';
+export type DustToken = {
+    initialValue: bigint;
+    owner: DustPublicKey;
+    nonce: DustNonce;
+    seq: number;
+    ctime: Date;
+    backingNight: DustInitialNonce;
+    mtIndex: bigint;
+};
+export type DustTokenWithNullifier = DustToken & {
+    nullifier: DustNullifier;
+};
+export type DustTokenFullInfo = {
+    token: DustToken;
+    dtime: Date | undefined;
+    maxCap: bigint;
+    maxCapReachedAt: Date;
+    generatedNow: bigint;
+    rate: bigint;
+};
+export type DustGenerationInfo = {
+    value: bigint;
+    owner: DustPublicKey;
+    nonce: DustInitialNonce;
+    dtime: Date | undefined;
+};
+export type UtxoWithMeta = Utxo & {
+    ctime: Date;
+};

package/dist/types/Dust.js

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

package/dist/types/index.d.ts

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

package/dist/types/index.js

@@ -0,0 +1,15 @@
+// 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 './Dust.js';
+export * from './ledger.js';
+export * from './transaction.js';

package/dist/types/ledger.d.ts

@@ -0,0 +1,4 @@
+import * as ledger from '@midnight-ntwrk/ledger-v6';
+export type AnyTransaction = ledger.UnprovenTransaction | ledger.FinalizedTransaction | ledger.ProofErasedTransaction;
+export type UnprovenDustSpend = ledger.DustSpend<ledger.PreProof>;
+export type NetworkId = string;

package/dist/types/ledger.js

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

package/dist/types/transaction.d.ts

@@ -0,0 +1,4 @@
+export type TotalCostParameters = {
+    additionalFeeOverhead: bigint;
+    feeBlocksMargin: number;
+};

package/dist/types/transaction.js

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