@dynamic-labs/midnight 4.95.1 → 4.96.0

package/CHANGELOG.md

@@ -1,4 +1,24 @@
 
+## [4.96.0](https://github.com/dynamic-labs/dynamic-auth/compare/v4.95.2...v4.96.0) (2026-08-03)
+
+
+### Features
+
+* **midnight:** add contract wallet provider support ([#12133](https://github.com/dynamic-labs/dynamic-auth/issues/12133)) ([f649ce4](https://github.com/dynamic-labs/dynamic-auth/commit/f649ce47101b439542e8db1c802a4a372fb45eb2))
+
+
+### Bug Fixes
+
+* **starknet:** restore Braavos L2 session after lock and unlock ([#12125](https://github.com/dynamic-labs/dynamic-auth/issues/12125)) ([9ea226f](https://github.com/dynamic-labs/dynamic-auth/commit/9ea226f1dd2a58e3087c267d74cfe79452ddaeff))
+* **wallet-book:** add universal deep link for Exodus Solana WalletConnect ([168dba5](https://github.com/dynamic-labs/dynamic-auth/commit/168dba5aa6076a769b78394eef093c91948b3c91)), closes [#12123](https://github.com/dynamic-labs/dynamic-auth/issues/12123)
+
+### [4.95.2](https://github.com/dynamic-labs/dynamic-auth/compare/v4.95.1...v4.95.2) (2026-07-30)
+
+
+### Bug Fixes
+
+* **ethereum-aa:** resolve chainId from network for ZeroDev v2 multichain projects ([#12106](https://github.com/dynamic-labs/dynamic-auth/issues/12106)) ([76f18b0](https://github.com/dynamic-labs/dynamic-auth/commit/76f18b0a861aa916f949a919e65a185c6c32673f)), closes [#12105](https://github.com/dynamic-labs/dynamic-auth/issues/12105) [#12105](https://github.com/dynamic-labs/dynamic-auth/issues/12105)
+
 ### [4.95.1](https://github.com/dynamic-labs/dynamic-auth/compare/v4.95.0...v4.95.1) (2026-07-28)
 
 

package/package.cjs

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

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/midnight",
-  "version": "4.95.1",
+  "version": "4.96.0",
   "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.95.1",
+    "@dynamic-labs/assert-package-version": "4.96.0",
     "@dynamic-labs/sdk-api-core": "0.0.1093",
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",
-    "@dynamic-labs/logger": "4.95.1",
-    "@dynamic-labs/types": "4.95.1",
-    "@dynamic-labs/utils": "4.95.1",
-    "@dynamic-labs/waas": "4.95.1",
-    "@dynamic-labs/wallet-book": "4.95.1",
-    "@dynamic-labs/wallet-connector-core": "4.95.1"
+    "@dynamic-labs/logger": "4.96.0",
+    "@dynamic-labs/types": "4.96.0",
+    "@dynamic-labs/utils": "4.96.0",
+    "@dynamic-labs/waas": "4.96.0",
+    "@dynamic-labs/wallet-book": "4.96.0",
+    "@dynamic-labs/wallet-connector-core": "4.96.0"
   },
   "peerDependencies": {}
 }

package/src/types.d.ts

@@ -22,6 +22,38 @@ export type MidnightTransaction = {
     circuitCalls: MidnightCircuitCall[];
     fee?: number;
 };
+/**
+ * Minimal structural view of a ledger transaction — only what is needed to move
+ * one across the embedded-wallet boundary.
+ */
+export type MidnightSerializableTransaction = {
+    serialize(): Uint8Array;
+};
+/**
+ * midnight-js compatible wallet and submission provider backed by an embedded
+ * wallet. Structurally equivalent to `WalletProvider & MidnightProvider` from
+ * `@midnight-ntwrk/midnight-js/types`, declared here rather than imported so
+ * this package carries no dependency on the consumer's midnight-js or
+ * ledger-v8 version.
+ *
+ * Transaction objects are deliberately structural so consumers can use their
+ * installed midnight-js/ledger version without sharing secret key state.
+ * Parameterise with the consumer's own `UnboundTransaction` and
+ * `FinalizedTransaction` to get a provider assignable to `MidnightProviders`:
+ *
+ * ```ts
+ * const walletProvider = await wallet.getWalletProvider<
+ *   UnboundTransaction,
+ *   FinalizedTransaction
+ * >();
+ * ```
+ */
+export type MidnightContractWalletProvider<TUnboundTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction, TFinalizedTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction> = {
+    balanceTx(tx: TUnboundTransaction, ttl?: Date): Promise<TFinalizedTransaction>;
+    getCoinPublicKey(): string;
+    getEncryptionPublicKey(): string;
+    submitTx(tx: TFinalizedTransaction): Promise<string>;
+};
 /**
  * Minimal interface for the Midnight wallet provider injected into window.
  *

package/src/waas/connector/DynamicWaasMidnightConnector.cjs

@@ -163,6 +163,31 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
     midnightNetworkParam() {
         return { networkId: this.getSelectedMidnightNetwork() };
     }
+    getWalletProviderRequestParams(accountAddress, networkId) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (this.activeAccountAddress !== accountAddress) {
+                throw new utils.DynamicError('The active Midnight wallet changed after the contract wallet provider was created', 'midnight_wallet_provider_account_changed');
+            }
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: sdkApiCore.MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({ accountAddress });
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: sdkApiCore.TokenScope.Walletsign,
+            }));
+            return {
+                accountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                networkId,
+                password,
+                signedSessionId,
+            };
+        });
+    }
     /**
      * Gets the active wallet address for the selected network.
      *
@@ -370,6 +395,67 @@ class DynamicWaasMidnightConnector extends waas.withDynamicWaas(WaasMidnightWall
     getProvider() {
         return undefined;
     }
+    /**
+     * Returns a midnight-js compatible provider whose wallet-bound operations
+     * execute inside the embedded-wallet iframe. Only public keys and serialized
+     * transactions cross the iframe boundary.
+     */
+    getWalletProvider() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new utils.DynamicError('Active account address is required', 'active_account_address_is_required');
+            }
+            const accountAddress = this.activeAccountAddress;
+            const networkId = this.getSelectedMidnightNetwork();
+            const walletClient = (yield this.getWaasWalletClient());
+            // The cast above asserts RPCs that older embedded-wallet clients do not
+            // expose. Without this check the caller gets an unattributable
+            // "is not a function" TypeError instead of the actual cause.
+            const missingRpcs = ['getWalletProvider', 'balanceWalletProviderTransaction'].filter((rpc) => typeof walletClient[rpc] !== 'function');
+            if (missingRpcs.length > 0) {
+                throw new utils.DynamicError(`The embedded wallet client does not support Midnight contract wallet providers (missing: ${missingRpcs.join(', ')}). Upgrade @dynamic-labs-wallet/browser-wallet-client to a version that exposes these operations.`, 'midnight_wallet_provider_unsupported_client');
+            }
+            const initParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+            const { coinPublicKey, encryptionPublicKey } = yield walletClient.getWalletProvider(initParams);
+            return {
+                balanceTx: (transaction, ttl) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    const requestParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+                    const transactionConstructor = transaction.constructor;
+                    // Reached through `transaction.constructor` so this package never
+                    // imports ledger-v8 and stays free of the consumer's ledger version.
+                    // The type constraint only guarantees `serialize()`, so the static is
+                    // checked rather than assumed — a wrapped or proxied transaction would
+                    // otherwise fail with a bare "deserialize is not a function". Checked
+                    // before the balance call below so a wrapper transaction fails
+                    // side-effect free, rather than after UTXOs are already reserved.
+                    if (typeof (transactionConstructor === null || transactionConstructor === void 0 ? void 0 : transactionConstructor.deserialize) !== 'function') {
+                        throw new utils.DynamicError('The transaction passed to balanceTx has no static deserialize; pass a ledger Transaction rather than a wrapper', 'midnight_transaction_not_deserializable');
+                    }
+                    const response = yield walletClient.balanceWalletProviderTransaction(Object.assign(Object.assign({}, requestParams), { transaction: utils.uint8ArrayToBase64(transaction.serialize()), ttl: ttl === null || ttl === void 0 ? void 0 : ttl.toISOString() }));
+                    return transactionConstructor.deserialize('signature', 'proof', 'binding', utils.uint8ArrayFromBase64(response.transaction));
+                }),
+                getCoinPublicKey: () => coinPublicKey,
+                getEncryptionPublicKey: () => encryptionPublicKey,
+                submitTx: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    const requestParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+                    // `txIdentifier` is newer than the published client's type, so it is
+                    // read through a cast: this compiles against both, and an older client
+                    // simply degrades to the hash.
+                    const { txHash, txIdentifier } = (yield walletClient.submitTransaction(Object.assign(Object.assign({}, requestParams), { transaction: utils.uint8ArrayToBase64(transaction.serialize()) })));
+                    // Balances changed — drop the snapshot so the next send fetches fresh.
+                    this.clearSendBalanceCache();
+                    // midnight-js treats this return value as a TransactionId and polls
+                    // `transactions(offset: { identifier })` to observe inclusion. The
+                    // canonical hash is a different value and never matches, so returning
+                    // it leaves callers such as deployContract waiting on a transaction
+                    // that already succeeded. Prefer the submission identifier; fall back
+                    // to the hash for older wallet clients that do not return it.
+                    return txIdentifier !== null && txIdentifier !== void 0 ? txIdentifier : txHash;
+                }),
+            };
+        });
+    }
     /**
      * Creates a new Midnight wallet account.
      * Midnight wallets automatically create multiple address types:

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

@@ -3,7 +3,7 @@ import { JwtVerifiedCredential, MFAAction, SignMessageContext, TokenScope } from
 import { IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
 import { IDynamicWaasConnector, InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
 import { Logger } from '@dynamic-labs/logger';
-import type { DynamicWaasMidnightConnectorProps } from '../../types';
+import type { DynamicWaasMidnightConnectorProps, MidnightContractWalletProvider, MidnightSerializableTransaction } from '../../types';
 import { MidnightWallet } from '../../wallet/MidnightWallet';
 import { WaasMidnightWalletConnector } from '../WaasMidnightWalletConnector';
 declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[]) => {
@@ -137,12 +137,6 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
         displayContainer: HTMLElement;
     }): Promise<void>;
     hideICloudSignIn(): Promise<void>;
-    /**
-     * Spread into wallet-client calls. Published browser-wallet-client builds
-     * that predate per-network support don't declare `networkId` — spreading a
-     * non-literal keeps this compiling against those types; older clients drop
-     * the field and default to preview.
-     */
     isICloudAuthenticated(): Promise<boolean>;
     refreshWalletAccountShares({ accountAddress, password, }: {
         accountAddress: string;
@@ -150,7 +144,12 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
     }): Promise<void>;
     reshareWalletAccountShares({ accountAddress, thresholdSignatureScheme, password, }: {
         accountAddress: string;
-        thresholdSignatureScheme: string;
+        thresholdSignatureScheme: string; /**
+         * Spread into wallet-client calls. Published browser-wallet-client builds
+         * that predate per-network support don't declare `networkId` — spreading a
+         * non-literal keeps this compiling against those types; older clients drop
+         * the field and default to preview.
+         */
         password?: string | undefined;
     }): Promise<void>;
     revokeDelegation({ accountAddress, password, }: {
@@ -302,6 +301,7 @@ export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightCon
      * the field and default to preview.
      */
     private midnightNetworkParam;
+    private getWalletProviderRequestParams;
     /**
      * Gets the active wallet address for the selected network.
      *
@@ -363,6 +363,12 @@ export declare class DynamicWaasMidnightConnector extends DynamicWaasMidnightCon
      * For WaaS, there is no traditional browser provider.
      */
     getProvider(): undefined;
+    /**
+     * Returns a midnight-js compatible provider whose wallet-bound operations
+     * execute inside the embedded-wallet iframe. Only public keys and serialized
+     * transactions cross the iframe boundary.
+     */
+    getWalletProvider<TUnboundTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction, TFinalizedTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction>(): Promise<MidnightContractWalletProvider<TUnboundTransaction, TFinalizedTransaction>>;
     /**
      * Creates a new Midnight wallet account.
      * Midnight wallets automatically create multiple address types:

package/src/waas/connector/DynamicWaasMidnightConnector.js

@@ -1,7 +1,7 @@
 'use client'
 import { __awaiter } from '../../../_virtual/_tslib.js';
 import { MFAAction, TokenScope } from '@dynamic-labs/sdk-api-core';
-import { DynamicError } from '@dynamic-labs/utils';
+import { DynamicError, uint8ArrayToBase64, uint8ArrayFromBase64 } from '@dynamic-labs/utils';
 import { withDynamicWaas } from '@dynamic-labs/waas';
 import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
 import { Logger } from '@dynamic-labs/logger';
@@ -159,6 +159,31 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
     midnightNetworkParam() {
         return { networkId: this.getSelectedMidnightNetwork() };
     }
+    getWalletProviderRequestParams(accountAddress, networkId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (this.activeAccountAddress !== accountAddress) {
+                throw new DynamicError('The active Midnight wallet changed after the contract wallet provider was created', 'midnight_wallet_provider_account_changed');
+            }
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const password = yield this.getPasswordIfNeeded({ accountAddress });
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            return {
+                accountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                networkId,
+                password,
+                signedSessionId,
+            };
+        });
+    }
     /**
      * Gets the active wallet address for the selected network.
      *
@@ -366,6 +391,67 @@ class DynamicWaasMidnightConnector extends withDynamicWaas(WaasMidnightWalletCon
     getProvider() {
         return undefined;
     }
+    /**
+     * Returns a midnight-js compatible provider whose wallet-bound operations
+     * execute inside the embedded-wallet iframe. Only public keys and serialized
+     * transactions cross the iframe boundary.
+     */
+    getWalletProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required', 'active_account_address_is_required');
+            }
+            const accountAddress = this.activeAccountAddress;
+            const networkId = this.getSelectedMidnightNetwork();
+            const walletClient = (yield this.getWaasWalletClient());
+            // The cast above asserts RPCs that older embedded-wallet clients do not
+            // expose. Without this check the caller gets an unattributable
+            // "is not a function" TypeError instead of the actual cause.
+            const missingRpcs = ['getWalletProvider', 'balanceWalletProviderTransaction'].filter((rpc) => typeof walletClient[rpc] !== 'function');
+            if (missingRpcs.length > 0) {
+                throw new DynamicError(`The embedded wallet client does not support Midnight contract wallet providers (missing: ${missingRpcs.join(', ')}). Upgrade @dynamic-labs-wallet/browser-wallet-client to a version that exposes these operations.`, 'midnight_wallet_provider_unsupported_client');
+            }
+            const initParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+            const { coinPublicKey, encryptionPublicKey } = yield walletClient.getWalletProvider(initParams);
+            return {
+                balanceTx: (transaction, ttl) => __awaiter(this, void 0, void 0, function* () {
+                    const requestParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+                    const transactionConstructor = transaction.constructor;
+                    // Reached through `transaction.constructor` so this package never
+                    // imports ledger-v8 and stays free of the consumer's ledger version.
+                    // The type constraint only guarantees `serialize()`, so the static is
+                    // checked rather than assumed — a wrapped or proxied transaction would
+                    // otherwise fail with a bare "deserialize is not a function". Checked
+                    // before the balance call below so a wrapper transaction fails
+                    // side-effect free, rather than after UTXOs are already reserved.
+                    if (typeof (transactionConstructor === null || transactionConstructor === void 0 ? void 0 : transactionConstructor.deserialize) !== 'function') {
+                        throw new DynamicError('The transaction passed to balanceTx has no static deserialize; pass a ledger Transaction rather than a wrapper', 'midnight_transaction_not_deserializable');
+                    }
+                    const response = yield walletClient.balanceWalletProviderTransaction(Object.assign(Object.assign({}, requestParams), { transaction: uint8ArrayToBase64(transaction.serialize()), ttl: ttl === null || ttl === void 0 ? void 0 : ttl.toISOString() }));
+                    return transactionConstructor.deserialize('signature', 'proof', 'binding', uint8ArrayFromBase64(response.transaction));
+                }),
+                getCoinPublicKey: () => coinPublicKey,
+                getEncryptionPublicKey: () => encryptionPublicKey,
+                submitTx: (transaction) => __awaiter(this, void 0, void 0, function* () {
+                    const requestParams = yield this.getWalletProviderRequestParams(accountAddress, networkId);
+                    // `txIdentifier` is newer than the published client's type, so it is
+                    // read through a cast: this compiles against both, and an older client
+                    // simply degrades to the hash.
+                    const { txHash, txIdentifier } = (yield walletClient.submitTransaction(Object.assign(Object.assign({}, requestParams), { transaction: uint8ArrayToBase64(transaction.serialize()) })));
+                    // Balances changed — drop the snapshot so the next send fetches fresh.
+                    this.clearSendBalanceCache();
+                    // midnight-js treats this return value as a TransactionId and polls
+                    // `transactions(offset: { identifier })` to observe inclusion. The
+                    // canonical hash is a different value and never matches, so returning
+                    // it leaves callers such as deployContract waiting on a transaction
+                    // that already succeeded. Prefer the submission identifier; fall back
+                    // to the hash for older wallet clients that do not return it.
+                    return txIdentifier !== null && txIdentifier !== void 0 ? txIdentifier : txHash;
+                }),
+            };
+        });
+    }
     /**
      * Creates a new Midnight wallet account.
      * Midnight wallets automatically create multiple address types:

package/src/wallet/MidnightWallet.cjs

@@ -89,6 +89,16 @@ class MidnightWallet extends walletConnectorCore.Wallet {
         });
     }
     // Exclusive for embedded Midnight wallets
+    /** Creates a midnight-js provider backed by the embedded-wallet iframe. */
+    getWalletProvider() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connector = this._connector;
+            if (!connector.getWalletProvider) {
+                throw new Error('Contract wallet providers are only supported for embedded Midnight wallets');
+            }
+            return connector.getWalletProvider();
+        });
+    }
     /** Builds an unsigned transaction from one or more transfer specs (step 1). */
     createTransferTransaction(...args) {
         return this._connector.createTransferTransaction(...args);

package/src/wallet/MidnightWallet.d.ts

@@ -2,6 +2,7 @@ import { TokenType } from '@midnight-ntwrk/dapp-connector-api';
 import { type MidnightFormattedBalances, Wallet } from '@dynamic-labs/wallet-connector-core';
 import { WalletAddressType } from '@dynamic-labs/sdk-api-core';
 import { MidnightWalletConnector } from '../connectors/MidnightWalletConnector';
+import type { MidnightContractWalletProvider, MidnightSerializableTransaction } from '../types';
 export declare class MidnightWallet extends Wallet<MidnightWalletConnector> {
     sendBalance({ amount, toAddress, token, }: {
         amount: string;
@@ -29,6 +30,8 @@ export declare class MidnightWallet extends Wallet<MidnightWalletConnector> {
         cap: string;
     }>;
     getFormattedBalances(): Promise<MidnightFormattedBalances>;
+    /** Creates a midnight-js provider backed by the embedded-wallet iframe. */
+    getWalletProvider<TUnboundTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction, TFinalizedTransaction extends MidnightSerializableTransaction = MidnightSerializableTransaction>(): Promise<MidnightContractWalletProvider<TUnboundTransaction, TFinalizedTransaction>>;
     /** 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). */

package/src/wallet/MidnightWallet.js

@@ -85,6 +85,16 @@ class MidnightWallet extends Wallet {
         });
     }
     // Exclusive for embedded Midnight wallets
+    /** Creates a midnight-js provider backed by the embedded-wallet iframe. */
+    getWalletProvider() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connector = this._connector;
+            if (!connector.getWalletProvider) {
+                throw new Error('Contract wallet providers are only supported for embedded Midnight wallets');
+            }
+            return connector.getWalletProvider();
+        });
+    }
     /** Builds an unsigned transaction from one or more transfer specs (step 1). */
     createTransferTransaction(...args) {
         return this._connector.createTransferTransaction(...args);