@midnight-ntwrk/wallet-sdk-facade 1.0.0-beta.9 → 1.0.0

package/README.md

@@ -0,0 +1,130 @@
+# @midnight-ntwrk/wallet-sdk-facade
+
+Unified facade for the Midnight Wallet SDK that combines all wallet types into a single API.
+
+## Installation
+
+```bash
+npm install @midnight-ntwrk/wallet-sdk-facade
+```
+
+## Overview
+
+The Wallet Facade provides a high-level unified interface that aggregates the functionality of all wallet types
+(shielded, unshielded, and dust). It simplifies wallet operations by providing:
+
+- Combined state management across all wallet types
+- Unified transaction balancing for shielded, unshielded, and dust tokens
+- Coordinated transfer and swap operations
+- Simplified transaction finalization flow
+- Dust registration management
+
+## Usage
+
+### Initializing the Facade
+
+```typescript
+import { WalletFacade } from '@midnight-ntwrk/wallet-sdk-facade';
+
+const facade = new WalletFacade(shieldedWallet, unshieldedWallet, dustWallet);
+
+// Start all wallets
+await facade.start(shieldedSecretKeys, dustSecretKey);
+```
+
+### Observing Combined State
+
+```typescript
+facade.state().subscribe((state) => {
+  console.log('Shielded:', state.shielded);
+  console.log('Unshielded:', state.unshielded);
+  console.log('Dust:', state.dust);
+  console.log('All synced:', state.isSynced);
+});
+
+// Or wait for full sync
+const syncedState = await facade.waitForSyncedState();
+```
+
+### Creating Transfer Transactions
+
+```typescript
+const recipe = await facade.transferTransaction(
+  [
+    {
+      type: 'shielded',
+      outputs: [{ type: 'TOKEN_B', receiverAddress: shieldedAddr, amount: 1000n }],
+    },
+    {
+      type: 'unshielded',
+      outputs: [{ type: 'TOKEN_A', receiverAddress: unshieldedAddr, amount: 500n }],
+    },
+  ],
+  { shieldedSecretKeys, dustSecretKey },
+  { ttl: new Date(Date.now() + 3600000) },
+);
+```
+
+### Balancing Transactions
+
+```typescript
+// Balance a finalized transaction
+const recipe = await facade.balanceFinalizedTransaction(
+  finalizedTx,
+  { shieldedSecretKeys, dustSecretKey },
+  { ttl, tokenKindsToBalance: 'all' }, // or ['shielded', 'dust']
+);
+
+// Finalize the balanced recipe
+const finalTx = await facade.finalizeRecipe(recipe);
+
+// Submit to the network
+const txId = await facade.submitTransaction(finalTx);
+```
+
+### Creating Swap Offers
+
+```typescript
+const swapRecipe = await facade.initSwap(
+  { shielded: { NIGHT: 1000n } }, // inputs
+  [{ type: 'shielded', outputs: [{ type: 'TOKEN_A', receiverAddress, amount: 100n }] }], // outputs
+  { shieldedSecretKeys, dustSecretKey },
+  { ttl, payFees: false },
+);
+```
+
+### Dust Registration
+
+```typescript
+// Register Night UTXOs for dust generation
+const registrationRecipe = await facade.registerNightUtxosForDustGeneration(
+  nightUtxos,
+  nightVerifyingKey,
+  signDustRegistration,
+);
+
+// Estimate registration costs
+const { fee, dustGenerationEstimations } = await facade.estimateRegistration(nightUtxos);
+```
+
+## Types
+
+### BalancingRecipe
+
+The facade returns different recipe types depending on the input transaction:
+
+- `FinalizedTransactionRecipe` - For finalized transactions
+- `UnboundTransactionRecipe` - For unbound transactions
+- `UnprovenTransactionRecipe` - For unproven transactions
+
+### TokenKindsToBalance
+
+Control which token types to balance:
+
+```typescript
+type TokenKindsToBalance = 'all' | ('dust' | 'shielded' | 'unshielded')[];
+```
+
+## License
+
+Apache-2.0

package/dist/index.d.ts

@@ -1,10 +1,34 @@
 import { Observable } from 'rxjs';
 import { ShieldedWalletState, type ShieldedWallet } from '@midnight-ntwrk/wallet-sdk-shielded';
 import { type UnshieldedWallet, UnshieldedWalletState } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
