@dynamic-labs/midnight 4.79.1 → 4.80.0

package/CHANGELOG.md

@@ -1,4 +1,20 @@
 
+## [4.80.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.79.2...v4.80.0) (2026-05-05)
+
+
+### Features
+
+* **aleo:** Aleo wallet connectors + send/shield token registries + UI transaction type ([#11101](https://github.com/dynamic-labs/dynamic-auth/issues/11101)) ([5478d9c](https://github.com/dynamic-labs/dynamic-auth/commit/5478d9c21ee065e2e6c8e96d37ab17b74c5aa0f8))
+* **midnight:** add address query methods and getProvider to InjectedWalletBase ([#11082](https://github.com/dynamic-labs/dynamic-auth/issues/11082)) ([9b6a870](https://github.com/dynamic-labs/dynamic-auth/commit/9b6a8709f83d04673e9dbe23bb0caae5827b036c))
+* **ton:** recognize v3R1/v3R2/v4 wallets in TonConnect proof verification ([#11130](https://github.com/dynamic-labs/dynamic-auth/issues/11130)) ([6c40ab1](https://github.com/dynamic-labs/dynamic-auth/commit/6c40ab11e56d56e278aeb5ee2ae982a42767b5cb))
+
+### [4.79.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.79.1...v4.79.2) (2026-05-04)
+
+
+### Bug Fixes
+
+* **react-native:** remove extra react-native turbo modules instructions ([#11126](https://github.com/dynamic-labs/dynamic-auth/issues/11126))
+
 ### [4.79.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.79.0...v4.79.1) (2026-05-01)
 
 

package/package.cjs

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

package/package.js

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

package/package.json

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

package/src/MidnightProviderHelper/MidnightProviderHelper.cjs

@@ -8,13 +8,46 @@ var utils = require('@dynamic-labs/utils');
 var walletBook = require('@dynamic-labs/wallet-book');
 var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var constants = require('../constants.cjs');
+var formatMidnightNativeUnshieldedBalance = require('../utils/formatMidnightNativeUnshieldedBalance/formatMidnightNativeUnshieldedBalance.cjs');
 
+const STORAGE_KEY_PREFIX = 'midnight.connected';
 class MidnightProviderHelper {
     constructor(connector) {
-        this._connectionGeneration = 0;
+        this._autoConnectAttempted = false;
         this.walletBookWallet = walletBook.findWalletBookWallet(connector.walletBook, connector.key);
         this.connector = connector;
     }
+    get storageKey() {
+        const { key } = this.connector;
+        if (!key) {
+            throw new Error('[MidnightProviderHelper] connector.key is required for session persistence');
+        }
+        return `${STORAGE_KEY_PREFIX}.${key}`;
+    }
+    persistConnection(rdns) {
+        try {
+            localStorage.setItem(this.storageKey, rdns);
+        }
+        catch (_a) {
+            // localStorage may be unavailable (SSR, private mode, quota exceeded)
+        }
+    }
+    clearPersistedConnection() {
+        try {
+            localStorage.removeItem(this.storageKey);
+        }
+        catch (_a) {
+            // localStorage may be unavailable
+        }
+    }
+    hasPersistedConnection() {
+        try {
+            return localStorage.getItem(this.storageKey) !== null;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
     getInjectedConfig() {
         var _a, _b;
         return (_b = (_a = this.walletBookWallet) === null || _a === void 0 ? void 0 : _a.injectedConfig) === null || _b === void 0 ? void 0 : _b.find((c) => c.chain === constants.MIDNIGHT_CHAIN);
@@ -26,7 +59,10 @@ class MidnightProviderHelper {
             return undefined;
         for (const windowLocation of config.windowLocations) {
             const [provider] = utils.getProvidersFromWindow(windowLocation);
-            if (provider)
+            // Guard against a partially-initialised provider: the wallet shell can
+            // appear in window.midnight before its internal registry is ready.
+            // rdns being present signals the provider is fully initialised.
+            if (provider === null || provider === void 0 ? void 0 : provider.rdns)
                 return provider;
         }
         return undefined;
@@ -36,30 +72,83 @@ class MidnightProviderHelper {
     }
     getConnectedAPI() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (this._connectedAPI)
-                return this._connectedAPI;
+            if (this._connectedAPI) {
+                try {
+                    const { status } = yield this._connectedAPI.getConnectionStatus();
+                    if (status === 'connected')
+                        return this._connectedAPI;
+                }
+                catch (_a) {
+                    // Status check failed — treat as disconnected and reconnect below.
+                }
+                this._connectedAPI = undefined;
+            }
             if (this._connectPromise)
                 return this._connectPromise;
-            const initialProvider = this.getInstalledProvider();
-            if (!initialProvider)
-                return undefined;
-            const generation = this._connectionGeneration;
-            this._connectPromise = initialProvider
-                .connect(this.connector.networkId)
-                .then((api) => {
-                if (this._connectionGeneration === generation) {
-                    this._connectedAPI = api;
-                }
-                return this._connectedAPI;
+            // Assigned synchronously so concurrent callers share the same promise.
+            // waitForProvider() polls window.midnight because extensions inject async.
+            const connectPromise = this.waitForProvider()
+                .then((initialProvider) => {
+                if (!initialProvider)
+                    return undefined;
+                return initialProvider
+                    .connect(this.connector.networkId)
+                    .then((api) => {
+                    // Only cache if this promise is still the active one.
+                    // disconnect() nulls _connectPromise, so a stale resolve after
+                    // disconnect won't overwrite the cleared connection state.
+                    if (this._connectPromise === connectPromise) {
+                        this._connectedAPI = api;
+                        this.persistConnection(initialProvider.rdns);
+                    }
+                    return api;
+                });
             })
                 .catch((err) => {
                 walletConnectorCore.logger.error('[MidnightProviderHelper] getConnectedAPI - Error connecting to wallet', err);
                 return undefined;
             })
                 .finally(() => {
-                this._connectPromise = undefined;
+                if (this._connectPromise === connectPromise) {
+                    this._connectPromise = undefined;
+                }
             });
-            return this._connectPromise;
+            this._connectPromise = connectPromise;
+            return connectPromise;
+        });
+    }
+    // Polls window.midnight until the provider injects (extensions inject async).
+    // Resolves undefined after timeoutMs if still not present.
+    waitForProvider(timeoutMs = 2000) {
+        const immediate = this.getInstalledProvider();
+        if (immediate)
+            return Promise.resolve(immediate);
+        return new Promise((resolve) => {
+            const deadline = Date.now() + timeoutMs;
+            const poll = () => {
+                const provider = this.getInstalledProvider();
+                if (provider)
+                    return resolve(provider);
+                if (Date.now() >= deadline)
+                    return resolve(undefined);
+                setTimeout(poll, 100);
+            };
+            setTimeout(poll, 100);
+        });
+    }
+    // Attempts a silent reconnect using the persisted session. Only tries once per
+    // page load — PermissionRejected is tab-scoped so retrying would just fail again.
+    // Delegates to getConnectedAPI() so status checks and deduplication are shared.
+    tryAutoConnect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this._connectPromise)
+                return this._connectPromise;
+            if (this._autoConnectAttempted)
+                return undefined;
+            if (!this.hasPersistedConnection())
+                return undefined;
+            this._autoConnectAttempted = true;
+            return this.getConnectedAPI();
         });
     }
     getAddress() {
@@ -71,6 +160,11 @@ class MidnightProviderHelper {
             return unshieldedAddress;
         });
     }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this.connector.networkId;
+        });
+    }
     getAddressIfConnected() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             if (!this._connectedAPI)
@@ -79,23 +173,52 @@ class MidnightProviderHelper {
             return unshieldedAddress;
         });
     }
+    getUnshieldedBalance() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api)
+                return undefined;
+            const response = yield api.getUnshieldedBalances();
+            const raw = response[constants.MIDNIGHT_NATIVE_TOKEN_TYPE];
+            if (raw === undefined)
+                return undefined;
+            return formatMidnightNativeUnshieldedBalance.formatMidnightNativeUnshieldedBalance(raw);
+        });
+    }
+    getBalances() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('[MidnightProviderHelper] getBalances requires a connected Midnight wallet');
+            }
+            const [shielded, unshielded, dust] = yield Promise.all([
+                api.getShieldedBalances(),
+                api.getUnshieldedBalances(),
+                api.getDustBalance(),
+            ]);
+            return { dust, shielded, unshielded };
+        });
+    }
     signMessage(messageToSign) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const api = yield this.getConnectedAPI();
             if (!api)
                 return undefined;
