@dynamic-labs/midnight 5.0.0 → 5.2.0

package/CHANGELOG.md

@@ -1,4 +1,32 @@
 
+## [5.2.0](https://github.com/dynamic-labs/dynamic-auth/compare/v5.1.0...v5.2.0) (2026-08-06)
+
+
+### Features
+
+* **webview-controller:** validate native SDK locale override before applying ([#12155](https://github.com/dynamic-labs/dynamic-auth/issues/12155)) ([4a9e1da](https://github.com/dynamic-labs/dynamic-auth/commit/4a9e1dafb59099c47d3678cc24f8475164c3db59))
+
+## [5.1.0](https://github.com/dynamic-labs/dynamic-auth/compare/v5.0.0...v5.1.0) (2026-08-04)
+
+
+### Features
+
+* **midnight:** expose contract wallet provider ([#12120](https://github.com/dynamic-labs/dynamic-auth/issues/12120)) ([2cecf23](https://github.com/dynamic-labs/dynamic-auth/commit/2cecf23f1f51819b99dfde4afd20264ea1abebf8))
+* **webview-messages,webview-controller:** add waas_backupKeySharesToICloud webview message ([#12147](https://github.com/dynamic-labs/dynamic-auth/issues/12147)) ([ca4edda](https://github.com/dynamic-labs/dynamic-auth/commit/ca4edda54adf0673a9fe41c17d861a739f1b8f2e))
+* **webview:** add business accounts message contract and controller ([#12144](https://github.com/dynamic-labs/dynamic-auth/issues/12144)) ([d9f80c1](https://github.com/dynamic-labs/dynamic-auth/commit/d9f80c10bb3c332c2f3e3dc401b95025b930fa4e))
+
+
+### Bug Fixes
+
+* bump brace-expansion to latest patched maintenance releases ([#12130](https://github.com/dynamic-labs/dynamic-auth/issues/12130)) ([1b26671](https://github.com/dynamic-labs/dynamic-auth/commit/1b26671ad8e62025904e04f9dfed8b3faafb9c19))
+* **ethereum-aa:** resolve chainId from network for ZeroDev v2 multichain projects ([#12105](https://github.com/dynamic-labs/dynamic-auth/issues/12105)) ([fe2c5d2](https://github.com/dynamic-labs/dynamic-auth/commit/fe2c5d239758ea79e8647006d9d77cc27c2ab647))
+* **midnight:** name the missing RPCs when the wallet client is too old ([#12121](https://github.com/dynamic-labs/dynamic-auth/issues/12121)) ([3a8a77f](https://github.com/dynamic-labs/dynamic-auth/commit/3a8a77f89d368d8634497a5b49ff345b004cdffa))
+* **midnight:** return the submission identifier from the contract provider ([#12122](https://github.com/dynamic-labs/dynamic-auth/issues/12122)) ([8aa5289](https://github.com/dynamic-labs/dynamic-auth/commit/8aa52895fbdf09a3cf481049009a95f03cddda54))
+* remediate high-severity dependency vulnerabilities ([#12149](https://github.com/dynamic-labs/dynamic-auth/issues/12149)) ([14058ee](https://github.com/dynamic-labs/dynamic-auth/commit/14058eeed34351791ad7ab7ac1fa720eb2cf9948))
+* **starknet:** restore Braavos L2 session after lock and unlock ([#12124](https://github.com/dynamic-labs/dynamic-auth/issues/12124)) ([ab3b11b](https://github.com/dynamic-labs/dynamic-auth/commit/ab3b11bd71fbca8d32d4f2badfa49e3b9641eecf))
+* **wallet-book:** add App Store id for Robinhood Wallet iOS install link ([#11877](https://github.com/dynamic-labs/dynamic-auth/issues/11877)) ([ef28619](https://github.com/dynamic-labs/dynamic-auth/commit/ef28619ba4396e01046717ea7ad560870a56c78f))
+* **wallet-book:** add universal deep link for Exodus Solana WalletConnect ([#12123](https://github.com/dynamic-labs/dynamic-auth/issues/12123)) ([cd7223e](https://github.com/dynamic-labs/dynamic-auth/commit/cd7223eb2dc21314f351b96d9a06d795d282c35d))
+
 ## [5.0.0](https://github.com/dynamic-labs/dynamic-auth/compare/v5.0.0-rc.4...v5.0.0) (2026-07-29)
 
 ## 🚀 Dynamic SDK v5 is live

package/package.cjs

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

package/package.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/midnight",
-  "version": "5.0.0",
+  "version": "5.2.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": "5.0.0",
+    "@dynamic-labs/assert-package-version": "5.2.0",
     "@dynamic-labs/sdk-api-core": "0.0.1093",
     "@midnight-ntwrk/dapp-connector-api": "4.0.1",
-    "@dynamic-labs/logger": "5.0.0",
-    "@dynamic-labs/types": "5.0.0",
-    "@dynamic-labs/utils": "5.0.0",
-    "@dynamic-labs/waas": "5.0.0",
-    "@dynamic-labs/wallet-book": "5.0.0",
-    "@dynamic-labs/wallet-connector-core": "5.0.0"
+    "@dynamic-labs/logger": "5.2.0",
+    "@dynamic-labs/types": "5.2.0",
+    "@dynamic-labs/utils": "5.2.0",
+    "@dynamic-labs/waas": "5.2.0",
+    "@dynamic-labs/wallet-book": "5.2.0",
+    "@dynamic-labs/wallet-connector-core": "5.2.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[]) => {
@@ -108,10 +108,7 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
         expectedAddresses: Record<string, string>;
         coinTypes?: Record<string, number> | undefined;
         password?: string | undefined;
-    }): Promise<Record<string, unknown>>; /**
-     * 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.
-     */
+    }): Promise<Record<string, unknown>>;
     exportPrivateKey({ accountAddress, displayContainer, password, }?: {
         accountAddress?: string | undefined;
         displayContainer?: HTMLIFrameElement | undefined;
@@ -122,6 +119,10 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
     };
     exportClientKeyshares({ accountAddress, password, }: {
         accountAddress: string;
+        /**
+         * 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.
+         */
         password?: string | undefined;
     }): Promise<void>;
     runBackupLifecycle({ provider, accountAddress, password, performBackup, }: {
@@ -158,9 +159,7 @@ declare const DynamicWaasMidnightConnector_base: (abstract new (...args: any[])
     hideICloudSignIn(): Promise<void>;
     isICloudAuthenticated(): Promise<boolean>;
     refreshWalletAccountShares({ accountAddress, password, }: {
-        accountAddress: string; /**
-         * Connects to the WaaS wallet client
-         */
+        accountAddress: string;
         password?: string | undefined;
     }): Promise<void>;
     reshareWalletAccountShares({ accountAddress, thresholdSignatureScheme, password, }: {
@@ -317,6 +316,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.
      *
@@ -378,6 +378,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);