@midnight-ntwrk/wallet-sdk-unshielded-wallet 3.0.0 → 3.1.0

package/dist/UnshieldedWallet.d.ts

@@ -46,6 +46,13 @@ export type UnshieldedWalletAPI<TSerialized = string> = {
     balanceUnboundTransaction(tx: UnboundTransaction): Promise<UnboundTransactionBalanceResult>;
     balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Promise<UnprovenTransactionBalanceResult>;
     transferTransaction(outputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
+    /**
+     * Books a caller-supplied set of Night UTxOs and returns an unproven transaction that moves them back to the same
+     * owner, split between the guaranteed (segment 0) and fallible (segment 1) sections of a single intent. Booking moves
+     * the UTxOs from available to pending so a concurrent build call cannot reuse them. The fallible section is available
+     * for callers that want to attach further actions (e.g. a Dust registration) at segment 1.
+     */
+    rotateUtxos(guaranteedUtxos: readonly UtxoWithMeta[], fallibleUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Promise<ledger.UnprovenTransaction>;
     initSwap(desiredInputs: Record<ledger.RawTokenType, bigint>, desiredOutputs: readonly TokenTransfer[], ttl: Date): Promise<ledger.UnprovenTransaction>;
     signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<ledger.UnprovenTransaction>;
     signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Promise<UnboundTransaction>;

package/dist/UnshieldedWallet.js

@@ -106,6 +106,13 @@ export function CustomUnshieldedWallet(configuration, builder) {
             })
                 .pipe(Effect.runPromise);
         }
+        rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+            return this.runtime
+                .dispatch({
+                [V1Tag]: (v1) => v1.rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl),
+            })
+                .pipe(Effect.runPromise);
+        }
         initSwap(desiredInputs, desiredOutputs, ttl) {
             return this.runtime
                 .dispatch({ [V1Tag]: (v1) => v1.initSwap(desiredInputs, desiredOutputs, ttl) })

package/dist/v1/RunningV1Variant.d.ts

@@ -4,6 +4,7 @@ import { type SerializationCapability } from './Serialization.js';
 import { type SyncCapability, type SyncService } from './Sync.js';
 import { type WalletSyncUpdate } from './SyncSchema.js';
 import { type TransactingCapability, type TokenTransfer, type FinalizedTransactionBalanceResult, type UnboundTransactionBalanceResult, type UnprovenTransactionBalanceResult } from './Transacting.js';
+import { type UtxoWithMeta } from './UnshieldedState.js';
 import { type UnboundTransaction } from './TransactionOps.js';
 import { type WalletError } from './WalletError.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
@@ -38,6 +39,7 @@ export declare class RunningV1Variant<TSerialized, TSyncUpdate> implements Varia
     balanceUnboundTransaction(tx: UnboundTransaction): Effect.Effect<UnboundTransactionBalanceResult, WalletError>;
     balanceUnprovenTransaction(tx: ledger.UnprovenTransaction): Effect.Effect<UnprovenTransactionBalanceResult, WalletError>;
     transferTransaction(outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
+    rotateUtxos(guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     initSwap(desiredInputs: Record<string, bigint>, desiredOutputs: ReadonlyArray<TokenTransfer>, ttl: Date): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     signUnprovenTransaction(transaction: ledger.UnprovenTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<ledger.UnprovenTransaction, WalletError>;
     signUnboundTransaction(transaction: UnboundTransaction, signSegment: (data: Uint8Array) => ledger.Signature): Effect.Effect<UnboundTransaction, WalletError>;

package/dist/v1/RunningV1Variant.js

@@ -87,6 +87,11 @@ export class RunningV1Variant {
             return pipe(this.#v1Context.transactingCapability.makeTransfer(state, outputs, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
         });
     }
+    rotateUtxos(guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+        return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
+            return pipe(this.#v1Context.transactingCapability.rotateUtxos(state, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl), EitherOps.toEffect, Effect.map(({ transaction, newState }) => [transaction, newState]));
+        });
+    }
     initSwap(desiredInputs, desiredOutputs, ttl) {
         return SubscriptionRef.modifyEffect(this.#context.stateRef, (state) => {
             return pipe(this.#v1Context.transactingCapability.initSwap(state, desiredInputs, desiredOutputs, ttl), Effect.map(({ transaction, newState }) => [transaction, newState]));

package/dist/v1/Transacting.d.ts

@@ -3,6 +3,7 @@ import { type NetworkId } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { Either } from 'effect';
 import { CoreWallet } from './CoreWallet.js';
 import { type WalletError } from './WalletError.js';
+import { type UtxoWithMeta } from './UnshieldedState.js';
 import { type CoinSelection } from '@midnight-ntwrk/wallet-sdk-capabilities';
 import { TransactionOps, type UnboundTransaction } from './TransactionOps.js';
 import { type CoinsAndBalancesCapability } from './CoinsAndBalances.js';
@@ -23,6 +24,23 @@ export type TransactingResult<TTransaction, TState> = {
 export interface TransactingCapability<TState> {
     makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
     initSwap(wallet: CoreWallet, desiredInputs: Record<string, bigint>, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
+    /**
+     * Builds an unproven transaction that moves a caller-supplied set of Night UTxOs back to their current owner,
+     * splitting them between the guaranteed and fallible sections of a single intent. The provided UTxOs are booked in
+     * the wallet state (moved from available to pending) so that no subsequent build call can pick them.
+     *
+     * Used by the Dust wallet's registration/deregistration flow, where the Dust wallet picks the guaranteed slot (based
+     * on dust generation) and hands both sets here for booking and intent construction. The Dust wallet then attaches its
+     * DustActions onto the returned intent.
+     *
+     * @param wallet - The wallet whose UTxOs are being passed through
+     * @param guaranteedUtxos - UTxOs to place in the guaranteed offer (segment 0)
+     * @param fallibleUtxos - UTxOs to place in the fallible offer (segment 1+)
+     * @param nightVerifyingKey - The verifying key used as the input owner and the address for the consolidating output
+     * @param ttl - The TTL for the transaction
+     * @returns The new wallet state (with all provided UTxOs booked) and the unproven transaction
+     */
+    rotateUtxos(wallet: CoreWallet, guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, TState>, WalletError>;
     balanceFinalizedTransaction(wallet: CoreWallet, transaction: ledger.FinalizedTransaction): Either.Either<[FinalizedTransactionBalanceResult, CoreWallet], WalletError>;
     balanceUnboundTransaction(wallet: CoreWallet, transaction: UnboundTransaction): Either.Either<[UnboundTransactionBalanceResult, CoreWallet], WalletError>;
     balanceUnprovenTransaction(wallet: CoreWallet, transaction: ledger.UnprovenTransaction): Either.Either<[UnprovenTransactionBalanceResult, CoreWallet], WalletError>;
@@ -82,6 +100,7 @@ export declare class TransactingCapabilityImplementation implements TransactingC
      * @returns The balanced transfer transaction and the new wallet state if successful, otherwise an error
      */
     makeTransfer(wallet: CoreWallet, outputs: ReadonlyArray<TokenTransfer>, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
+    rotateUtxos(wallet: CoreWallet, guaranteedUtxos: ReadonlyArray<UtxoWithMeta>, fallibleUtxos: ReadonlyArray<UtxoWithMeta>, nightVerifyingKey: ledger.SignatureVerifyingKey, ttl: Date): Either.Either<TransactingResult<ledger.UnprovenTransaction, CoreWallet>, WalletError>;
     /**
      * Initializes a swap transaction
      *

package/dist/v1/Transacting.js

@@ -85,9 +85,7 @@ export class TransactingCapabilityImplementation {
             const balancingIntent = ledger.Intent.new(intent.ttl);
             balancingIntent.guaranteedUnshieldedOffer = offer;
             const segmentId = Option.getOrElse(this.txOps.findAvailableSegmentId(transaction), () => 1);
-            // @TODO in ledger 8.1.0 will be able to set the segment id when constructing the tx
-            const balancingTx = ledger.Transaction.fromParts(this.networkId, undefined, undefined, undefined);
-            balancingTx.intents = new Map([[segmentId, balancingIntent]]);
+            const balancingTx = ledger.Transaction.fromParts(this.networkId).addIntent({ tag: 'specific', value: segmentId }, balancingIntent);
             return [balancingTx, newState];
         });
     }
@@ -132,6 +130,56 @@ export class TransactingCapabilityImplementation {
             };
         });
     }
+    rotateUtxos(wallet, guaranteedUtxos, fallibleUtxos, nightVerifyingKey, ttl) {
+        return Either.gen(this, function* () {
+            const { networkId } = this;
+            if (guaranteedUtxos.length === 0 && fallibleUtxos.length === 0) {
+                return yield* Either.left(new TransactingError({ message: 'At least one UTxO must be provided to rotateUtxos' }));
+            }
+            const ownerAddress = ledger.addressFromKey(nightVerifyingKey);
+            const makeOffer = (utxos) => {
+                if (utxos.length === 0) {
+                    return Option.none();
+                }
+                const inputs = utxos.map(({ utxo }) => ({
+                    value: utxo.value,
+                    type: utxo.type,
+                    intentHash: utxo.intentHash,
+                    outputNo: utxo.outputNo,
+                    owner: nightVerifyingKey,
+                }));
+                const totalValue = pipe(utxos, Arr.map(({ utxo }) => utxo.value), Arr.reduce(0n, (a, b) => a + b));
+                const output = {
+                    owner: ownerAddress,
+                    type: ledger.nativeToken().raw,
+                    value: totalValue,
+                };
+                return Option.some(ledger.UnshieldedOffer.new(inputs, [output], []));
+            };
+            const allUtxos = [...guaranteedUtxos, ...fallibleUtxos].map(({ utxo }) => utxo);
+            const [, walletAfterBooking] = yield* CoreWallet.spendUtxos(wallet, allUtxos);
+            const guaranteedOffer = makeOffer(guaranteedUtxos);
+            const fallibleOffer = makeOffer(fallibleUtxos);
+            const intent = pipe(ledger.Intent.new(ttl), (i) => Option.match(guaranteedOffer, {
+                onNone: () => i,
+                onSome: (offer) => {
+                    i.guaranteedUnshieldedOffer = offer;
+                    return i;
+                },
+            }), (i) => Option.match(fallibleOffer, {
+                onNone: () => i,
+                onSome: (offer) => {
+                    i.fallibleUnshieldedOffer = offer;
+                    return i;
+                },
+            }));
+            const transaction = ledger.Transaction.fromParts(networkId, undefined, undefined, intent);
+            return {
+                newState: walletAfterBooking,
+                transaction,
+            };
+        });
+    }
     /**
      * Initializes a swap transaction
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-unshielded-wallet",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -28,13 +28,13 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v8": "^8.0.3",
-    "@midnight-ntwrk/wallet-sdk-abstractions": "2.1.0",
-    "@midnight-ntwrk/wallet-sdk-address-format": "3.1.1",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "3.3.0",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "1.2.1",
-    "@midnight-ntwrk/wallet-sdk-runtime": "1.0.3",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.1.1",
+    "@midnight-ntwrk/ledger-v8": "^8.1.0",
+    "@midnight-ntwrk/wallet-sdk-abstractions": "^2.1.0",
+    "@midnight-ntwrk/wallet-sdk-address-format": "^3.1.2",
+    "@midnight-ntwrk/wallet-sdk-capabilities": "^3.3.1",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "^1.2.2",
+    "@midnight-ntwrk/wallet-sdk-runtime": "^1.0.4",
+    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.0",
     "effect": "^3.19.19",
     "rxjs": "^7.8.2"
   },
@@ -50,6 +50,6 @@
     "publint": "publint --strict"
   },
   "devDependencies": {
-    "@midnight-ntwrk/wallet-sdk-hd": "3.0.2"
+    "@midnight-ntwrk/wallet-sdk-hd": "^3.0.2"
   }
 }