-            const { signature } = yield api.signData(messageToSign, {
+            // hintUsage pre-fetches signing permission; wallet resolves this only after
+            // the user grants it, ensuring signData succeeds immediately on first call.
+            yield api.hintUsage(['signData']);
+            const { signature, verifyingKey } = yield api.signData(messageToSign, {
                 encoding: 'text',
                 keyType: 'unshielded',
             });
-            return signature;
+            return JSON.stringify({ signature, verifyingKey });
         });
     }
     disconnect() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            this._connectionGeneration++;
             this._connectedAPI = undefined;
             this._connectPromise = undefined;
+            this.clearPersistedConnection();
         });
     }
     // Midnight ConnectedAPI does not expose event listeners.

package/src/MidnightProviderHelper/MidnightProviderHelper.d.ts

@@ -1,12 +1,16 @@
-import type { ConnectedAPI, InitialAPI } from '@midnight-ntwrk/dapp-connector-api';
+import type { ConnectedAPI, InitialAPI, TokenType } from '@midnight-ntwrk/dapp-connector-api';
 import type { InjectedWalletBase } from '../injected/InjectedWalletBase/InjectedWalletBase';
 export declare class MidnightProviderHelper {
     private walletBookWallet;
     private connector;
     private _connectedAPI;
     private _connectPromise;
-    private _connectionGeneration;
+    private _autoConnectAttempted;
     constructor(connector: InjectedWalletBase);
+    private get storageKey();
+    private persistConnection;
+    private clearPersistedConnection;
+    hasPersistedConnection(): boolean;
     getInjectedConfig(): {
         chain: string;
         extensionLocators: {
@@ -28,8 +32,20 @@ export declare class MidnightProviderHelper {
     getInstalledProvider(): InitialAPI | undefined;
     isInstalledHelper(): boolean;
     getConnectedAPI(): Promise<ConnectedAPI | undefined>;
+    private waitForProvider;
+    tryAutoConnect(): Promise<ConnectedAPI | undefined>;
     getAddress(): Promise<string | undefined>;
+    getNetwork(): Promise<string | undefined>;
     getAddressIfConnected(): Promise<string | undefined>;
+    getUnshieldedBalance(): Promise<string | undefined>;
+    getBalances(): Promise<{
+        dust: {
+            balance: bigint;
+            cap: bigint;
+        };
+        shielded: Record<TokenType, bigint>;
+        unshielded: Record<TokenType, bigint>;
+    }>;
     signMessage(messageToSign: string): Promise<string | undefined>;
     disconnect(): Promise<void>;
     _setupEventListeners(): void;

package/src/MidnightProviderHelper/MidnightProviderHelper.js

@@ -3,14 +3,47 @@ import { __awaiter } from '../../_virtual/_tslib.js';
 import { getProvidersFromWindow } from '@dynamic-labs/utils';
 import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
 import { logger } from '@dynamic-labs/wallet-connector-core';
-import { MIDNIGHT_CHAIN } from '../constants.js';
+import { MIDNIGHT_CHAIN, MIDNIGHT_NATIVE_TOKEN_TYPE } from '../constants.js';
+import { formatMidnightNativeUnshieldedBalance } from '../utils/formatMidnightNativeUnshieldedBalance/formatMidnightNativeUnshieldedBalance.js';
 
+const STORAGE_KEY_PREFIX = 'midnight.connected';
 class MidnightProviderHelper {
     constructor(connector) {
-        this._connectionGeneration = 0;
+        this._autoConnectAttempted = false;
         this.walletBookWallet = findWalletBookWallet(connector.walletBook, connector.key);
         this.connector = connector;
     }
+    get storageKey() {
+        const { key } = this.connector;
+        if (!key) {
+            throw new Error('[MidnightProviderHelper] connector.key is required for session persistence');
+        }
+        return `${STORAGE_KEY_PREFIX}.${key}`;
+    }
+    persistConnection(rdns) {
+        try {
+            localStorage.setItem(this.storageKey, rdns);
+        }
+        catch (_a) {
+            // localStorage may be unavailable (SSR, private mode, quota exceeded)
+        }
+    }
+    clearPersistedConnection() {
+        try {
+            localStorage.removeItem(this.storageKey);
+        }
+        catch (_a) {
+            // localStorage may be unavailable
+        }
+    }
+    hasPersistedConnection() {
+        try {
+            return localStorage.getItem(this.storageKey) !== null;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
     getInjectedConfig() {
         var _a, _b;
         return (_b = (_a = this.walletBookWallet) === null || _a === void 0 ? void 0 : _a.injectedConfig) === null || _b === void 0 ? void 0 : _b.find((c) => c.chain === MIDNIGHT_CHAIN);
@@ -22,7 +55,10 @@ class MidnightProviderHelper {
             return undefined;
         for (const windowLocation of config.windowLocations) {
             const [provider] = getProvidersFromWindow(windowLocation);
-            if (provider)
+            // Guard against a partially-initialised provider: the wallet shell can
+            // appear in window.midnight before its internal registry is ready.
+            // rdns being present signals the provider is fully initialised.
+            if (provider === null || provider === void 0 ? void 0 : provider.rdns)
                 return provider;
         }
         return undefined;
@@ -32,30 +68,83 @@ class MidnightProviderHelper {
     }
     getConnectedAPI() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this._connectedAPI)
-                return this._connectedAPI;
+            if (this._connectedAPI) {
+                try {
+                    const { status } = yield this._connectedAPI.getConnectionStatus();
+                    if (status === 'connected')
+                        return this._connectedAPI;
+                }
+                catch (_a) {
+                    // Status check failed — treat as disconnected and reconnect below.
+                }
+                this._connectedAPI = undefined;
+            }
             if (this._connectPromise)
                 return this._connectPromise;
-            const initialProvider = this.getInstalledProvider();
-            if (!initialProvider)
-                return undefined;
-            const generation = this._connectionGeneration;
-            this._connectPromise = initialProvider
-                .connect(this.connector.networkId)
-                .then((api) => {
-                if (this._connectionGeneration === generation) {
-                    this._connectedAPI = api;
-                }
-                return this._connectedAPI;
+            // Assigned synchronously so concurrent callers share the same promise.
+            // waitForProvider() polls window.midnight because extensions inject async.
+            const connectPromise = this.waitForProvider()
+                .then((initialProvider) => {
+                if (!initialProvider)
+                    return undefined;
+                return initialProvider
+                    .connect(this.connector.networkId)
+                    .then((api) => {
+                    // Only cache if this promise is still the active one.
+                    // disconnect() nulls _connectPromise, so a stale resolve after
+                    // disconnect won't overwrite the cleared connection state.
+                    if (this._connectPromise === connectPromise) {
+                        this._connectedAPI = api;
+                        this.persistConnection(initialProvider.rdns);
+                    }
+                    return api;
+                });
             })
                 .catch((err) => {
                 logger.error('[MidnightProviderHelper] getConnectedAPI - Error connecting to wallet', err);
                 return undefined;
             })
                 .finally(() => {
-                this._connectPromise = undefined;
+                if (this._connectPromise === connectPromise) {
+                    this._connectPromise = undefined;
+                }
             });
-            return this._connectPromise;
+            this._connectPromise = connectPromise;
+            return connectPromise;
+        });
+    }
+    // Polls window.midnight until the provider injects (extensions inject async).
+    // Resolves undefined after timeoutMs if still not present.
+    waitForProvider(timeoutMs = 2000) {
+        const immediate = this.getInstalledProvider();
+        if (immediate)
+            return Promise.resolve(immediate);
+        return new Promise((resolve) => {
+            const deadline = Date.now() + timeoutMs;
+            const poll = () => {
+                const provider = this.getInstalledProvider();
+                if (provider)
+                    return resolve(provider);
+                if (Date.now() >= deadline)
+                    return resolve(undefined);
+                setTimeout(poll, 100);
+            };
+            setTimeout(poll, 100);
+        });
+    }
+    // Attempts a silent reconnect using the persisted session. Only tries once per
+    // page load — PermissionRejected is tab-scoped so retrying would just fail again.
+    // Delegates to getConnectedAPI() so status checks and deduplication are shared.
+    tryAutoConnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._connectPromise)
+                return this._connectPromise;
+            if (this._autoConnectAttempted)
+                return undefined;
+            if (!this.hasPersistedConnection())
+                return undefined;
+            this._autoConnectAttempted = true;
+            return this.getConnectedAPI();
         });
     }
     getAddress() {
@@ -67,6 +156,11 @@ class MidnightProviderHelper {
             return unshieldedAddress;
         });
     }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.connector.networkId;
+        });
+    }
     getAddressIfConnected() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this._connectedAPI)
