@dynamic-labs/midnight 4.91.0 → 4.91.2

package/CHANGELOG.md

@@ -1,4 +1,47 @@
 
+### [4.91.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.91.1...v4.91.2) (2026-06-26)
+
+
+### ⚠ BREAKING CHANGES
+
+* **waas:** require expectedAddresses on migrateFromFireblocks (#11730)
+
+### Features
+
+* **midnight:** support shielded/unshielded transfers and dust states in the embedded Send flow ([#11731](https://github.com/dynamic-labs/dynamic-auth/issues/11731)) ([663d171](https://github.com/dynamic-labs/dynamic-auth/commit/663d171a9628c634586831ee35c234e9331e3f80))
+* **react-native-extension:** instrument all embedded webview failure paths ([#11737](https://github.com/dynamic-labs/dynamic-auth/issues/11737)) ([172998b](https://github.com/dynamic-labs/dynamic-auth/commit/172998b56e9bee04fbb8da71e83ce8885bc378ff))
+* **waas:** migrateFromFireblocks connector method + demo panel (browser-wallet-client 1.0.46) ([#11702](https://github.com/dynamic-labs/dynamic-auth/issues/11702)) ([6bfc844](https://github.com/dynamic-labs/dynamic-auth/commit/6bfc8443fbaedabe1e7bee0ed78742cbbe5d0084))
+
+
+### Bug Fixes
+
+* add coverage for scenario with passkey re-login and smart account ([#11726](https://github.com/dynamic-labs/dynamic-auth/issues/11726)) ([5364a72](https://github.com/dynamic-labs/dynamic-auth/commit/5364a72a750d835b9b2da602a91e8b5d7d305db7))
+* remediate high-severity dependency vulnerabilities ([#11721](https://github.com/dynamic-labs/dynamic-auth/issues/11721)) ([cdb9306](https://github.com/dynamic-labs/dynamic-auth/commit/cdb93061365a20b8f73a1f8bea8352332e282c1e))
+* replace node-fetch v2 with native fetch to fix Node 22 stream failure ([#11732](https://github.com/dynamic-labs/dynamic-auth/issues/11732)) ([b98f801](https://github.com/dynamic-labs/dynamic-auth/commit/b98f801e307b52dbd7e4b241a9a4a2d34d89118e))
+* **zerodev-extension:** derive kernel 7702 vs 4337 per-wallet, not from global dashboard flag ([#11735](https://github.com/dynamic-labs/dynamic-auth/issues/11735)) ([72cf6a7](https://github.com/dynamic-labs/dynamic-auth/commit/72cf6a70a4857a4ea469faa555c485dbad8d0217))
+
+
+* **waas:** require expectedAddresses on migrateFromFireblocks ([#11730](https://github.com/dynamic-labs/dynamic-auth/issues/11730)) ([c94824e](https://github.com/dynamic-labs/dynamic-auth/commit/c94824ebe11e0433a6ffbd2a5a9dd4283aeed31e))
+
+### [4.91.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.91.0...v4.91.1) (2026-06-24)
+
+
+### Features
+
+* **aleo:** update sendBalance with individual and marketplace logic ([#11709](https://github.com/dynamic-labs/dynamic-auth/issues/11709)) ([f8dfc48](https://github.com/dynamic-labs/dynamic-auth/commit/f8dfc488ae607fbbbcc3432a3ef69f746f0b7df0))
+* **sdk-react-core:** surface shielded address in Midnight deposit view ([#11698](https://github.com/dynamic-labs/dynamic-auth/issues/11698)) ([79c5402](https://github.com/dynamic-labs/dynamic-auth/commit/79c54029b1d8f722cf9f1d8b4c11977898442ac0))
+
+
+### Bug Fixes
+
+* display actual error message for WaaS export failures instead of generic fallback ([#11498](https://github.com/dynamic-labs/dynamic-auth/issues/11498)) ([373c931](https://github.com/dynamic-labs/dynamic-auth/commit/373c931eb96c88e484c557ee8f2934660d028f97))
+* **wallet-book:** guard replaceKey and remove stale override ([#11682](https://github.com/dynamic-labs/dynamic-auth/issues/11682)) ([13947d9](https://github.com/dynamic-labs/dynamic-auth/commit/13947d972ed1f8227712bfc01af9cc2be616a78a))
+
+
+### Performance Improvements
+
+* **e2e:** prebuild Expo web bundle for RN e2e tests ([#11674](https://github.com/dynamic-labs/dynamic-auth/issues/11674)) ([16e002d](https://github.com/dynamic-labs/dynamic-auth/commit/16e002d59b2035e3f2c116879a78418a959da8bc))
+
 ## [4.91.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.90.0...v4.91.0) (2026-06-23)
 
 

package/package.cjs

@@ -3,6 +3,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var version = "4.91.0";
+var version = "4.91.2";
 
 exports.version = version;

package/package.js

@@ -1,4 +1,4 @@
 'use client'
-var version = "4.91.0";
+var version = "4.91.2";
 
 export { version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/midnight",
-  "version": "4.91.0",
+  "version": "4.91.2",
   "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
   "author": "Dynamic Labs, Inc.",
   "license": "MIT",
@@ -18,15 +18,15 @@
   },
   "homepage": "https://www.dynamic.xyz/",
   "dependencies": {
-    "@dynamic-labs/assert-package-version": "4.91.0",
+    "@dynamic-labs/assert-package-version": "4.91.2",
     "@dynamic-labs/sdk-api-core": "0.0.1046",
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",
-    "@dynamic-labs/logger": "4.91.0",
-    "@dynamic-labs/types": "4.91.0",
-    "@dynamic-labs/utils": "4.91.0",
-    "@dynamic-labs/waas": "4.91.0",
-    "@dynamic-labs/wallet-book": "4.91.0",
-    "@dynamic-labs/wallet-connector-core": "4.91.0"
+    "@dynamic-labs/logger": "4.91.2",
+    "@dynamic-labs/types": "4.91.2",
+    "@dynamic-labs/utils": "4.91.2",
+    "@dynamic-labs/waas": "4.91.2",
+    "@dynamic-labs/wallet-book": "4.91.2",
+    "@dynamic-labs/wallet-connector-core": "4.91.2"
   },
   "peerDependencies": {}
 }

package/src/connectors/MidnightWalletConnector.cjs

@@ -74,6 +74,35 @@ class MidnightWalletConnector extends walletConnectorCore.WalletConnectorBase {
             throw new Error('signTransaction is not supported by this connector');
         });
     }
+    createTransferTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('createTransferTransaction is not supported by this connector');
+        });
+    }
+    registerDust() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('registerDust is not supported by this connector');
+        });
+    }
+    revertTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    serializedTransaction) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('revertTransaction is not supported by this connector');
+        });
+    }
+    revertAllPending() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('revertAllPending is not supported by this connector');
+        });
+    }
+    resetWalletCache() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            throw new Error('resetWalletCache is not supported by this connector');
+        });
+    }
     getShieldedBalances() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const api = yield this.getConnectedAPI();

package/src/connectors/MidnightWalletConnector.d.ts

@@ -31,6 +31,42 @@ export declare abstract class MidnightWalletConnector extends WalletConnectorBas
         }>;
     }): Promise<string>;
     signTransaction(serializedTransaction: string): Promise<string>;
+    createTransferTransaction(params: {
+        transfers: Array<{
+            type: 'unshielded' | 'shielded';
+            recipientAddress: string;
+            amount: string;
+            tokenType?: string;
+        }>;
+        ttlMinutes?: number;
+    }): Promise<{
+        serializedTransaction: string;
+    }>;
+    registerDust(): Promise<{
+        dustBalance: string;
+        txId?: string;
+        status: 'registered' | 'already_registered' | 'already_has_dust' | 'no_utxos';
+        message: string;
+        registeredCount: number;
+    }>;
+    revertTransaction(serializedTransaction: string): Promise<{
+        reverted: boolean;
+        count: number;
+        cacheCleared: boolean;
+        message: string;
+    }>;
+    revertAllPending(): Promise<{
+        reverted: boolean;
+        count: number;
+        cacheCleared: boolean;
+        message: string;
+    }>;
+    resetWalletCache(): Promise<{
+        reverted: boolean;
+        count: number;
+        cacheCleared: boolean;
+        message: string;
+    }>;
     getShieldedBalances(): Promise<Record<TokenType, bigint>>;
     getUnshieldedBalances(): Promise<Record<TokenType, bigint>>;
     getDustBalance(): Promise<{

package/src/connectors/MidnightWalletConnector.js

@@ -70,6 +70,35 @@ class MidnightWalletConnector extends WalletConnectorBase {
             throw new Error('signTransaction is not supported by this connector');
         });
     }
+    createTransferTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('createTransferTransaction is not supported by this connector');
+        });
+    }
+    registerDust() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('registerDust is not supported by this connector');
+        });
+    }
+    revertTransaction(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    serializedTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('revertTransaction is not supported by this connector');
+        });
+    }
+    revertAllPending() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('revertAllPending is not supported by this connector');
+        });
+    }
+    resetWalletCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('resetWalletCache is not supported by this connector');
+        });
+    }
     getShieldedBalances() {
         return __awaiter(this, void 0, void 0, function* () {
             const api = yield this.getConnectedAPI();

package/src/utils/MidnightUiTransaction/MidnightUiTransaction.cjs

@@ -8,6 +8,10 @@ var constants = require('../../constants.cjs');
 var formatMidnightAtomicBalance = require('../formatMidnightAtomicBalance/formatMidnightAtomicBalance.cjs');
 var parseMidnightAtomicAmount = require('../parseMidnightAtomicAmount/parseMidnightAtomicAmount.cjs');
 
+// Shielded tokens aren't NIGHT and have no decimals metadata, so they're shown
+// at their raw amount (decimals 0); native NIGHT keeps 6-decimal formatting.
+const SHIELDED_TOKEN_DECIMALS = 0;
+const shortTokenLabel = (address) => `TOKEN: ${address.slice(0, 8)}...${address.slice(-8)}`;
 class MidnightUiTransaction {
     constructor(opts) {
         this.to = undefined;
@@ -17,68 +21,104 @@ class MidnightUiTransaction {
         this.chain = 'MIDNIGHT';
         this.fee = { gas: undefined };
         this.feeTokenSymbol = 'DUST';
+        // Pool defaults to unshielded; it is derived from the selected token (or the
+        // transaction-mode toggle), never inferred from a hard-coded token hash.
         this.pool = 'unshielded';
+        this.selectedTransactionMode = 'unshielded';
+        this.selectedTokenAddress = constants.MIDNIGHT_NATIVE_TOKEN_TYPE;
         this.from = opts.from;
+        this.balances = opts.balances;
+        this.shieldedAddresses = new Set(Object.keys(opts.balances.shielded));
         this.onSubmitFn = opts.onSubmit;
-        this.getUnshieldedBalanceFn = opts.getUnshieldedBalance;
-        this.getShieldedBalanceFn = opts.getShieldedBalance;
         this.fetchDustFeeFn = opts.fetchDustFee;
     }
     get activePool() {
         return this.pool;
     }
+    get transactionModes() {
+        return [
+            { id: 'unshielded', label: 'Unshielded' },
+            { id: 'shielded', label: 'Shielded' },
+        ];
+    }
+    get selectedTokenDecimals() {
+        return this.selectedTokenAddress === constants.MIDNIGHT_NATIVE_TOKEN_TYPE
+            ? constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS
+            : SHIELDED_TOKEN_DECIMALS;
+    }
+    // Pool a token belongs to — used by the send form to filter the picker.
+    getTokenPool(contractAddress) {
+        return this.shieldedAddresses.has(contractAddress)
+            ? 'shielded'
+            : 'unshielded';
+    }
+    setTransactionMode(modeId) {
+        this.selectedTransactionMode = modeId;
+        this.pool = modeId === 'shielded' ? 'shielded' : 'unshielded';
+        this.to = undefined;
+        this.value = undefined;
+    }
     setSelectedToken(contractAddress) {
-        this.pool =
-            contractAddress === constants.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE
-                ? 'shielded'
-                : 'unshielded';
+        this.selectedTokenAddress = contractAddress;
+        this.pool = this.getTokenPool(contractAddress);
+        this.selectedTransactionMode = this.pool;
         this.to = undefined;
         this.value = undefined;
     }
     getSendableTokenBalances() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const [unshieldedRaw, shieldedRaw] = yield Promise.all([
-                this.getUnshieldedBalanceFn(),
-                this.getShieldedBalanceFn(),
-            ]);
-            const toDisplay = (raw) => Number(formatMidnightAtomicBalance.formatMidnightAtomicBalance(raw, constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS));
-            return [
-                {
-                    address: constants.MIDNIGHT_NATIVE_TOKEN_TYPE,
-                    balance: toDisplay(unshieldedRaw),
-                    decimals: constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
-                    isNative: true,
-                    logoURI: '',
-                    name: 'NIGHT (Unshielded)',
-                    rawBalance: Number(unshieldedRaw),
-                    rawBalanceString: unshieldedRaw.toString(),
-                    symbol: 'NIGHT',
-                },
-                {
-                    address: constants.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE,
-                    balance: toDisplay(shieldedRaw),
-                    decimals: constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
-                    isNative: true,
-                    logoURI: '',
-                    name: 'NIGHT (Shielded)',
-                    rawBalance: Number(shieldedRaw),
-                    rawBalanceString: shieldedRaw.toString(),
-                    symbol: 'NIGHT',
-                },
-            ];
+            var _a;
+            const toDisplay = (raw, decimals) => Number(formatMidnightAtomicBalance.formatMidnightAtomicBalance(raw, decimals));
+            // Native unshielded NIGHT — always shown, even at a zero balance.
+            const unshieldedNightRaw = (_a = this.balances.unshielded[constants.MIDNIGHT_NATIVE_TOKEN_TYPE]) !== null && _a !== void 0 ? _a : BigInt(0);
+            const nightEntry = {
+                address: constants.MIDNIGHT_NATIVE_TOKEN_TYPE,
+                balance: toDisplay(unshieldedNightRaw, constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS),
+                decimals: constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
+                isNative: true,
+                logoURI: '',
+                name: 'NIGHT',
+                rawBalance: Number(unshieldedNightRaw),
+                rawBalanceString: unshieldedNightRaw.toString(),
+                symbol: 'NIGHT',
+            };
+            // Non-NIGHT tokens (other unshielded + every shielded token), shown at raw
+            // amount. `isNative: true` is deliberate — like Aleo, every Midnight token
+            // uses the `transaction.parse`/`getBalance` path; the form's non-native
+            // branch (`parseNonNativeToken`) is EVM-only and doesn't apply here.
+            const tokenEntry = (address, raw) => ({
+                address,
+                balance: toDisplay(raw, SHIELDED_TOKEN_DECIMALS),
+                decimals: SHIELDED_TOKEN_DECIMALS,
+                isNative: true,
+                logoURI: '',
+                name: shortTokenLabel(address),
+                rawBalance: Number(raw),
+                rawBalanceString: raw.toString(),
+                symbol: '',
+            });
+            const otherUnshielded = Object.entries(this.balances.unshielded)
+                .filter(([address, raw]) => address !== constants.MIDNIGHT_NATIVE_TOKEN_TYPE && raw > BigInt(0))
+                .map(([address, raw]) => tokenEntry(address, raw));
+            const shielded = Object.entries(this.balances.shielded)
+                .filter(([, raw]) => raw > BigInt(0))
+                .map(([address, raw]) => tokenEntry(address, raw));
+            return [nightEntry, ...otherUnshielded, ...shielded];
         });
     }
     parse(input) {
-        return parseMidnightAtomicAmount.parseMidnightAtomicAmount(input, constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS);
+        return parseMidnightAtomicAmount.parseMidnightAtomicAmount(input, this.selectedTokenDecimals);
     }
     format(value) {
-        return formatMidnightAtomicBalance.formatMidnightAtomicBalance(value, constants.MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS);
+        return formatMidnightAtomicBalance.formatMidnightAtomicBalance(value, this.selectedTokenDecimals);
     }
     getBalance() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            return this.pool === 'shielded'
-                ? this.getShieldedBalanceFn()
-                : this.getUnshieldedBalanceFn();
+            var _a;
+            const map = this.pool === 'shielded'
+                ? this.balances.shielded
+                : this.balances.unshielded;
+            return (_a = map[this.selectedTokenAddress]) !== null && _a !== void 0 ? _a : BigInt(0);
         });
     }
     fetchFee() {

package/src/utils/MidnightUiTransaction/MidnightUiTransaction.d.ts

@@ -1,11 +1,14 @@
 import type { TokenBalance } from '@dynamic-labs/sdk-api-core';
-import type { IUITransaction } from '@dynamic-labs/types';
+import type { IUITransaction, TransactionModeOption } from '@dynamic-labs/types';
 type MidnightPool = 'unshielded' | 'shielded';
+export type MidnightBalanceMaps = {
+    shielded: Record<string, bigint>;
+    unshielded: Record<string, bigint>;
+};
 type MidnightUiTransactionOpts = {
     from: string;
     onSubmit: (tx: MidnightUiTransaction) => Promise<string>;
-    getUnshieldedBalance: () => Promise<bigint>;
-    getShieldedBalance: () => Promise<bigint>;
+    balances: MidnightBalanceMaps;
     fetchDustFee: () => Promise<bigint>;
 };
 export declare class MidnightUiTransaction implements IUITransaction {
@@ -20,12 +23,18 @@ export declare class MidnightUiTransaction implements IUITransaction {
     };
     feeTokenSymbol: string;
     private pool;
+    selectedTransactionMode: string;
+    selectedTokenAddress: string;
+    private readonly balances;
+    private readonly shieldedAddresses;
     private readonly onSubmitFn;
-    private readonly getUnshieldedBalanceFn;
-    private readonly getShieldedBalanceFn;
     private readonly fetchDustFeeFn;
     constructor(opts: MidnightUiTransactionOpts);
     get activePool(): MidnightPool;
+    get transactionModes(): TransactionModeOption[];
+    private get selectedTokenDecimals();
+    getTokenPool(contractAddress: string): MidnightPool;
+    setTransactionMode(modeId: string): void;
     setSelectedToken(contractAddress: string): void;
     getSendableTokenBalances(): Promise<TokenBalance[]>;
     parse(input: string): bigint;

package/src/utils/MidnightUiTransaction/MidnightUiTransaction.js

@@ -1,9 +1,13 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
-import { MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE, MIDNIGHT_NATIVE_TOKEN_TYPE, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS } from '../../constants.js';
+import { MIDNIGHT_NATIVE_TOKEN_TYPE, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS } from '../../constants.js';
 import { formatMidnightAtomicBalance } from '../formatMidnightAtomicBalance/formatMidnightAtomicBalance.js';
 import { parseMidnightAtomicAmount } from '../parseMidnightAtomicAmount/parseMidnightAtomicAmount.js';
 
+// Shielded tokens aren't NIGHT and have no decimals metadata, so they're shown
+// at their raw amount (decimals 0); native NIGHT keeps 6-decimal formatting.
+const SHIELDED_TOKEN_DECIMALS = 0;
+const shortTokenLabel = (address) => `TOKEN: ${address.slice(0, 8)}...${address.slice(-8)}`;
 class MidnightUiTransaction {
     constructor(opts) {
         this.to = undefined;
@@ -13,68 +17,104 @@ class MidnightUiTransaction {
         this.chain = 'MIDNIGHT';
         this.fee = { gas: undefined };
         this.feeTokenSymbol = 'DUST';
+        // Pool defaults to unshielded; it is derived from the selected token (or the
+        // transaction-mode toggle), never inferred from a hard-coded token hash.
         this.pool = 'unshielded';
+        this.selectedTransactionMode = 'unshielded';
+        this.selectedTokenAddress = MIDNIGHT_NATIVE_TOKEN_TYPE;
         this.from = opts.from;
+        this.balances = opts.balances;
+        this.shieldedAddresses = new Set(Object.keys(opts.balances.shielded));
         this.onSubmitFn = opts.onSubmit;
-        this.getUnshieldedBalanceFn = opts.getUnshieldedBalance;
-        this.getShieldedBalanceFn = opts.getShieldedBalance;
         this.fetchDustFeeFn = opts.fetchDustFee;
     }
     get activePool() {
         return this.pool;
     }
+    get transactionModes() {
+        return [
+            { id: 'unshielded', label: 'Unshielded' },
+            { id: 'shielded', label: 'Shielded' },
+        ];
+    }
+    get selectedTokenDecimals() {
+        return this.selectedTokenAddress === MIDNIGHT_NATIVE_TOKEN_TYPE
+            ? MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS
+            : SHIELDED_TOKEN_DECIMALS;
+    }
+    // Pool a token belongs to — used by the send form to filter the picker.
+    getTokenPool(contractAddress) {
+        return this.shieldedAddresses.has(contractAddress)
+            ? 'shielded'
+            : 'unshielded';
+    }
+    setTransactionMode(modeId) {
+        this.selectedTransactionMode = modeId;
+        this.pool = modeId === 'shielded' ? 'shielded' : 'unshielded';
+        this.to = undefined;
+        this.value = undefined;
+    }
     setSelectedToken(contractAddress) {
-        this.pool =
-            contractAddress === MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE
-                ? 'shielded'
-                : 'unshielded';
+        this.selectedTokenAddress = contractAddress;
+        this.pool = this.getTokenPool(contractAddress);
+        this.selectedTransactionMode = this.pool;
         this.to = undefined;
         this.value = undefined;
     }
     getSendableTokenBalances() {
         return __awaiter(this, void 0, void 0, function* () {
-            const [unshieldedRaw, shieldedRaw] = yield Promise.all([
-                this.getUnshieldedBalanceFn(),
-                this.getShieldedBalanceFn(),
-            ]);
-            const toDisplay = (raw) => Number(formatMidnightAtomicBalance(raw, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS));
-            return [
-                {
-                    address: MIDNIGHT_NATIVE_TOKEN_TYPE,
-                    balance: toDisplay(unshieldedRaw),
-                    decimals: MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
-                    isNative: true,
-                    logoURI: '',
-                    name: 'NIGHT (Unshielded)',
-                    rawBalance: Number(unshieldedRaw),
-                    rawBalanceString: unshieldedRaw.toString(),
-                    symbol: 'NIGHT',
-                },
-                {
-                    address: MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE,
-                    balance: toDisplay(shieldedRaw),
-                    decimals: MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
-                    isNative: true,
-                    logoURI: '',
-                    name: 'NIGHT (Shielded)',
-                    rawBalance: Number(shieldedRaw),
-                    rawBalanceString: shieldedRaw.toString(),
-                    symbol: 'NIGHT',
-                },
-            ];
+            var _a;
+            const toDisplay = (raw, decimals) => Number(formatMidnightAtomicBalance(raw, decimals));
+            // Native unshielded NIGHT — always shown, even at a zero balance.
+            const unshieldedNightRaw = (_a = this.balances.unshielded[MIDNIGHT_NATIVE_TOKEN_TYPE]) !== null && _a !== void 0 ? _a : BigInt(0);
+            const nightEntry = {
+                address: MIDNIGHT_NATIVE_TOKEN_TYPE,
+                balance: toDisplay(unshieldedNightRaw, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS),
+                decimals: MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS,
+                isNative: true,
+                logoURI: '',
+                name: 'NIGHT',
+                rawBalance: Number(unshieldedNightRaw),
+                rawBalanceString: unshieldedNightRaw.toString(),
+                symbol: 'NIGHT',
+            };
+            // Non-NIGHT tokens (other unshielded + every shielded token), shown at raw
+            // amount. `isNative: true` is deliberate — like Aleo, every Midnight token
+            // uses the `transaction.parse`/`getBalance` path; the form's non-native
+            // branch (`parseNonNativeToken`) is EVM-only and doesn't apply here.
+            const tokenEntry = (address, raw) => ({
+                address,
+                balance: toDisplay(raw, SHIELDED_TOKEN_DECIMALS),
+                decimals: SHIELDED_TOKEN_DECIMALS,
+                isNative: true,
+                logoURI: '',
+                name: shortTokenLabel(address),
+                rawBalance: Number(raw),
+                rawBalanceString: raw.toString(),
+                symbol: '',
+            });
+            const otherUnshielded = Object.entries(this.balances.unshielded)
+                .filter(([address, raw]) => address !== MIDNIGHT_NATIVE_TOKEN_TYPE && raw > BigInt(0))
+                .map(([address, raw]) => tokenEntry(address, raw));
+            const shielded = Object.entries(this.balances.shielded)
+                .filter(([, raw]) => raw > BigInt(0))
+                .map(([address, raw]) => tokenEntry(address, raw));
+            return [nightEntry, ...otherUnshielded, ...shielded];
         });
     }
     parse(input) {
-        return parseMidnightAtomicAmount(input, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS);
+        return parseMidnightAtomicAmount(input, this.selectedTokenDecimals);
     }
     format(value) {
-        return formatMidnightAtomicBalance(value, MIDNIGHT_NATIVE_UNSHIELDED_DECIMALS);
+        return formatMidnightAtomicBalance(value, this.selectedTokenDecimals);
     }
     getBalance() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.pool === 'shielded'
-                ? this.getShieldedBalanceFn()
-                : this.getUnshieldedBalanceFn();
+            var _a;
+            const map = this.pool === 'shielded'
+                ? this.balances.shielded
+                : this.balances.unshielded;
+            return (_a = map[this.selectedTokenAddress]) !== null && _a !== void 0 ? _a : BigInt(0);
         });
     }
     fetchFee() {

package/src/waas/connector/DynamicWaasMidnightConnector.cjs

@@ -18,8 +18,6 @@ var buildMidnightWaasConnectedApi = require('./buildMidnightWaasConnectedApi.cjs
 /**
  * WaaS (Wallet-as-a-Service) connector for Midnight blockchain.
  * Extends the WaaS-specific Midnight base with MPC wallet functionality.
- *
- * Phase 1: Supports unshielded assets (NIGHT, MNTs) only.
  */
 class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWalletConnector.WaasMidnightWalletConnector) {
     constructor(props) {
@@ -89,6 +87,8 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
      */
     afterWalletSelectHook(walletAddress) {
         this.setActiveAccountAddress(walletAddress);
+        // Different wallet → its balances are unrelated; drop any cached snapshot.
+        this.clearSendBalanceCache();
     }
     /**
      * Requires and returns the signed session ID
@@ -167,7 +167,9 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
      */
     disconnect() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            // WaaS doesn't require explicit disconnect
+            // WaaS doesn't require explicit disconnect, but drop the balance snapshot
+            // so a shielded balance isn't retained after the wallet is disconnected.
+            this.clearSendBalanceCache();
         });
     }
     /**
@@ -270,47 +272,54 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
             return signature;
         });
     }
-    /**
-     * Creates a UI transaction for the send balance flow
-     * @param from - The sender's address
-     * @returns A new IUITransaction instance
-     */
+    clearSendBalanceCache() {
+        this.sendBalanceCache = undefined;
+    }
     createUiTransaction(from) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             yield this.validateActiveWallet(from);
+            // Balances from the connector (MPC state) — never the redcoast
+            // public-balance endpoint, which rejects Midnight addresses. Reused from the
+            // short-lived cache across recreations (see field doc).
+            const now = Date.now();
+            if (!this.sendBalanceCache ||
+                now - this.sendBalanceCache.at >
+                    DynamicWaasMidnightConnector.SEND_BALANCE_TTL_MS) {
+                const { shielded, unshielded } = yield this.getBalances();
+                this.sendBalanceCache = { at: now, maps: { shielded, unshielded } };
+            }
+            const balances = this.sendBalanceCache.maps;
             return new MidnightUiTransaction.MidnightUiTransaction({
+                balances,
                 // No on-chain dust-fee estimate is exposed yet; DUST fees are charged
                 // at submit time. TODO: surface a real estimate from the wallet client.
                 fetchDustFee: () => _tslib.__awaiter(this, void 0, void 0, function* () { return BigInt(0); }),
                 from,
-                // Balances come from the connector (MPC state), reusing the cached
-                // synced wallet — never from the redcoast public-balance endpoint,
-                // which doesn't support Midnight addresses.
-                getShieldedBalance: () => _tslib.__awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    return (_a = (yield this.getBalances()).shielded[constants.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE]) !== null && _a !== void 0 ? _a : BigInt(0);
-                }),
-                getUnshieldedBalance: () => _tslib.__awaiter(this, void 0, void 0, function* () {
-                    var _b;
-                    return (_b = (yield this.getBalances()).unshielded[constants.MIDNIGHT_NATIVE_TOKEN_TYPE]) !== null && _b !== void 0 ? _b : BigInt(0);
-                }),
                 onSubmit: (tx) => _tslib.__awaiter(this, void 0, void 0, function* () {
                     if (tx.to === undefined || tx.value === undefined) {
                         throw new utils.DynamicError('Recipient and amount are required before submitting');
                     }
+                    // Native NIGHT needs no tokenType; any other (shielded) token is passed
+                    // by its ledger token type so the correct balance is debited.
+                    const tokenType = tx.selectedTokenAddress === constants.MIDNIGHT_NATIVE_TOKEN_TYPE
+                        ? undefined
+                        : tx.selectedTokenAddress;
                     // 3-step Midnight transfer: build → sign (ZK prove) → submit.
                     const { serializedTransaction } = yield this.createTransferTransaction({
                         transfers: [
                             {
                                 amount: tx.value.toString(),
                                 recipientAddress: tx.to,
+                                tokenType,
                                 type: tx.activePool,
                             },
                         ],
                     });
                     const finalized = yield this.signTransaction(serializedTransaction);
-                    // Return the tx hash so the Send flow advances to the success view.
                     const { txHash } = yield this.submitTransaction(finalized);
+                    // Balances changed — drop the snapshot so the next send fetches fresh.
+                    this.clearSendBalanceCache();
+                    // Return the tx hash so the Send flow advances to the success view.
                     return txHash;
                 }),
             });
