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

package/dist/index.d.ts

@@ -1,9 +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 { AnyTransaction, DustWallet, DustWalletState } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
-import { ProvingRecipe } from '@midnight-ntwrk/wallet-sdk-shielded/v1';
+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;
@@ -33,20 +58,64 @@ export declare class FacadeState {
     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);
+    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: readonly UtxoWithMeta[], 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: UtxoWithMeta[], 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

@@ -11,7 +11,18 @@
 // 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;
@@ -27,6 +38,7 @@ export class FacadeState {
         this.dust = dust;
     }
 }
+const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
 export class WalletFacade {
     shielded;
     unshielded;
@@ -36,47 +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]) => 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 '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 ProvingRecipe.TRANSACTION_TO_PROVE:
-                return await this.dust.addFeePayment(dustSecretKeys, recipe.transaction, 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, ttl);
-                if (balancedTx.type !== ProvingRecipe.TRANSACTION_TO_PROVE) {
-                    throw Error('Unexpected transaction type after adding fee payment.');
-                }
+            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, 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 signTransaction(tx, signSegment) {
-        return await this.unshielded.signTransaction(tx, signSegment);
+    async signUnboundTransaction(tx, signSegment) {
+        return await this.unshielded.signUnboundTransaction(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);
@@ -84,68 +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, 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, 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, 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 ttl = new Date(Date.now() + 60 * 60 * 1000);
-        const transaction = await this.dust.createDustGenerationTransaction(undefined, ttl, nightUtxos.map(({ utxo, meta }) => ({ ...utxo, ctime: meta.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')
@@ -158,43 +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.');
-        }
-        if (shieldedTxRecipe && unshieldedTx) {
-            return shieldedTxRecipe.transaction.merge(unshieldedTx);
-        }
-        if (shieldedTxRecipe) {
-            return shieldedTxRecipe.transaction;
+        const combinedTx = this.mergeUnprovenTransactions(shieldedTx, unshieldedTx);
+        if (!combinedTx) {
+            throw Error('Unexpected transaction state.');
         }
-        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 ttl = new Date(Date.now() + 60 * 60 * 1000);
-        const transaction = await this.dust.createDustGenerationTransaction(undefined, ttl, nightUtxos.map(({ utxo, meta }) => ({ ...utxo, ctime: meta.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,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -24,16 +24,17 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v7": "7.0.0-rc.1",
+    "@midnight-ntwrk/ledger-v7": "7.0.0",
     "@midnight-ntwrk/wallet-sdk-abstractions": "1.0.0-beta.10",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.11",
-    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0-beta.14",
+    "@midnight-ntwrk/wallet-sdk-address-format": "3.0.0-beta.12",
+    "@midnight-ntwrk/wallet-sdk-dust-wallet": "1.0.0-beta.16",
     "@midnight-ntwrk/wallet-sdk-hd": "3.0.0-beta.8",
-    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.15",
-    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0-beta.17",
+    "@midnight-ntwrk/wallet-sdk-shielded": "1.0.0-beta.17",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "1.0.0-beta.19",
     "rxjs": "^7.5"
   },
   "devDependencies": {
+    "@midnight-ntwrk/wallet-sdk-prover-client": "1.0.0-beta.14",
     "eslint": "^9.37.0",
     "prettier": "^3.7.0",
     "publint": "~0.3.14",