@@ -75,23 +169,52 @@ class MidnightProviderHelper {
             return unshieldedAddress;
         });
     }
+    getUnshieldedBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api)
+                return undefined;
+            const response = yield api.getUnshieldedBalances();
+            const raw = response[MIDNIGHT_NATIVE_TOKEN_TYPE];
+            if (raw === undefined)
+                return undefined;
+            return formatMidnightNativeUnshieldedBalance(raw);
+        });
+    }
+    getBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = yield this.getConnectedAPI();
+            if (!api) {
+                throw new Error('[MidnightProviderHelper] getBalances requires a connected Midnight wallet');
+            }
+            const [shielded, unshielded, dust] = yield Promise.all([
+                api.getShieldedBalances(),
+                api.getUnshieldedBalances(),
+                api.getDustBalance(),
+            ]);
+            return { dust, shielded, unshielded };
+        });
+    }
     signMessage(messageToSign) {
         return __awaiter(this, void 0, void 0, function* () {
             const api = yield this.getConnectedAPI();
             if (!api)
                 return undefined;
-            const { signature } = yield api.signData(messageToSign, {
+            // hintUsage pre-fetches signing permission; wallet resolves this only after
+            // the user grants it, ensuring signData succeeds immediately on first call.
+            yield api.hintUsage(['signData']);
+            const { signature, verifyingKey } = yield api.signData(messageToSign, {
                 encoding: 'text',
                 keyType: 'unshielded',
             });
-            return signature;
+            return JSON.stringify({ signature, verifyingKey });
         });
     }
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._connectionGeneration++;
             this._connectedAPI = undefined;
             this._connectPromise = undefined;
+            this.clearPersistedConnection();
         });
     }
     // Midnight ConnectedAPI does not expose event listeners.