@@ -441,6 +450,21 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
             });
         });
     }
+    /**
+     * One-call transfer: runs the full build → sign (ZK prove) → submit flow and
+     * returns the broadcast tx hash. This is what backs `wallet.sendBalance` for
+     * embedded Midnight wallets; use the individual steps
+     * (`createTransferTransaction` / `signTransaction` / `submitTransaction`) when
+     * you need to inspect or persist the transaction between stages.
+     */
+    createTransfer(params) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const { serializedTransaction } = yield this.createTransferTransaction(params);
+            const finalizedTransaction = yield this.signTransaction(serializedTransaction);
+            const { txHash } = yield this.submitTransaction(finalizedTransaction);
+            return txHash;
+        });
+    }
     /**
      * Step 1 of the Midnight transfer flow.
      * Builds an unsigned UnprovenTransaction from one or more transfer specs.
@@ -567,5 +591,7 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
         });
     }
 }
+// Max age of the Send-flow balance snapshot (see `sendBalanceCache`).
+DynamicWaasMidnightConnector.SEND_BALANCE_TTL_MS = 30000;
 
 exports.DynamicWaasMidnightConnector = DynamicWaasMidnightConnector;

package/src/waas/connector/DynamicWaasMidnightConnector.d.ts

@@ -80,6 +80,15 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
         legacyWalletId?: string | undefined;
         password?: string | undefined;
     }): Promise<void>;
+    migrateFromFireblocks({ deviceId, jwt, walletPassword, ncwStorage, expectedAddresses, coinTypes, password, }: {
+        deviceId: string;
+        jwt: string;
+        walletPassword: string;
+        ncwStorage: Record<string, string>;
+        expectedAddresses: Record<string, string>;
+        coinTypes?: Record<string, number> | undefined;
+        password?: string | undefined;
+    }): Promise<import("@dynamic-labs-wallet/browser-wallet-client").MigrateFromFireblocksResponse>;
     exportPrivateKey({ accountAddress, displayContainer, password, }?: {
         accountAddress?: string | undefined;
         displayContainer?: HTMLIFrameElement | undefined;
@@ -98,6 +107,10 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
         googleDriveAccessToken?: string | undefined;
     }): Promise<void>;
     exportClientKeysharesFromGoogleDrive({ accountAddress, password, }: {
+        /**
+         * When active account is not set (e.g. primary wallet restored from session),
+         * fall back to the first Midnight verified credential so signing and getAddress work.
+         */
         accountAddress: string;
         password?: string | undefined;
     }): Promise<void>;
