@midnight-ntwrk/wallet-sdk-facade 4.0.0 → 4.1.0

package/README.md

@@ -1,3 +1,10 @@
+> [!IMPORTANT]
+> **This package has moved.** The `@midnight-ntwrk` scope is published only
+> during the migration window and will stop receiving updates. Please migrate to
+> [`@midnightntwrk/wallet-sdk-facade`](https://www.npmjs.com/package/@midnightntwrk/wallet-sdk-facade).
+
+---
+
 # @midnight-ntwrk/wallet-sdk-facade
 
 > **Note:** It is recommended to use the [`@midnight-ntwrk/wallet-sdk`](../wallet-sdk/README.md) barrel package, which
@@ -24,6 +31,11 @@ The Wallet Facade provides a high-level unified interface that aggregates the fu
 
 ## Usage
 
+More detailed and complete examples can be found at [docs snippets](../docs-snippets/src/snippets) (always up-to-date
+with the recent changes) or at the
+[SDK documentation site](https://docs.midnight.network/sdks/official/wallet-developer-guide) (aligned with the recent
+release)
+
 ### Initializing the Facade
 
 ```typescript

package/dist/index.d.ts

@@ -6,6 +6,7 @@ import { type AnyTransaction, type CoinsAndBalances as DustCoinsAndBalances } fr
 import { type DefaultShieldedConfiguration, type ShieldedWalletAPI, type ShieldedWalletState } from '@midnight-ntwrk/wallet-sdk-shielded';
 import type { DefaultUnshieldedConfiguration, UnshieldedWalletAPI } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 import { type UnshieldedWalletState } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
+import { Clock } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { Schema } from 'effect';
 import { TransactionHistoryStorage } from '@midnight-ntwrk/wallet-sdk-abstractions';
 import { type Observable } from 'rxjs';
@@ -137,14 +138,16 @@ export declare class FacadeState {
     constructor(shielded: ShieldedWalletState, unshielded: UnshieldedWalletState, dust: DustWalletState, pending: PendingTransactions.PendingTransactions<ledger.FinalizedTransaction>);
 }
 /**
- * A clock abstraction for obtaining the current time. By default, the facade uses the system clock. For testing with a
- * simulator, inject a custom clock (e.g., one backed by the simulator's time).
+ * Clock abstraction for obtaining the current time. By default, the facade uses the system clock
+ * ({@link Clock.systemClock}); for testing with a simulator, inject a custom clock (e.g. one backed by the simulator's
+ * time).
+ *
+ * Re-exported from `@midnight-ntwrk/wallet-sdk-utilities` as a namespace so the type is `Clock.Clock` and the default is
+ * `Clock.systemClock`. Forwarding the same symbol — rather than re-declaring its members individually — keeps the
+ * umbrella `wallet-sdk` package's star-exports unambiguous and lets lower-level packages (e.g. dust-wallet) share it
+ * without a circular dependency.
  */
-export type Clock = {
-    readonly now: () => Date;
-};
-/** Default clock using real system time. */
-export declare const systemClock: Clock;
+export { Clock };
 /**
  * The Terms and Conditions returned by the indexer, containing a URL for display and a SHA-256 hash for content
  * verification.
@@ -168,10 +171,16 @@ export type FetchTermsAndConditionsConfiguration = {
 };
 export type DefaultConfiguration = DefaultUnshieldedConfiguration & DefaultShieldedConfiguration & DefaultDustConfiguration & DefaultSubmissionConfiguration & DefaultPendingTransactionsServiceConfiguration & Partial<DefaultProvingConfiguration>;
 type MaybePromise<T> = T | Promise<T>;
+/**
+ * Parameters object for {@link WalletFacade.init}. It features configuration and bunch of initializers for the wallets
+ * and services, all of them are in a form of a function that takes the configuration and returns proper implementation,
+ * either synchronously or wrapped in a Promise. Services are optional to provide ({@link WalletFacade.init} will provide
+ * default implementations), but all 3 wallets: shielded, unshielded and Dust one need to be present
+ */
 export type InitParams<TConfig extends DefaultConfiguration> = {
     configuration: TConfig;
     /** Optional factory for the clock abstraction. Defaults to system clock (`() => new Date()`). */
-    clock?: (config: TConfig) => MaybePromise<Clock>;
+    clock?: (config: TConfig) => MaybePromise<Clock.Clock>;
     submissionService?: (config: TConfig) => MaybePromise<SubmissionService<ledger.FinalizedTransaction>>;
     pendingTransactionsService?: (config: TConfig) => MaybePromise<PendingTransactionsService<ledger.FinalizedTransaction>>;
     provingService?: (config: TConfig) => MaybePromise<ProvingService<UnboundTransaction>>;
@@ -200,6 +209,27 @@ export declare class WalletFacade {
      *   been set on the network yet.
      */
     static fetchTermsAndConditions(configuration: FetchTermsAndConditionsConfiguration): Promise<TermsAndConditions>;
+    /**
+     * Default initialization for {@link WalletFacade}. It is a static method, which takes an object holding configuration
+     * and initialization of necessary components. Specifically - it requires following fields:
+     *
+     * - `configuration` - holding a configuration, which needs to extend {@link DefaultConfiguration} - this way allows to
+     *   convey use-case-specific settings in the same way, as the SDK works by default
+     * - `shielded` - a function taking the configuration and returning shielded wallet (or a promise with such)
+     *   implementing {@link ShieldedWalletAPI}
+     * - `unshielded` - a function taking the configuration and returning unshielded wallet (or a promise with such)
+     *   implementing {@link UnshieldedWalletAPI}
+     * - `dust` - a function taking the configuration and returning Dust wallet (or a promise with such) implementing
+     *   {@link DustWalletAPI} There are some optional services/abstractions to provide, too. If not provided - default
+     *   implementations will be used, each of them is initialized by a function taking the configuration and returning
+     *   proper implementation (wrapped in a {@link Promise} or not).
+     * - `submissionService` - needs to implement {@link SubmissionService} for a {@link ledger.FinalizedTransaction} to
+     *   submit transactions to the network, default uses Node RPC connection
+     * - `pendingTransactionsService` - needs to implement {@link PendingTransactionsService} for a
+     *   {@link ledger.FinalizedTransaction} to keep track of pending transactions, default uses in-memory implementation
+     * - `provingService` - needs to implement {@link ProvingService} to prove it, default uses proving server
+     * - `clock` - needs to implement {@link Clock.Clock} for getting current time, default uses system clock
+     */
     static init<TConfig extends DefaultConfiguration>(initParams: InitParams<TConfig>): Promise<WalletFacade>;
     readonly shielded: ShieldedWalletAPI;
     readonly unshielded: UnshieldedWalletAPI;
@@ -207,7 +237,13 @@ export declare class WalletFacade {
     readonly submissionService: SubmissionService<ledger.FinalizedTransaction>;
     readonly pendingTransactionsService: PendingTransactionsService<ledger.FinalizedTransaction>;
     readonly provingService: ProvingService<UnboundTransaction>;
-    readonly clock: Clock;
+    readonly clock: Clock.Clock;
+    /**
+     * Constructor is private on purpose - much of initialization of the facade is potentially asynchronous, and adding
+     * new parameters is a breaking change to the users Use {@link WalletFacade.init} instead
+     *
+     * @private
+     */
     private constructor();
     private defaultTtl;
     private mergeUnprovenTransactions;
@@ -274,6 +310,19 @@ export declare class WalletFacade {
         payFees?: boolean;
     }): Promise<UnprovenTransactionRecipe>;
     registerNightUtxosForDustGeneration(nightUtxos: readonly UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature, dustReceiverAddress?: DustAddress): Promise<UnprovenTransactionRecipe>;
+    /**
+     * Waits until the dust projected to be generated by the given Night UTxOs reaches `requiredAmount`, re-checking every
+     * second. Pair with {@link estimateRegistration} to pick `requiredAmount`, then call before
+     * {@link registerNightUtxosForDustGeneration} so the registration covers its own fee.
+     *
+     * @param nightUtxos - Night UTxOs to project generation for; the same set passed to the registration.
+     * @param requiredAmount - Dust threshold to wait for. Resolves immediately if `<= 0n`.
+     * @param opts.timeoutMs - Deadline, in ms, for the threshold to be reached. Rejects otherwise. Default `300_000`.
+     * @throws If `nightUtxos` is empty, or if `requiredAmount` is not reached within `opts.timeoutMs`.
+     */
+    waitForGeneratedDust(nightUtxos: readonly UtxoWithMeta[], requiredAmount: bigint, opts?: {
+        timeoutMs?: number;
+    }): Promise<void>;
     deregisterFromDustGeneration(nightUtxos: UtxoWithMeta[], nightVerifyingKey: ledger.SignatureVerifyingKey, signDustRegistration: (payload: Uint8Array) => ledger.Signature): Promise<UnprovenTransactionRecipe>;
     revert(txOrRecipe: AnyTransaction | BalancingRecipe): Promise<void>;
     revertTransaction(tx: AnyTransaction): Promise<void>;
@@ -282,4 +331,3 @@ export declare class WalletFacade {
     queryTxHistoryByHash(hash: TransactionHistoryStorage.TransactionHash): Promise<WalletEntry | undefined>;
     getAllFromTxHistory(): Promise<WalletEntry[]>;
 }
-export {};

package/dist/index.js

@@ -16,6 +16,7 @@ import { makeDefaultProvingService, } from '@midnight-ntwrk/wallet-sdk-capabilit
 import { ShieldedSectionSchema, mergeShieldedSections, } from '@midnight-ntwrk/wallet-sdk-shielded';
 import { UnshieldedSectionSchema } from '@midnight-ntwrk/wallet-sdk-unshielded-wallet';
 import { DustSectionSchema, mergeDustSections } from '@midnight-ntwrk/wallet-sdk-dust-wallet';
+import { Clock } from '@midnight-ntwrk/wallet-sdk-utilities';
 import { FetchTermsAndConditions as FetchTermsAndConditionsQuery } from '@midnight-ntwrk/wallet-sdk-indexer-client';
 import { QueryRunner } from '@midnight-ntwrk/wallet-sdk-indexer-client/effect';
 import { Array as Arr, pipe, Schema } from 'effect';
@@ -98,8 +99,17 @@ export class FacadeState {
     }
 }
 const DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
-/** Default clock using real system time. */
-export const systemClock = { now: () => new Date() };
+/**
+ * Clock abstraction for obtaining the current time. By default, the facade uses the system clock
+ * ({@link Clock.systemClock}); for testing with a simulator, inject a custom clock (e.g. one backed by the simulator's
+ * time).
+ *
+ * Re-exported from `@midnight-ntwrk/wallet-sdk-utilities` as a namespace so the type is `Clock.Clock` and the default is
+ * `Clock.systemClock`. Forwarding the same symbol — rather than re-declaring its members individually — keeps the
+ * umbrella `wallet-sdk` package's star-exports unambiguous and lets lower-level packages (e.g. dust-wallet) share it
+ * without a circular dependency.
+ */
+export { Clock };
 export class WalletFacade {
     static makeDefaultSubmissionService(config) {
         return makeDefaultSubmissionService(config);
@@ -145,6 +155,27 @@ export class WalletFacade {
         }
         return tc;
     }
+    /**
+     * Default initialization for {@link WalletFacade}. It is a static method, which takes an object holding configuration
+     * and initialization of necessary components. Specifically - it requires following fields:
+     *
+     * - `configuration` - holding a configuration, which needs to extend {@link DefaultConfiguration} - this way allows to
+     *   convey use-case-specific settings in the same way, as the SDK works by default
+     * - `shielded` - a function taking the configuration and returning shielded wallet (or a promise with such)
+     *   implementing {@link ShieldedWalletAPI}
+     * - `unshielded` - a function taking the configuration and returning unshielded wallet (or a promise with such)
+     *   implementing {@link UnshieldedWalletAPI}
+     * - `dust` - a function taking the configuration and returning Dust wallet (or a promise with such) implementing
+     *   {@link DustWalletAPI} There are some optional services/abstractions to provide, too. If not provided - default
+     *   implementations will be used, each of them is initialized by a function taking the configuration and returning
+     *   proper implementation (wrapped in a {@link Promise} or not).
+     * - `submissionService` - needs to implement {@link SubmissionService} for a {@link ledger.FinalizedTransaction} to
+     *   submit transactions to the network, default uses Node RPC connection
+     * - `pendingTransactionsService` - needs to implement {@link PendingTransactionsService} for a
+     *   {@link ledger.FinalizedTransaction} to keep track of pending transactions, default uses in-memory implementation
+     * - `provingService` - needs to implement {@link ProvingService} to prove it, default uses proving server
+     * - `clock` - needs to implement {@link Clock.Clock} for getting current time, default uses system clock
+     */
     static async init(initParams) {
         const submissionService = await Promise.resolve(initParams.submissionService
             ? initParams.submissionService(initParams.configuration)
@@ -158,7 +189,7 @@ export class WalletFacade {
         const shielded = await Promise.resolve(initParams.shielded(initParams.configuration));
         const unshielded = await Promise.resolve(initParams.unshielded(initParams.configuration));
         const dust = await Promise.resolve(initParams.dust(initParams.configuration));
-        const clock = await Promise.resolve(initParams.clock ? initParams.clock(initParams.configuration) : systemClock);
+        const clock = await Promise.resolve(initParams.clock ? initParams.clock(initParams.configuration) : Clock.systemClock);
         return new WalletFacade(shielded, unshielded, dust, submissionService, pendingTransactionsService, provingService, initParams.configuration.txHistoryStorage, clock);
     }
     shielded;
@@ -170,7 +201,13 @@ export class WalletFacade {
     #txHistoryStorage;
     clock;
     #pendingSubscription;
-    constructor(shieldedWallet, unshieldedWallet, dustWallet, submissionService, pendingTransactionsService, provingService, txHistoryStorage, clock = systemClock) {
+    /**
+     * Constructor is private on purpose - much of initialization of the facade is potentially asynchronous, and adding
+     * new parameters is a breaking change to the users Use {@link WalletFacade.init} instead
+     *
+     * @private
+     */
+    constructor(shieldedWallet, unshieldedWallet, dustWallet, submissionService, pendingTransactionsService, provingService, txHistoryStorage, clock = Clock.systemClock) {
         this.shielded = shieldedWallet;
         this.unshielded = unshieldedWallet;
         this.dust = dustWallet;
@@ -194,18 +231,72 @@ export class WalletFacade {
     }
     async createDustActionTransaction(action, nightUtxos, nightVerifyingKey, signDustRegistration) {
         const ttl = this.defaultTtl();
-        const transaction = await this.dust.createDustGenerationTransaction(undefined, ttl, nightUtxos.map(({ utxo, meta }) => ({
+        const now = this.clock.now();
+        const isRegistration = action.type === 'registration';
+        const dustReceiverAddress = isRegistration ? action.dustReceiverAddress : undefined;
+        // Step 1 — Dust decides which Night UTxO belongs in the guaranteed slot (the one whose dust
+        // generation can pay the fee) and computes the fee-payment allowance.
+        const split = await this.dust.splitNightUtxosForDustRegistration(now, nightUtxos.map(({ utxo, meta }) => ({
             ...utxo,
             ctime: meta.ctime,
             registeredForDustGeneration: meta.registeredForDustGeneration,
-        })), 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.');
+        })), isRegistration);
+        const toUnshieldedUtxoWithMeta = (u) => ({
+            utxo: {
+                value: u.utxo.value,
+                type: u.utxo.type,
+                owner: u.utxo.owner,
+                intentHash: u.utxo.intentHash,
+                outputNo: u.utxo.outputNo,
+            },
+            meta: {
+                ctime: u.utxo.ctime,
+                registeredForDustGeneration: u.utxo.registeredForDustGeneration,
+            },
+        });
+        const guaranteedForUnshielded = split.guaranteedUtxos.map(toUnshieldedUtxoWithMeta);
+        const fallibleForUnshielded = split.fallibleUtxos.map(toUnshieldedUtxoWithMeta);
+        // Step 2 — Unshielded books the Night UTxOs (move available -> pending) and builds the intent
+        // with the two offers. After this point, a concurrent build call that wants any of these UTxOs
+        // will fail fast.
+        const txWithOffers = await this.unshielded.rotateUtxos(guaranteedForUnshielded, fallibleForUnshielded, nightVerifyingKey, ttl);
+        // Step 3 — Dust attaches its DustActions onto the intent the unshielded wallet just built.
+        // If this fails we must unbook the UTxOs so the caller can retry.
+        let txWithDustActions;
+        try {
+            txWithDustActions = await this.dust.attachDustRegistration(txWithOffers, now, nightVerifyingKey, dustReceiverAddress, split.feePayment);
+        }
+        catch (error) {
+            await this.unshielded.revertTransaction(txWithOffers);
+            throw error;
+        }
+        // Step 4 (first-time registration only) — Fail fast if the dust generated so far by the
+        // unregistered guaranteed UTxOs is below the registration's own fee. Submitting would fail
+        // on-chain with BalanceCheckOverspend. Skip for re-registration (all guaranteed UTxOs already
+        // registered) since `feePayment` is 0 by design and the caller is expected to balance the fee
+        // externally via `balanceUnprovenTransaction({ tokenKindsToBalance: ['dust'] })`.
+        const hasUnregisteredGuaranteed = split.guaranteedUtxos.some((u) => !u.utxo.registeredForDustGeneration);
+        if (isRegistration && hasUnregisteredGuaranteed) {
+            const fee = await this.dust.calculateFee([txWithDustActions]);
+            if (split.feePayment < fee) {
+                await this.unshielded.revertTransaction(txWithOffers);
+                throw Error(`Insufficient generated dust to cover registration fee (have ${split.feePayment}, need ${fee}). ` +
+                    `Use WalletFacade.waitForGeneratedDust(utxos, ${fee}) before retrying.`);
+            }
+        }
+        // Step 5 — Sign via the standard signRecipe pathway, which now stamps both the unshielded
+        // offers and the dust registration. Signing failures also need to release the booking.
+        try {
+            const signedRecipe = await this.signRecipe({ type: 'UNPROVEN_TRANSACTION', transaction: txWithDustActions }, signDustRegistration);
+            if (signedRecipe.type !== 'UNPROVEN_TRANSACTION') {
+                throw Error('signRecipe returned unexpected recipe type for dust action transaction.');
+            }
+            return signedRecipe.transaction;
+        }
+        catch (error) {
+            await this.unshielded.revertTransaction(txWithOffers);
+            throw error;
         }
-        const signatureData = intent.signatureData(1);
-        const signature = await Promise.resolve(signDustRegistration(signatureData));
-        return await this.dust.addDustGenerationSignature(transaction, signature);
     }
     state() {
         return combineLatest([
@@ -349,15 +440,16 @@ export class WalletFacade {
         switch (recipe.type) {
             case 'FINALIZED_TRANSACTION': {
                 const signedBalancingTx = await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment);
+                const withDustSig = await this.#signDustRegistrationIfPresent(signedBalancingTx, signSegment);
                 return {
                     type: 'FINALIZED_TRANSACTION',
                     originalTransaction: recipe.originalTransaction,
-                    balancingTransaction: signedBalancingTx,
+                    balancingTransaction: withDustSig,
                 };
             }
             case 'UNBOUND_TRANSACTION': {
                 const signedBalancingTx = recipe.balancingTransaction
-                    ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment)
+                    ? await this.signUnprovenTransaction(recipe.balancingTransaction, signSegment).then((tx) => this.#signDustRegistrationIfPresent(tx, signSegment))
                     : undefined;
                 const signedBaseTx = await this.signUnboundTransaction(recipe.baseTransaction, signSegment);
                 return {
@@ -368,13 +460,23 @@ export class WalletFacade {
             }
             case 'UNPROVEN_TRANSACTION': {
                 const signedTx = await this.signUnprovenTransaction(recipe.transaction, signSegment);
+                const withDustSig = await this.#signDustRegistrationIfPresent(signedTx, signSegment);
                 return {
                     type: 'UNPROVEN_TRANSACTION',
-                    transaction: signedTx,
+                    transaction: withDustSig,
                 };
             }
         }
     }
+    async #signDustRegistrationIfPresent(tx, signSegment) {
+        const intent = tx.intents?.get(1);
+        const registrations = intent?.dustActions?.registrations ?? [];
+        if (!intent || registrations.length === 0) {
+            return tx;
+        }
+        const signature = signSegment(intent.signatureData(1));
+        return await this.dust.addDustRegistrationSignature(tx, signature);
+    }
     async signUnprovenTransaction(tx, signSegment) {
         return await this.unshielded.signUnprovenTransaction(tx, signSegment);
     }
@@ -446,8 +548,23 @@ export class WalletFacade {
         })), (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.address);
-        const finalizedFakeTx = fakeRegistrationRecipe.transaction.mockProve().bind();
+        // Use the legacy dust-only construction path here so estimation does NOT book real UTxOs in the
+        // unshielded wallet state. (The race-fix path in createDustActionTransaction books on purpose;
+        // estimation is meant to be observation-only.)
+        const ttl = this.defaultTtl();
+        const fakeUnsignedTx = await this.dust.createDustGenerationTransaction(undefined, ttl, nightUtxos.map(({ utxo, meta }) => ({
+            ...utxo,
+            ctime: meta.ctime,
+            registeredForDustGeneration: meta.registeredForDustGeneration,
+        })), fakeVerifyingKey, dustState.address);
+        const intent = fakeUnsignedTx.intents?.get(1);
+        if (!intent) {
+            throw Error('Dust generation transaction is missing intent segment 1.');
+        }
+        const signatureData = intent.signatureData(1);
+        const signature = ledger.signData(fakeSigningKey, signatureData);
+        const fakeSignedTx = await this.dust.addDustGenerationSignature(fakeUnsignedTx, signature);
+        const finalizedFakeTx = fakeSignedTx.mockProve().bind();
         const fee = await this.calculateTransactionFee(finalizedFakeTx);
         return {
             fee,
@@ -497,6 +614,23 @@ export class WalletFacade {
             transaction: dustRegistrationTx,
         };
     }
+    /**
+     * Waits until the dust projected to be generated by the given Night UTxOs reaches `requiredAmount`, re-checking every
+     * second. Pair with {@link estimateRegistration} to pick `requiredAmount`, then call before
+     * {@link registerNightUtxosForDustGeneration} so the registration covers its own fee.
+     *
+     * @param nightUtxos - Night UTxOs to project generation for; the same set passed to the registration.
+     * @param requiredAmount - Dust threshold to wait for. Resolves immediately if `<= 0n`.
+     * @param opts.timeoutMs - Deadline, in ms, for the threshold to be reached. Rejects otherwise. Default `300_000`.
+     * @throws If `nightUtxos` is empty, or if `requiredAmount` is not reached within `opts.timeoutMs`.
+     */
+    async waitForGeneratedDust(nightUtxos, requiredAmount, opts) {
+        await this.dust.waitForGeneratedDust(nightUtxos.map(({ utxo, meta }) => ({
+            ...utxo,
+            ctime: meta.ctime,
+            registeredForDustGeneration: meta.registeredForDustGeneration,
+        })), requiredAmount, this.clock, opts);
+    }
     async deregisterFromDustGeneration(nightUtxos, nightVerifyingKey, signDustRegistration) {
         const dustDeregistrationTx = await this.createDustActionTransaction({ type: 'deregistration' }, nightUtxos, nightVerifyingKey, signDustRegistration);
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midnight-ntwrk/wallet-sdk-facade",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -8,14 +8,16 @@
   "author": "Midnight Foundation",
   "license": "Apache-2.0",
   "publishConfig": {
-    "registry": "https://npm.pkg.github.com/"
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
   },
   "files": [
     "dist/"
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/midnight-ntwrk/artifacts.git"
+    "url": "git+https://github.com/midnightntwrk/midnight-wallet.git",
+    "directory": "packages/facade"
   },
   "exports": {
     ".": {
@@ -24,19 +26,19 @@
     }
   },
   "dependencies": {
-    "@midnight-ntwrk/ledger-v8": "^8.0.3",
-    "@midnight-ntwrk/wallet-sdk-address-format": "^3.1.1",
-    "@midnight-ntwrk/wallet-sdk-capabilities": "^3.3.0",
-    "@midnight-ntwrk/wallet-sdk-dust-wallet": "^4.0.0",
-    "@midnight-ntwrk/wallet-sdk-indexer-client": "^1.2.1",
-    "@midnight-ntwrk/wallet-sdk-shielded": "^3.0.0",
-    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "^3.0.0",
+    "@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-dust-wallet": "^4.2.0",
+    "@midnight-ntwrk/wallet-sdk-indexer-client": "^1.2.3",
+    "@midnight-ntwrk/wallet-sdk-shielded": "^3.0.2",
+    "@midnight-ntwrk/wallet-sdk-unshielded-wallet": "^3.1.0",
     "rxjs": "^7.8.2"
   },
   "devDependencies": {
-    "@midnight-ntwrk/wallet-sdk-abstractions": "^2.1.0",
-    "@midnight-ntwrk/wallet-sdk-hd": "^3.0.2",
-    "@midnight-ntwrk/wallet-sdk-utilities": "1.1.1"
+    "@midnight-ntwrk/wallet-sdk-hd": "^3.0.3",
+    "@midnight-ntwrk/wallet-sdk-utilities": "^1.2.0"
   },
   "scripts": {
     "typecheck": "tsc -b ./tsconfig.json --noEmit --force",