package/src/MidnightWalletConnectors.cjs

@@ -0,0 +1,13 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fetchInjectedWalletConnectors = require('./injected/fetchInjectedWalletConnectors/fetchInjectedWalletConnectors.cjs');
+
+const MidnightWalletConnectors = (props) => [
+    ...fetchInjectedWalletConnectors.injectedWalletOverrides,
+    ...fetchInjectedWalletConnectors.fetchInjectedWalletConnectors(Object.assign(Object.assign({}, props), { walletsWithCustomConnectors: [] })),
+];
+
+exports.MidnightWalletConnectors = MidnightWalletConnectors;

package/src/MidnightWalletConnectors.d.ts

@@ -0,0 +1,3 @@
+import { WalletConnectorConstructor } from '@dynamic-labs/wallet-connector-core';
+import { MidnightWalletConnectorOpts } from './types';
+export declare const MidnightWalletConnectors: (props: MidnightWalletConnectorOpts) => WalletConnectorConstructor[];

package/src/MidnightWalletConnectors.js

@@ -0,0 +1,9 @@
+'use client'
+import { injectedWalletOverrides, fetchInjectedWalletConnectors } from './injected/fetchInjectedWalletConnectors/fetchInjectedWalletConnectors.js';
+
+const MidnightWalletConnectors = (props) => [
+    ...injectedWalletOverrides,
+    ...fetchInjectedWalletConnectors(Object.assign(Object.assign({}, props), { walletsWithCustomConnectors: [] })),
+];
+
+export { MidnightWalletConnectors };