@@ -119,6 +132,9 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
         thresholdSignatureScheme: string;
         password?: string | undefined;
     }): Promise<void>;
+    /**
+     * Connects to the WaaS wallet client
+     */
     revokeDelegation({ accountAddress, password, }: {
         accountAddress: string;
         password?: string | undefined;
@@ -130,9 +146,7 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
     }): Promise<void>;
     setPassword({ accountAddress, newPassword, }: {
         accountAddress: string;
-        newPassword: string; /**
-         * Disconnects from the wallet (no-op for WaaS)
-         */
+        newPassword: string;
     }): Promise<void>;
     signRawMessage({ accountAddress, message, password, }: {
         accountAddress: string;
@@ -180,8 +194,6 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
 /**
  * WaaS (Wallet-as-a-Service) connector for Midnight blockchain.
  * Extends the WaaS-specific Midnight base with MPC wallet functionality.
- *
- * Phase 1: Supports unshielded assets (NIGHT, MNTs) only.
  */
 export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightConnector_base implements IDynamicWaasConnector {
     ChainWallet: typeof MidnightWallet;
@@ -189,6 +201,7 @@ export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightCon
     overrideKey: string;
     isEmbeddedWallet: boolean;
     logger: Logger;
+    private static readonly SEND_BALANCE_TTL_MS;
     activeAccountAddress: string | undefined;
     verifiedCredentials: JwtVerifiedCredential[] | undefined;
     protected walletUiUtils: WalletUiUtils<InternalWalletConnector>;
@@ -301,6 +314,8 @@ export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightCon
      * @param from - The sender's address
      * @returns A new IUITransaction instance
      */
+    private sendBalanceCache;
+    private clearSendBalanceCache;
     createUiTransaction(from: string): Promise<IUITransaction>;
     /**
      * Returns the provider.
@@ -373,6 +388,23 @@ export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightCon
         message: string;
         registeredCount: number;
     }>;
+    /**
+     * One-call transfer: runs the full build → sign (ZK prove) → submit flow and
+     * returns the broadcast tx hash. This is what backs `wallet.sendBalance` for
+     * embedded Midnight wallets; use the individual steps
+     * (`createTransferTransaction` / `signTransaction` / `submitTransaction`) when
+     * you need to inspect or persist the transaction between stages.
+     */
+    createTransfer(params: {
+        transfers: Array<{
+            type: 'unshielded' | 'shielded';
+            recipientAddress: string;
+            amount: string;
+            tokenType?: string;
+        }>;
+        /** Optional TTL in minutes. Defaults to 5. */
+        ttlMinutes?: number;
+    }): Promise<string>;
     /**
      * Step 1 of the Midnight transfer flow.
      * Builds an unsigned UnprovenTransaction from one or more transfer specs.

package/src/waas/connector/DynamicWaasMidnightConnector.js

@@ -5,7 +5,7 @@ import { DynamicError } from '@dynamic-labs/utils';
 import { withDynamicWaas } from '@dynamic-labs/waas';
 import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
 import { Logger } from '@dynamic-labs/logger';
-import { MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE, MIDNIGHT_NATIVE_TOKEN_TYPE } from '../../constants.js';
+import { MIDNIGHT_NATIVE_TOKEN_TYPE } from '../../constants.js';
 import { MidnightUiTransaction } from '../../utils/MidnightUiTransaction/MidnightUiTransaction.js';
 import { MidnightWallet } from '../../wallet/MidnightWallet.js';
 import { WaasMidnightWalletConnector } from '../WaasMidnightWalletConnector.js';
@@ -14,8 +14,6 @@ import { buildMidnightWaasConnectedApi, normalizeDustBalance, toBigIntBalanceMap
 /**
  * WaaS (Wallet-as-a-Service) connector for Midnight blockchain.
  * Extends the WaaS-specific Midnight base with MPC wallet functionality.
- *
- * Phase 1: Supports unshielded assets (NIGHT, MNTs) only.
  */
 class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletConnector) {
     constructor(props) {
@@ -85,6 +83,8 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
      */
     afterWalletSelectHook(walletAddress) {
         this.setActiveAccountAddress(walletAddress);
+        // Different wallet → its balances are unrelated; drop any cached snapshot.
+        this.clearSendBalanceCache();
     }
     /**
      * Requires and returns the signed session ID
@@ -163,7 +163,9 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
      */
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            // WaaS doesn't require explicit disconnect
+            // WaaS doesn't require explicit disconnect, but drop the balance snapshot
+            // so a shielded balance isn't retained after the wallet is disconnected.
+            this.clearSendBalanceCache();
         });
     }
     /**
@@ -266,47 +268,54 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
             return signature;
         });
     }
-    /**
-     * Creates a UI transaction for the send balance flow
-     * @param from - The sender's address
-     * @returns A new IUITransaction instance
-     */
+    clearSendBalanceCache() {
+        this.sendBalanceCache = undefined;
+    }
     createUiTransaction(from) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.validateActiveWallet(from);
+            // Balances from the connector (MPC state) — never the redcoast
+            // public-balance endpoint, which rejects Midnight addresses. Reused from the
+            // short-lived cache across recreations (see field doc).
+            const now = Date.now();
+            if (!this.sendBalanceCache ||
+                now - this.sendBalanceCache.at >
+                    DynamicWaasMidnightConnector.SEND_BALANCE_TTL_MS) {
+                const { shielded, unshielded } = yield this.getBalances();
+                this.sendBalanceCache = { at: now, maps: { shielded, unshielded } };
+            }
+            const balances = this.sendBalanceCache.maps;
             return new MidnightUiTransaction({
+                balances,
                 // No on-chain dust-fee estimate is exposed yet; DUST fees are charged
                 // at submit time. TODO: surface a real estimate from the wallet client.
                 fetchDustFee: () => __awaiter(this, void 0, void 0, function* () { return BigInt(0); }),
                 from,
-                // Balances come from the connector (MPC state), reusing the cached
-                // synced wallet — never from the redcoast public-balance endpoint,
-                // which doesn't support Midnight addresses.
-                getShieldedBalance: () => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    return (_a = (yield this.getBalances()).shielded[MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE]) !== null && _a !== void 0 ? _a : BigInt(0);
-                }),
-                getUnshieldedBalance: () => __awaiter(this, void 0, void 0, function* () {
-                    var _b;
-                    return (_b = (yield this.getBalances()).unshielded[MIDNIGHT_NATIVE_TOKEN_TYPE]) !== null && _b !== void 0 ? _b : BigInt(0);
-                }),
                 onSubmit: (tx) => __awaiter(this, void 0, void 0, function* () {
                     if (tx.to === undefined || tx.value === undefined) {
                         throw new DynamicError('Recipient and amount are required before submitting');
                     }
+                    // Native NIGHT needs no tokenType; any other (shielded) token is passed
+                    // by its ledger token type so the correct balance is debited.
+                    const tokenType = tx.selectedTokenAddress === MIDNIGHT_NATIVE_TOKEN_TYPE
+                        ? undefined
+                        : tx.selectedTokenAddress;
                     // 3-step Midnight transfer: build → sign (ZK prove) → submit.
                     const { serializedTransaction } = yield this.createTransferTransaction({
                         transfers: [
                             {
                                 amount: tx.value.toString(),
                                 recipientAddress: tx.to,
+                                tokenType,
                                 type: tx.activePool,
                             },
                         ],
                     });
                     const finalized = yield this.signTransaction(serializedTransaction);
-                    // Return the tx hash so the Send flow advances to the success view.
                     const { txHash } = yield this.submitTransaction(finalized);
+                    // Balances changed — drop the snapshot so the next send fetches fresh.
+                    this.clearSendBalanceCache();
+                    // Return the tx hash so the Send flow advances to the success view.
                     return txHash;
                 }),
             });