-import { type Utxo } from '@midnight-ntwrk/wallet-sdk-unshielded-state';
-import { AnyTransaction, DustWallet, DustWalletState } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
-import { ProvingRecipe } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
-import * as ledger from '@midnight-ntwrk/ledger-v6';
+import { AnyTransaction, DustWallet, DustWalletState, CoinsAndBalances as DustCoinsAndBalances } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+export type UnboundTransaction = ledger.Transaction<ledger.SignatureEnabled, ledger.Proof, ledger.PreBinding>;
+type TokenKind = 'dust' | 'shielded' | 'unshielded';
+type TokenKindsToBalance = 'all' | TokenKind[];
+declare const TokenKindsToBalance: {
+    allTokenKinds: string[];
+    toFlags: (tokenKinds: TokenKindsToBalance) => {
+        shouldBalanceUnshielded: boolean;
+        shouldBalanceShielded: boolean;
+        shouldBalanceDust: boolean;
+    };
+};
+export type FinalizedTransactionRecipe = {
+    type: 'FINALIZED_TRANSACTION';
+    originalTransaction: ledger.FinalizedTransaction;
+    balancingTransaction: ledger.UnprovenTransaction;
+};
+export type UnboundTransactionRecipe = {
+    type: 'UNBOUND_TRANSACTION';
+    baseTransaction: UnboundTransaction;
+    balancingTransaction?: ledger.UnprovenTransaction | undefined;
+};
+export type UnprovenTransactionRecipe = {
+    type: 'UNPROVEN_TRANSACTION';
+    transaction: ledger.UnprovenTransaction;
+};
+export type BalancingRecipe = FinalizedTransactionRecipe | UnboundTransactionRecipe | UnprovenTransactionRecipe;
 export interface TokenTransfer {
     type: ledger.RawTokenType;
     receiverAddress: string;
@@ -20,25 +44,78 @@ export type CombinedSwapInputs = {
 };
 export type CombinedSwapOutputs = CombinedTokenTransfer;
 export type TransactionIdentifier = string;
+export type UtxoWithMeta = {
+    utxo: ledger.Utxo;
+    meta: {
+        ctime: Date;
+    };
+};
+export declare class FacadeState {
+    readonly shielded: ShieldedWalletState;
+    readonly unshielded: UnshieldedWalletState;
+    readonly dust: DustWalletState;
+    get isSynced(): boolean;
+    constructor(shielded: ShieldedWalletState, unshielded: UnshieldedWalletState, dust: DustWalletState);
+}
 export declare class WalletFacade {
-    shielded: ShieldedWallet;
-    unshielded: UnshieldedWallet;
-    dust: DustWallet;
+    readonly shielded: ShieldedWallet;
+    readonly unshielded: UnshieldedWallet;
+    readonly dust: DustWallet;
     constructor(shieldedWallet: ShieldedWallet, unshieldedWallet: UnshieldedWallet, dustWallet: DustWallet);
-    state(): Observable<{
-        shielded: ShieldedWalletState;
-        unshielded: UnshieldedWalletState;
-        dust: DustWalletState;
-    }>;
+    private defaultTtl;
+    private mergeUnprovenTransactions;
+    private createDustActionTransaction;
+    state(): Observable<FacadeState>;
+    waitForSyncedState(): Promise<FacadeState>;
     submitTransaction(tx: ledger.FinalizedTransaction): Promise<TransactionIdentifier>;
-    balanceTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKeys: ledger.DustSecretKey, tx: ledger.Transaction<ledger.SignatureEnabled, ledger.Proofish, ledger.Bindingish>, ttl: Date): Promise<ProvingRecipe.ProvingRecipe<ledger.FinalizedTransaction>>;
-    finalizeTransaction(recipe: ProvingRecipe.ProvingRecipe<ledger.FinalizedTransaction>): Promise<ledger.FinalizedTransaction>;
-    signTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    balanceFinalizedTransaction(tx: ledger.FinalizedTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<FinalizedTransactionRecipe>;
+    balanceUnboundTransaction(tx: UnboundTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<UnboundTransactionRecipe>;
+    balanceUnprovenTransaction(tx: ledger.UnprovenTransaction, secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        tokenKindsToBalance?: TokenKindsToBalance;
+    }): Promise<UnprovenTransactionRecipe>;
+    finalizeRecipe(recipe: BalancingRecipe): Promise<ledger.FinalizedTransaction>;
+    signRecipe(recipe: BalancingRecipe, signSegment: (data: Uint8Array) => ledger.Signature): Promise<BalancingRecipe>;
+    signUnprovenTransaction(tx: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
+    signUnboundTransaction(tx: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;
+    finalizeTransaction(tx: ledger.UnprovenTransaction): Promise<ledger.FinalizedTransaction>;
     calculateTransactionFee(tx: AnyTransaction): Promise<bigint>;
-    transferTransaction(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey, outputs: CombinedTokenTransfer[], ttl: Date): Promise<ProvingRecipe.TransactionToProve>;
-    registerNightUtxosForDustGeneration(nightUtxos: Utxo[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => Promise<ledger.Signature> | ledger.Signature, dustReceiverAddress?: string): Promise<ProvingRecipe.TransactionToProve>;
-    initSwap(zswapSecretKeys: ledger.ZswapSecretKeys, desiredInputs: CombinedSwapInputs, desiredOutputs: CombinedSwapOutputs[], ttl: Date): Promise<ledger.UnprovenTransaction>;
-    deregisterFromDustGeneration(nightUtxos: Utxo[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => Promise<ledger.Signature> | ledger.Signature): Promise<ProvingRecipe.TransactionToProve>;
-    start(zswapSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey): Promise<void>;
+    transferTransaction(outputs: CombinedTokenTransfer[], secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        payFees?: boolean;
+    }): Promise<UnprovenTransactionRecipe>;
+    estimateRegistration(nightUtxos: readonly UtxoWithMeta[]): Promise<{
+        fee: bigint;
+        dustGenerationEstimations: ReadonlyArray<DustCoinsAndBalances.UtxoWithFullDustDetails>;
+    }>;
+    initSwap(desiredInputs: CombinedSwapInputs, desiredOutputs: CombinedSwapOutputs[], secretKeys: {
+        shieldedSecretKeys: ledger.ZswapSecretKeys;
+        dustSecretKey: ledger.DustSecretKey;
+    }, options: {
+        ttl: Date;
+        payFees?: boolean;
+    }): Promise<UnprovenTransactionRecipe>;
+    registerNightUtxosForDustGeneration(nightUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature, dustReceiverAddress?: string): Promise<UnprovenTransactionRecipe>;
+    deregisterFromDustGeneration(nightUtxos: UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature): Promise<UnprovenTransactionRecipe>;
+    start(shieldedSecretKeys: ledger.ZswapSecretKeys, dustSecretKey: ledger.DustSecretKey): Promise<void>;
     stop(): Promise<void>;
 }
+export {};

package/dist/index.js

@@ -1,5 +1,44 @@
+// 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 { combineLatest, map } from 'rxjs';
-import { ProvingRecipe } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+import { Array as Arr, pipe } from 'effect';
+import * as ledger from '@midnight-ntwrk/ledger-v7';
+const TokenKindsToBalance = new (class {
+    allTokenKinds = ['shielded', 'unshielded', 'dust'];
+    toFlags = (tokenKinds) => {
+        return pipe(tokenKinds, (kinds) => (kinds === 'all' ? this.allTokenKinds : kinds), (kinds) => ({
+            shouldBalanceUnshielded: kinds.includes('unshielded'),
+            shouldBalanceShielded: kinds.includes('shielded'),
+            shouldBalanceDust: kinds.includes('dust'),
+        }));
+    };
+})();
+export class FacadeState {
+    shielded;
+    unshielded;
+    dust;
+    get isSynced() {
+        return (this.shielded.state.progress.isStrictlyComplete() &&
+            this.dust.state.progress.isStrictlyComplete() &&
+            this.unshielded.progress.isStrictlyComplete());
+    }
+    constructor(shielded, unshielded, dust) {
+        this.shielded = shielded;
+        this.unshielded = unshielded;
+        this.dust = dust;
+    }
+}
+const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
 export class WalletFacade {
     shielded;
     unshielded;
@@ -9,51 +48,188 @@ export class WalletFacade {
         this.unshielded = unshieldedWallet;
         this.dust = dustWallet;
     }
+    defaultTtl() {
+        return new Date(Date.now() + DEFAULT_TTL_MS);
+    }
+    mergeUnprovenTransactions(a, b) {
+        if (a && b)
+            return a.merge(b);
+        return a ?? b;
+    }
+    async createDustActionTransaction(action, nightUtxos, nightVerifyingKey, signDustRegistration) {
+        const ttl = this.defaultTtl();
+        const transaction = await this.dust.createDustGenerationTransaction(undefined, ttl, nightUtxos.map(({ utxo, meta }) => ({ ...utxo, ctime: meta.ctime })), nightVerifyingKey, action.type === 'registration' ? action.dustReceiverAddress : undefined);
+        const intent = transaction.intents?.get(1);
+        if (!intent) {
+            throw Error('Dust generation transaction is missing intent segment 1.');
+        }
+        const signatureData = intent.signatureData(1);
+        const signature = await Promise.resolve(signDustRegistration(signatureData));
+        return await this.dust.addDustGenerationSignature(transaction, signature);
+    }
     state() {
-        return combineLatest([this.shielded.state, this.unshielded.state(), this.dust.state]).pipe(map(([shieldedState, unshieldedState, dustState]) => ({
-            shielded: shieldedState,
-            unshielded: unshieldedState,
-            dust: dustState,
-        })));
+        return combineLatest([this.shielded.state, this.unshielded.state, this.dust.state]).pipe(map(([shieldedState, unshieldedState, dustState]) => new FacadeState(shieldedState, unshieldedState, dustState)));
+    }
+    async waitForSyncedState() {
+        const [shieldedState, unshieldedState, dustState] = await Promise.all([
+            this.shielded.waitForSyncedState(),
+            this.unshielded.waitForSyncedState(),
+            this.dust.waitForSyncedState(),
+        ]);
+        return new FacadeState(shieldedState, unshieldedState, dustState);
     }
     async submitTransaction(tx) {
         await this.shielded.submitTransaction(tx, 'Finalized');
         return tx.identifiers().at(-1);
     }
-    async balanceTransaction(zswapSecretKeys, dustSecretKeys, tx, ttl) {
-        const unshieldedBalancedTx = await this.unshielded.balanceTransaction(tx);
-        const recipe = await this.shielded.balanceTransaction(zswapSecretKeys, unshieldedBalancedTx, []);
+    async balanceFinalizedTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const unshieldedBalancingTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceFinalizedTransaction(tx)
+            : undefined;
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
+        // Step 2: Merge unshielded and shielded balancing
+        const mergedBalancingTx = this.mergeUnprovenTransactions(shieldedBalancingTx, unshieldedBalancingTx);
+        // Step 3: Conditionally add dust/fee balancing
+        const feeBalancingTx = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, mergedBalancingTx ? [tx, mergedBalancingTx] : [tx], ttl)
+            : undefined;
+        // Step 4: Merge fee balancing and create final recipe
+        const balancingTx = this.mergeUnprovenTransactions(mergedBalancingTx, feeBalancingTx);
+        if (!balancingTx) {
+            throw new Error('No balancing transaction was created. Please check your transaction.');
+        }
+        return {
+            type: 'FINALIZED_TRANSACTION',
+            originalTransaction: tx,
+            balancingTransaction: balancingTx,
+        };
+    }
+    async balanceUnboundTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
+        // For unbound transactions, unshielded balancing happens in place not with a balancing transaction
+        const balancedUnshieldedTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceUnboundTransaction(tx)
+            : undefined;
+        // Step 2: Unbound unshielded tx are balanced in place, use it as base tx if present
+        const baseTx = balancedUnshieldedTx ?? tx;
+        // Step 3: Conditionally add dust/fee balancing
+        const feeBalancingTransaction = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, shieldedBalancingTx ? [baseTx, shieldedBalancingTx] : [baseTx], ttl)
+            : undefined;
+        // Step 4: Create the final balancing transaction
+        const balancingTransaction = this.mergeUnprovenTransactions(shieldedBalancingTx, feeBalancingTransaction);
+        // if there is no balancingTransaction and there was no unshielded tx balancing (in place) throw an error.
+        if (!balancingTransaction && !balancedUnshieldedTx) {
+            throw new Error('No balancing transaction was created. Please check your transaction.');
+        }
+        return {
+            type: 'UNBOUND_TRANSACTION',
+            baseTransaction: baseTx,
+            balancingTransaction: balancingTransaction ?? undefined,
+        };
+    }
+    async balanceUnprovenTransaction(tx, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, tokenKindsToBalance = 'all' } = options;
+        const { shouldBalanceDust, shouldBalanceShielded, shouldBalanceUnshielded } = TokenKindsToBalance.toFlags(tokenKindsToBalance);
+        // Step 1: Run unshielded and shielded balancing
+        const shieldedBalancingTx = shouldBalanceShielded
+            ? await this.shielded.balanceTransaction(shieldedSecretKeys, tx)
+            : undefined;
+        // For unproven transactions, unshielded balancing happens in place
+        const balancedUnshieldedTx = shouldBalanceUnshielded
+            ? await this.unshielded.balanceUnprovenTransaction(tx)
+            : undefined;
+        // Step 2: Use the balanced unshielded tx if present, otherwise use the original tx
+        const baseTx = balancedUnshieldedTx ?? tx;
+        // Step 3: Merge shielded balancing into base tx if present
+        const mergedTx = this.mergeUnprovenTransactions(baseTx, shieldedBalancingTx);
+        // Step 4: Conditionally add dust/fee balancing
+        const feeBalancingTx = shouldBalanceDust
+            ? await this.dust.balanceTransactions(dustSecretKey, [mergedTx], ttl)
+            : undefined;
+        // Step 5: Merge fee balancing if present
+        const balancedTx = this.mergeUnprovenTransactions(mergedTx, feeBalancingTx);
+        return {
+            type: 'UNPROVEN_TRANSACTION',
+            transaction: balancedTx,
+        };
+    }
+    async finalizeRecipe(recipe) {
         switch (recipe.type) {
-            case ProvingRecipe.TRANSACTION_TO_PROVE:
-                return await this.dust.addFeePayment(dustSecretKeys, recipe.transaction, new Date(), ttl);
-            case ProvingRecipe.BALANCE_TRANSACTION_TO_PROVE: {
-                // if the shielded wallet returned a proven transaction, we need to pay fees with the dust wallet
-                const balancedTx = await this.dust.addFeePayment(dustSecretKeys, recipe.transactionToProve, new Date(), ttl);
-                if (balancedTx.type !== ProvingRecipe.TRANSACTION_TO_PROVE) {
-                    throw Error('Unexpected transaction type after adding fee payment.');
-                }
+            case 'FINALIZED_TRANSACTION': {
+                const finalizedBalancing = await this.finalizeTransaction(recipe.balancingTransaction);
+                return recipe.originalTransaction.merge(finalizedBalancing);
+            }
+            case 'UNBOUND_TRANSACTION': {
+                const finalizedBalancingTx = recipe.balancingTransaction
+                    ? await this.finalizeTransaction(recipe.balancingTransaction)
+                    : undefined;
+                const finalizedTransaction = recipe.baseTransaction.bind();
+                return finalizedBalancingTx ? finalizedTransaction.merge(finalizedBalancingTx) : finalizedTransaction;
+            }
+            case 'UNPROVEN_TRANSACTION': {
+                return await this.finalizeTransaction(recipe.transaction);
+            }
+        }
+    }
+    async signRecipe(recipe, signSegment) {
+        switch (recipe.type) {
+            case 'FINALIZED_TRANSACTION': {
+                const signedBalancingTx = await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment);
                 return {
-                    ...recipe,
-                    transactionToProve: balancedTx.transaction,
+                    type: 'FINALIZED_TRANSACTION',
+                    originalTransaction: recipe.originalTransaction,
+                    balancingTransaction: signedBalancingTx,
                 };
             }
-            case ProvingRecipe.NOTHING_TO_PROVE: {
-                // @TODO fix casting
-                const txToBalance = recipe.transaction;
-                return await this.dust.addFeePayment(dustSecretKeys, txToBalance, new Date(), ttl);
+            case 'UNBOUND_TRANSACTION': {
+                const signedBalancingTx = recipe.balancingTransaction
+                    ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment)
+                    : undefined;
+                const signedBaseTx = await this.signUnboundTransaction(recipe.baseTransaction, signSegment);
+                return {
+                    type: 'UNBOUND_TRANSACTION',
+                    baseTransaction: signedBaseTx,
+                    balancingTransaction: signedBalancingTx,
+                };
+            }
+            case 'UNPROVEN_TRANSACTION': {
+                const signedTx = await this.signUnprovenTransaction(recipe.transaction, signSegment);
+                return {
+                    type: 'UNPROVEN_TRANSACTION',
+                    transaction: signedTx,
+                };
             }
         }
     }
-    async finalizeTransaction(recipe) {
-        return await this.shielded.finalizeTransaction(recipe);
+    async signUnprovenTransaction(tx, signSegment) {
+        return await this.unshielded.signUnprovenTransaction(tx, signSegment);
+    }
+    async signUnboundTransaction(tx, signSegment) {
+        return await this.unshielded.signUnboundTransaction(tx, signSegment);
     }
-    async signTransaction(tx, signSegment) {
-        return await this.unshielded.signTransaction(tx, signSegment);
+    async finalizeTransaction(tx) {
+        return await this.shielded.finalizeTransaction(tx);
     }
     async calculateTransactionFee(tx) {
-        return await this.dust.calculateFee(tx);
+        return await this.dust.calculateFee([tx]);
     }
-    async transferTransaction(zswapSecretKeys, dustSecretKey, outputs, ttl) {
+    async transferTransaction(outputs, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, payFees = true } = options;
         const unshieldedOutputs = outputs
             .filter((output) => output.type === 'unshielded')
             .flatMap((output) => output.outputs);
@@ -61,69 +237,36 @@ export class WalletFacade {
         if (unshieldedOutputs.length === 0 && shieldedOutputs.length === 0) {
             throw Error('At least one shielded or unshielded output is required.');
         }
-        let shieldedTxRecipe = undefined;
-        let unshieldedTx = undefined;
-        if (unshieldedOutputs.length > 0) {
-            unshieldedTx = await this.unshielded.transferTransaction(unshieldedOutputs, ttl);
-        }
-        if (shieldedOutputs.length > 0) {
-            shieldedTxRecipe = await this.shielded.transferTransaction(zswapSecretKeys, shieldedOutputs);
-        }
-        // if there's a shielded tx only, return it as it's already balanced
-        if (shieldedTxRecipe !== undefined && unshieldedTx === undefined) {
-            if (shieldedTxRecipe.type !== 'TransactionToProve') {
-                throw Error('Unexpected transaction type.');
-            }
-            const recipe = await this.dust.addFeePayment(dustSecretKey, shieldedTxRecipe.transaction, new Date(), ttl);
-            if (recipe.type !== 'TransactionToProve') {
-                throw Error('Unexpected transaction type after adding fee payment.');
-            }
-            return recipe;
-        }
-        // if there's an unshielded tx only, pay fees (balance) with shielded wallet
-        if (shieldedTxRecipe === undefined && unshieldedTx !== undefined) {
-            const recipe = await this.dust.addFeePayment(dustSecretKey, unshieldedTx, new Date(), ttl);
-            if (recipe.type !== 'TransactionToProve') {
-                throw Error('Unexpected transaction type after adding fee payment.');
-            }
-            return recipe;
-        }
-        // if there's a shielded and unshielded tx, pay fees for unshielded and merge them
-        if (shieldedTxRecipe !== undefined && unshieldedTx !== undefined) {
-            if (shieldedTxRecipe.type !== 'TransactionToProve') {
-                throw Error('Unexpected transaction type.');
-            }
-            const txToBalance = shieldedTxRecipe.transaction.merge(unshieldedTx);
-            const recipe = await this.dust.addFeePayment(dustSecretKey, txToBalance, new Date(), ttl);
-            if (recipe.type !== 'TransactionToProve') {
-                throw Error('Unexpected transaction type after adding fee payment.');
-            }
-            return recipe;
-        }
-        throw Error('Unexpected transaction state.');
+        const shieldedTx = shieldedOutputs.length > 0
+            ? await this.shielded.transferTransaction(shieldedSecretKeys, shieldedOutputs)
+            : undefined;
+        const unshieldedTx = unshieldedOutputs.length > 0 ? await this.unshielded.transferTransaction(unshieldedOutputs, ttl) : undefined;
+        const mergedTxs = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+        // Add fee payment
+        const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [mergedTxs], ttl) : undefined;
+        const finalTx = this.mergeUnprovenTransactions(mergedTxs, feeBalancingTx);
+        return {
+            type: 'UNPROVEN_TRANSACTION',
+            transaction: finalTx,
+        };
     }
-    async registerNightUtxosForDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration, dustReceiverAddress) {
-        if (nightUtxos.length === 0) {
-            throw Error('At least one Night UTXO is required.');
-        }
+    async estimateRegistration(nightUtxos) {
+        const now = new Date();
         const dustState = await this.dust.waitForSyncedState();
-        const receiverAddress = dustReceiverAddress ?? dustState.dustAddress;
-        const nextBlock = new Date();
-        const ttl = new Date(nextBlock.getTime() + 60 * 60 * 1000);
-        const transaction = await this.dust.createDustGenerationTransaction(nextBlock, ttl, nightUtxos.map((utxo) => ({ ...utxo, ctime: new Date(utxo.ctime) })), nightVerifyingKey, receiverAddress);
-        const intent = transaction.intents?.get(1);
-        if (!intent) {
-            throw Error('Dust generation transaction is missing intent segment 1.');
-        }
-        const signatureData = intent.signatureData(1);
-        const signature = await Promise.resolve(signDustRegistration(signatureData));
-        const recipe = await this.dust.addDustGenerationSignature(transaction, signature);
-        if (recipe.type !== ProvingRecipe.TRANSACTION_TO_PROVE) {
-            throw Error('Unexpected recipe type returned when registering Night UTXOs.');
-        }
-        return recipe;
+        const dustGenerationEstimations = pipe(nightUtxos, Arr.map(({ utxo, meta }) => ({ ...utxo, ctime: meta.ctime })), (utxosWithMeta) => dustState.estimateDustGeneration(utxosWithMeta, now), (estimatedUtxos) => dustState.capabilities.coinsAndBalances.splitNightUtxos(estimatedUtxos), (split) => split.guaranteed);
+        const fakeSigningKey = ledger.sampleSigningKey();
+        const fakeVerifyingKey = ledger.signatureVerifyingKey(fakeSigningKey);
+        const fakeRegistrationRecipe = await this.registerNightUtxosForDustGeneration(nightUtxos, fakeVerifyingKey, (payload) => ledger.signData(fakeSigningKey, payload), dustState.dustAddress);
+        const finalizedFakeTx = fakeRegistrationRecipe.transaction.mockProve().bind();
+        const fee = await this.calculateTransactionFee(finalizedFakeTx);
+        return {
+            fee,
+            dustGenerationEstimations,
+        };
     }
-    async initSwap(zswapSecretKeys, desiredInputs, desiredOutputs, ttl) {
+    async initSwap(desiredInputs, desiredOutputs, secretKeys, options) {
+        const { shieldedSecretKeys, dustSecretKey } = secretKeys;
+        const { ttl, payFees = false } = options;
         const { shielded: shieldedInputs, unshielded: unshieldedInputs } = desiredInputs;
         const shieldedOutputs = desiredOutputs
             .filter((output) => output.type === 'shielded')
@@ -136,44 +279,48 @@ export class WalletFacade {
         if (!hasShieldedPart && !hasUnshieldedPart) {
             throw Error('At least one shielded or unshielded swap is required.');
         }
-        const shieldedTxRecipe = hasShieldedPart && shieldedInputs !== undefined
-            ? await this.shielded.initSwap(zswapSecretKeys, shieldedInputs, shieldedOutputs)
+        const shieldedTx = hasShieldedPart && shieldedInputs !== undefined
+            ? await this.shielded.initSwap(shieldedSecretKeys, shieldedInputs, shieldedOutputs)
             : undefined;
         const unshieldedTx = hasUnshieldedPart && unshieldedInputs !== undefined
             ? await this.unshielded.initSwap(unshieldedInputs, unshieldedOutputs, ttl)
             : undefined;
-        if (shieldedTxRecipe !== undefined && shieldedTxRecipe.type !== ProvingRecipe.TRANSACTION_TO_PROVE) {
-            throw Error('Unexpected transaction type.');
+        const combinedTx = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+        if (!combinedTx) {
+            throw Error('Unexpected transaction state.');
         }
-        if (shieldedTxRecipe && unshieldedTx) {
-            return shieldedTxRecipe.transaction.merge(unshieldedTx);
-        }
-        if (shieldedTxRecipe) {
-            return shieldedTxRecipe.transaction;
-        }
-        if (unshieldedTx) {
-            return unshieldedTx;
+        const feeBalancingTx = payFees ? await this.dust.balanceTransactions(dustSecretKey, [combinedTx], ttl) : undefined;
+        const finalTx = this.mergeUnprovenTransactions(combinedTx, feeBalancingTx);
+        return {
+            type: 'UNPROVEN_TRANSACTION',
+            transaction: finalTx,
+        };
+    }
+    async registerNightUtxosForDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration, dustReceiverAddress) {
+        if (nightUtxos.length === 0) {
+            throw Error('At least one Night UTXO is required.');
         }
-        throw Error('Unexpected transaction state.');
+        const dustState = await this.dust.waitForSyncedState();
+        const receiverAddress = dustReceiverAddress ?? dustState.dustAddress;
+        const dustRegistrationTx = await this.createDustActionTransaction({ type: 'registration', dustReceiverAddress: receiverAddress }, nightUtxos, nightVerifyingKey, signDustRegistration);
+        return {
+            type: 'UNPROVEN_TRANSACTION',
+            transaction: dustRegistrationTx,
+        };
     }
     async deregisterFromDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration) {
-        const nextBlock = new Date();
-        const ttl = new Date(nextBlock.getTime() + 60 * 60 * 1000);
-        const transaction = await this.dust.createDustGenerationTransaction(nextBlock, ttl, nightUtxos.map((utxo) => ({ ...utxo, ctime: new Date(utxo.ctime) })), nightVerifyingKey, undefined);
-        const intent = transaction.intents?.get(1);
-        if (!intent) {
-            throw Error('Dust generation transaction is missing intent segment 1.');
-        }
-        const signatureData = intent.signatureData(1);
-        const signature = await Promise.resolve(signDustRegistration(signatureData));
-        const recipe = await this.dust.addDustGenerationSignature(transaction, signature);
-        if (recipe.type !== ProvingRecipe.TRANSACTION_TO_PROVE) {
-            throw Error('Unexpected recipe type returned when registering Night UTXOs.');
-        }
-        return recipe;
+        const dustDeregistrationTx = await this.createDustActionTransaction({ type: 'deregistration' }, nightUtxos, nightVerifyingKey, signDustRegistration);
+        return {
+            type: 'UNPROVEN_TRANSACTION',
+            transaction: dustDeregistrationTx,
+        };
     }
-    async start(zswapSecretKeys, dustSecretKey) {
-        await Promise.all([this.shielded.start(zswapSecretKeys), this.unshielded.start(), this.dust.start(dustSecretKey)]);
+    async start(shieldedSecretKeys, dustSecretKey) {
+        await Promise.all([
+            this.shielded.start(shieldedSecretKeys),
+            this.unshielded.start(),
+            this.dust.start(dustSecretKey),
+        ]);
     }
     async stop() {
         await Promise.all([this.shielded.stop(), this.unshielded.stop(), this.dust.stop()]);

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "author": "IOHK",
+  "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
     "registry": "https://npm.pkg.github.com/"
@@ -24,28 +24,31 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v6": "6.1.0-alpha.5",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.7",
-    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.6",
-    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.9",
-    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0-beta.11",
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-hd": "3.0.0",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0",
     "rxjs": "^7.5"
   },
   "devDependencies": {
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0",
     "eslint": "^9.37.0",
+    "prettier": "^3.7.0",
     "publint": "~0.3.14",
     "rimraf": "^6.0.1",
-    "testcontainers": "^11.4.0",
+    "testcontainers": "^11.10.0",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.16"
   },
   "scripts": {
     "typecheck": "tsc -b ./tsconfig.json --noEmit",
     "test": "vitest run",
     "lint": "eslint --max-warnings 0",
-    "format": "prettier --write \"**/*.{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",