@@ -437,6 +446,21 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
             });
         });
     }
+    /**
+     * One-call transfer: runs the full build → sign (ZK prove) → submit flow and
+     * returns the broadcast tx hash. This is what backs `wallet.sendBalance` for
+     * embedded Midnight wallets; use the individual steps
+     * (`createTransferTransaction` / `signTransaction` / `submitTransaction`) when
+     * you need to inspect or persist the transaction between stages.
+     */
+    createTransfer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { serializedTransaction } = yield this.createTransferTransaction(params);
+            const finalizedTransaction = yield this.signTransaction(serializedTransaction);
+            const { txHash } = yield this.submitTransaction(finalizedTransaction);
+            return txHash;
+        });
+    }
     /**
      * Step 1 of the Midnight transfer flow.
      * Builds an unsigned UnprovenTransaction from one or more transfer specs.
@@ -563,5 +587,7 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
         });
     }
 }
+// Max age of the Send-flow balance snapshot (see `sendBalanceCache`).
+DynamicWaasMidnightConnector.SEND_BALANCE_TTL_MS = 30000;
 
 export { DynamicWaasMidnightConnector };

package/src/wallet/MidnightWallet.cjs

@@ -69,24 +69,54 @@ class MidnightWallet extends walletConnectorCore.Wallet {
     getFormattedBalances() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const raw = yield this._connector.getBalances();
-            const shieldedRaw = raw.shielded[constants.MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE];
             const unshieldedRaw = raw.unshielded[constants.MIDNIGHT_NATIVE_TOKEN_TYPE];
             const dustEmpty = raw.dust.balance === BigInt(0) && raw.dust.cap === BigInt(0);
+            // The shielded pool holds non-NIGHT token types only, so surface a count of
+            // distinct tokens with a positive balance rather than a (non-existent)
+            // shielded NIGHT amount.
+            const shieldedTokenCount = Object.values(raw.shielded).filter((amount) => amount > BigInt(0)).length;
             return {
                 dustBalance: dustEmpty
                     ? undefined
                     : formatMidnightConnectorDustBalance.formatMidnightConnectorDustBalance(raw.dust.balance, raw.dust.cap),
                 // Passthrough (undefined for injected/external wallets, which omit it).
                 dustSyncing: raw.dustSyncing,
-                shieldedBalance: shieldedRaw !== undefined
-                    ? formatMidnightNativeUnshieldedBalance.formatMidnightNativeUnshieldedBalance(shieldedRaw)
-                    : undefined,
+                shieldedTokenCount,
                 unshieldedBalance: unshieldedRaw !== undefined
                     ? formatMidnightNativeUnshieldedBalance.formatMidnightNativeUnshieldedBalance(unshieldedRaw)
                     : undefined,
             };
         });
     }
+    // Exclusive for embedded Midnight wallets
+    /** Builds an unsigned transaction from one or more transfer specs (step 1). */
+    createTransferTransaction(...args) {
+        return this._connector.createTransferTransaction(...args);
+    }
+    /** Signs and ZK-proves an unsigned transaction via MPC (step 2). */
+    signTransaction(...args) {
+        return this._connector.signTransaction(...args);
+    }
+    /** Broadcasts a finalized transaction (step 3). */
+    submitTransaction(...args) {
+        return this._connector.submitTransaction(...args);
+    }
+    /** Registers the wallet's NIGHT for DUST generation. */
+    registerDust(...args) {
+        return this._connector.registerDust(...args);
+    }
+    /** Releases the reserved inputs of a specific built/signed transaction. */
+    revertTransaction(...args) {
+        return this._connector.revertTransaction(...args);
+    }
+    /** Releases every finalized-but-unsubmitted transaction's reserved inputs. */
+    revertAllPending(...args) {
+        return this._connector.revertAllPending(...args);
+    }
+    /** Clears the wallet's persisted state and forces a cold re-sync. */
+    resetWalletCache(...args) {
+        return this._connector.resetWalletCache(...args);
+    }
 }
 
 exports.MidnightWallet = MidnightWallet;

package/src/wallet/MidnightWallet.d.ts

@@ -20,6 +20,7 @@ export declare class MidnightWallet extends Wallet<MidnightWalletConnector> {
             cap: bigint;
             balance: bigint;
         };
+        dustSyncing?: boolean;
     }>;
     getShieldedBalance(): Promise<string | undefined>;
     getUnshieldedBalance(): Promise<string | undefined>;
@@ -28,4 +29,18 @@ export declare class MidnightWallet extends Wallet<MidnightWalletConnector> {
         cap: string;
     }>;
     getFormattedBalances(): Promise<MidnightFormattedBalances>;
+    /** Builds an unsigned transaction from one or more transfer specs (step 1). */
+    createTransferTransaction(...args: Parameters<MidnightWalletConnector['createTransferTransaction']>): ReturnType<MidnightWalletConnector['createTransferTransaction']>;
+    /** Signs and ZK-proves an unsigned transaction via MPC (step 2). */
+    signTransaction(...args: Parameters<MidnightWalletConnector['signTransaction']>): ReturnType<MidnightWalletConnector['signTransaction']>;
+    /** Broadcasts a finalized transaction (step 3). */
+    submitTransaction(...args: Parameters<MidnightWalletConnector['submitTransaction']>): ReturnType<MidnightWalletConnector['submitTransaction']>;
+    /** Registers the wallet's NIGHT for DUST generation. */
+    registerDust(...args: Parameters<MidnightWalletConnector['registerDust']>): ReturnType<MidnightWalletConnector['registerDust']>;
+    /** Releases the reserved inputs of a specific built/signed transaction. */
+    revertTransaction(...args: Parameters<MidnightWalletConnector['revertTransaction']>): ReturnType<MidnightWalletConnector['revertTransaction']>;
+    /** Releases every finalized-but-unsubmitted transaction's reserved inputs. */
+    revertAllPending(...args: Parameters<MidnightWalletConnector['revertAllPending']>): ReturnType<MidnightWalletConnector['revertAllPending']>;
+    /** Clears the wallet's persisted state and forces a cold re-sync. */
+    resetWalletCache(...args: Parameters<MidnightWalletConnector['resetWalletCache']>): ReturnType<MidnightWalletConnector['resetWalletCache']>;
 }

package/src/wallet/MidnightWallet.js

@@ -65,24 +65,54 @@ class MidnightWallet extends Wallet {
     getFormattedBalances() {
         return __awaiter(this, void 0, void 0, function* () {
             const raw = yield this._connector.getBalances();
-            const shieldedRaw = raw.shielded[MIDNIGHT_NATIVE_SHIELDED_TOKEN_TYPE];
             const unshieldedRaw = raw.unshielded[MIDNIGHT_NATIVE_TOKEN_TYPE];
             const dustEmpty = raw.dust.balance === BigInt(0) && raw.dust.cap === BigInt(0);
+            // The shielded pool holds non-NIGHT token types only, so surface a count of
+            // distinct tokens with a positive balance rather than a (non-existent)
+            // shielded NIGHT amount.
+            const shieldedTokenCount = Object.values(raw.shielded).filter((amount) => amount > BigInt(0)).length;
             return {
                 dustBalance: dustEmpty
                     ? undefined
                     : formatMidnightConnectorDustBalance(raw.dust.balance, raw.dust.cap),
                 // Passthrough (undefined for injected/external wallets, which omit it).
                 dustSyncing: raw.dustSyncing,
-                shieldedBalance: shieldedRaw !== undefined
-                    ? formatMidnightNativeUnshieldedBalance(shieldedRaw)
-                    : undefined,
+                shieldedTokenCount,
                 unshieldedBalance: unshieldedRaw !== undefined
                     ? formatMidnightNativeUnshieldedBalance(unshieldedRaw)
                     : undefined,
             };
         });
     }
+    // Exclusive for embedded Midnight wallets
+    /** Builds an unsigned transaction from one or more transfer specs (step 1). */
+    createTransferTransaction(...args) {
+        return this._connector.createTransferTransaction(...args);
+    }
+    /** Signs and ZK-proves an unsigned transaction via MPC (step 2). */
+    signTransaction(...args) {
+        return this._connector.signTransaction(...args);
+    }
+    /** Broadcasts a finalized transaction (step 3). */
+    submitTransaction(...args) {
+        return this._connector.submitTransaction(...args);
+    }
+    /** Registers the wallet's NIGHT for DUST generation. */
+    registerDust(...args) {
+        return this._connector.registerDust(...args);
+    }
+    /** Releases the reserved inputs of a specific built/signed transaction. */
+    revertTransaction(...args) {
+        return this._connector.revertTransaction(...args);
+    }
+    /** Releases every finalized-but-unsubmitted transaction's reserved inputs. */
+    revertAllPending(...args) {
+        return this._connector.revertAllPending(...args);
+    }
+    /** Clears the wallet's persisted state and forces a cold re-sync. */
+    resetWalletCache(...args) {
+        return this._connector.resetWalletCache(...args);
+    }
 }
 
 export { MidnightWallet };