@dynamic-labs/midnight 4.90.0 → 4.91.0

package/src/waas/connector/DynamicWaasMidnightConnector.js

@@ -0,0 +1,567 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { MFAAction, TokenScope } from '@dynamic-labs/sdk-api-core';
+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 { MidnightUiTransaction } from '../../utils/MidnightUiTransaction/MidnightUiTransaction.js';
+import { MidnightWallet } from '../../wallet/MidnightWallet.js';
+import { WaasMidnightWalletConnector } from '../WaasMidnightWalletConnector.js';
+import { buildMidnightWaasConnectedApi, normalizeDustBalance, toBigIntBalanceMap } from './buildMidnightWaasConnectedApi.js';
+
+/**
+ * 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) {
+        super('Dynamic Waas', props);
+        this.ChainWallet = MidnightWallet;
+        this.name = 'Dynamic Waas';
+        this.overrideKey = 'dynamicwaas';
+        this.isEmbeddedWallet = true;
+        this.logger = new Logger('DynamicWaasMidnightConnector');
+        this.walletUiUtils = props.walletUiUtils;
+    }
+    /**
+     * Signs a message with additional context information
+     * @param message - The message to sign (string or object with raw property)
+     * @param context - Additional context for the message signing
+     * @returns The signed message as a string
+     * @throws {Error} Method not implemented for Midnight
+     */
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    signMessageWithContext({ message, context, }) {
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Override setVerifiedCredentials to filter and set Midnight WaaS credentials
+     * Filters for credentials with walletName === 'dynamicwaas' and chain === 'midnight'
+     */
+    setVerifiedCredentials(verifiedCredentials) {
+        this.verifiedCredentials = verifiedCredentials.filter((vc) => vc.walletName === 'dynamicwaas' && vc.chain === 'midnight');
+    }
+    /**
+     * Override setEnvironmentId to ensure it's set on the logger
+     */
+    setEnvironmentId(environmentId) {
+        super.setEnvironmentId(environmentId);
+    }
+    /**
+     * Gets the wallet client for a specific account address and sets it as active
+     * @param accountAddress - The Midnight account address
+     * @returns The WaaS wallet client instance
+     */
+    getWalletClientByAddress(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ accountAddress, }) {
+            this.setActiveAccountAddress(accountAddress);
+            return this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Gets the currently active account address
+     * @returns The active account address or undefined if not set
+     */
+    getActiveAccountAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.activeAccountAddress;
+        });
+    }
+    /**
+     * Sets the active account address for this connector
+     * @param accountAddress - The Midnight account address to set as active
+     */
+    setActiveAccountAddress(accountAddress) {
+        this.activeAccountAddress = accountAddress;
+    }
+    /**
+     * Called when the user selects this wallet in the modal.
+     * Sets the active account so getAddress/getNetwork work correctly during network validation.
+     */
+    afterWalletSelectHook(walletAddress) {
+        this.setActiveAccountAddress(walletAddress);
+    }
+    /**
+     * Requires and returns the signed session ID
+     * @returns The signed session ID
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    requireSignedSessionId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const signedSessionId = yield ((_a = this.getSignedSessionId) === null || _a === void 0 ? void 0 : _a.call(this));
+            if (!signedSessionId) {
+                throw new DynamicError('Signed session ID is required');
+            }
+            return signedSessionId;
+        });
+    }
+    /**
+     * Validates that the expected wallet address matches the active wallet
+     * Updates the active account address if it doesn't match
+     * @param expectedAddress - The expected wallet address to validate
+     * @throws {DynamicError} If signed session ID is not available or account is not found
+     */
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const targetWallet = yield walletClient.getWallet({
+                accountAddress: expectedAddress,
+                authToken: (_a = this.getAuthToken) === null || _a === void 0 ? void 0 : _a.call(this),
+                signedSessionId,
+            });
+            if (!targetWallet) {
+                throw new DynamicError('Account not found');
+            }
+            const isWalletActive = isSameAddress(targetWallet.accountAddress, this.activeAccountAddress || '', this.connectedChain);
+            if (!isWalletActive) {
+                this.activeAccountAddress = targetWallet.accountAddress;
+            }
+        });
+    }
+    /**
+     * 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.
+     */
+    ensureActiveAccountFromVerifiedCredentials() {
+        var _a, _b;
+        if (this.activeAccountAddress)
+            return;
+        const address = (_b = (_a = this.verifiedCredentials) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.address;
+        if (typeof address === 'string') {
+            this.setActiveAccountAddress(address);
+        }
+    }
+    /**
+     * Gets the active wallet address
+     * Falls back to verified credential address if no active account is set
+     * @returns The wallet address or empty string if not found
+     */
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.ensureActiveAccountFromVerifiedCredentials();
+            return this.activeAccountAddress || '';
+        });
+    }
+    /**
+     * Connects to the WaaS wallet client
+     */
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getWaasWalletClient();
+        });
+    }
+    /**
+     * Disconnects from the wallet (no-op for WaaS)
+     */
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // WaaS doesn't require explicit disconnect
+        });
+    }
+    /**
+     * Signs a message using the wallet UI utils for user interaction
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     */
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.walletUiUtils.signMessage({
+                handler: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignMessage(message); }),
+                message,
+                walletConnector: this,
+            });
+        });
+    }
+    /**
+     * Internal method to sign a message with MFA token
+     * @param message - The message to sign
+     * @returns The signed message as a string
+     * @throws {DynamicError} If active account address is not set
+     * @throws {DynamicError} If signed session ID is not available
+     */
+    internalSignMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            const walletClient = yield this.getWaasWalletClient();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            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: this.activeAccountAddress,
+            });
+            const signedMessage = yield walletClient.signMessage({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_b = this.getAuthToken) === null || _b === void 0 ? void 0 : _b.call(this),
+                message,
+                mfaToken,
+                password,
+                signedSessionId,
+            });
+            return signedMessage;
+        });
+    }
+    /**
+     * Ends the current session and clears the active account address
+     */
+    endSession() {
+        const _super = Object.create(null, {
+            endSession: { get: () => super.endSession }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.endSession.call(this);
+            this.activeAccountAddress = undefined;
+        });
+    }
+    /**
+     * Signs and finalizes (ZK proves) a Midnight transaction via MPC.
+     * Step 2 of the 3-step flow: createTransferTransaction → signTransaction → submitTransaction.
+     *
+     * @param serializedTransaction - Base64-encoded unsigned UnprovenTransaction
+     * @returns Base64-encoded FinalizedTransaction, ready for submitTransaction
+     */
+    signTransaction(serializedTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            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: this.activeAccountAddress,
+            });
+            // Derive the chain name (e.g. "mainnet" / "preview") — not the numeric
+            // network ID — because `chainId` is typed as a string and resolved by
+            // name on the wallet-client side. Passing a stringified numeric id
+            // (`"1"`) reaches `getNetworkIdFromChainId`, which doesn't recognize it.
+            const selectedNetwork = this.getSelectedNetwork();
+            const isTestnet = (_c = (_b = selectedNetwork === null || selectedNetwork === void 0 ? void 0 : selectedNetwork.name) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('testnet')) !== null && _c !== void 0 ? _c : false;
+            const chainId = isTestnet ? 'preview' : 'mainnet';
+            // Sign the transaction using MPC
+            const signature = yield walletClient.signTransaction({
+                authToken: (_d = this.getAuthToken) === null || _d === void 0 ? void 0 : _d.call(this),
+                chainId,
+                mfaToken,
+                password,
+                senderAddress: this.activeAccountAddress,
+                signedSessionId,
+                transaction: serializedTransaction,
+            });
+            return signature;
+        });
+    }
+    /**
+     * Creates a UI transaction for the send balance flow
+     * @param from - The sender's address
+     * @returns A new IUITransaction instance
+     */
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(from);
+            return new MidnightUiTransaction({
+                // 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');
+                    }
+                    // 3-step Midnight transfer: build → sign (ZK prove) → submit.
+                    const { serializedTransaction } = yield this.createTransferTransaction({
+                        transfers: [
+                            {
+                                amount: tx.value.toString(),
+                                recipientAddress: tx.to,
+                                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);
+                    return txHash;
+                }),
+            });
+        });
+    }
+    /**
+     * Returns the provider.
+     * For WaaS, there is no traditional browser provider.
+     */
+    getProvider() {
+        return undefined;
+    }
+    /**
+     * Creates a new Midnight wallet account.
+     * Midnight wallets automatically create multiple address types:
+     * - Primary: unshielded address (for public transfers)
+     * - Additional: dust address (for gas/fee management) and shielded address (for private transfers)
+     *
+     * All address types are derived from a single keygen using different BIP-44 derivation paths.
+     *
+     * @param thresholdSignatureScheme - The threshold signature scheme (default: 'TWO_OF_TWO')
+     * @param password - Optional password for the wallet
+     * @returns The created wallet account information with primary (unshielded) address
+     */
+    createWalletAccount() {
+        const _super = Object.create(null, {
+            createWalletAccount: { get: () => super.createWalletAccount }
+        });
+        return __awaiter(this, arguments, void 0, function* ({ thresholdSignatureScheme = 'TWO_OF_TWO', password, } = {}) {
+            // Midnight automatically creates all address types (unshielded, dust, shielded)
+            // from a single keygen. The primary address is unshielded, additional addresses
+            // (dust and shielded) are returned as additionalAddresses from the server.
+            return _super.createWalletAccount.call(this, {
+                password,
+                thresholdSignatureScheme,
+            });
+        });
+    }
+    // Passes through the wallet client's shape. `dust` carries `{ balance, cap }`
+    // (wallet-SDK v4 — cap = summed dust maxCap). `dustSynced` is false while dust
+    // finishes syncing in the background (balance resolves on shielded+unshielded
+    // first). Matches the base `IDynamicWaasConnector` / `DynamicWaasMixin`.
+    getPrivateBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            const result = yield walletClient.getPrivateBalance({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                signedSessionId,
+            });
+            // Defensive: wallet-client builds that predate the dust decouple don't
+            // return `dustSynced` — treat those as already-synced (no loading state),
+            // preserving prior behavior until the client is republished.
+            return Object.assign(Object.assign({}, result), { dustSynced: (_d = result.dustSynced) !== null && _d !== void 0 ? _d : true });
+        });
+    }
+    /**
+     * Exposes the same `ConnectedAPI` surface injected Midnight wallets provide,
+     * adapted from WaaS MPC state. This is what lets the shared
+     * `MidnightWalletConnector` balance methods (`getShieldedBalances`,
+     * `getUnshieldedBalances`, `getDustBalance`) work for WaaS wallets — they all
+     * delegate to `getConnectedAPI()`, which throws (returns undefined) by
+     * default. Address lookups and transfers stay on the WaaS-specific paths.
+     */
+    getConnectedAPI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return buildMidnightWaasConnectedApi(() => this.getPrivateBalance());
+        });
+    }
+    /**
+     * Adapts the WaaS MPC `getPrivateBalance()` result to the shape
+     * `MidnightWallet.getFormattedBalances()` expects. The base
+     * `MidnightWalletConnector.getBalances()` throws unconditionally (it does not
+     * route through `getConnectedAPI`), so WaaS still overrides it directly —
+     * here in a single `getPrivateBalance()` call.
+     *
+     * Cap-tolerant: `dust.cap` is 0n on browser-wallet-client <= 1.0.16 and the
+     * real cap once the wallet-SDK-v4 change is published (no code change needed).
+     */
+    getBalances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { shielded, unshielded, dust, dustSynced } = yield this.getPrivateBalance();
+            return {
+                dust: normalizeDustBalance(dust),
+                // True while dust is still catching up (balance resolved on
+                // shielded+unshielded). Drives the "dust loading" UI; only WaaS sets it.
+                dustSyncing: !dustSynced,
+                shielded: toBigIntBalanceMap(shielded),
+                unshielded: toBigIntBalanceMap(unshielded),
+            };
+        });
+    }
+    registerDust() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            return walletClient.registerDust({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                signedSessionId,
+            });
+        });
+    }
+    /**
+     * Step 1 of the Midnight transfer flow.
+     * Builds an unsigned UnprovenTransaction from one or more transfer specs.
+     * Accepts any combination of unshielded / shielded transfers in a single tx.
+     * No MPC, no proof server, no broadcast.
+     */
+    createTransferTransaction(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            return walletClient.createTransferTransaction({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                signedSessionId,
+                transfers: params.transfers,
+                ttlMinutes: params.ttlMinutes,
+            });
+        });
+    }
+    /**
+     * Release UTXOs reserved by an abandoned draft or signed-but-never-submitted
+     * transaction. Accepts either an unsigned (Step 1 output) or finalized
+     * (Step 2 output) serialized transaction.
+     */
+    revertTransaction(serializedTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.callRevertTransaction({ transaction: serializedTransaction });
+        });
+    }
+    /**
+     * Revert every finalized-but-unsubmitted transaction the SDK knows about
+     * (`state.pending.all`). Does not cover unfinalized Step-1-only drafts —
+     * those are never registered with the pending-tx service by design. If
+     * UTXOs are still stuck after this, use `resetWalletCache()`.
+     */
+    revertAllPending() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.callRevertTransaction({ all: true });
+        });
+    }
+    /**
+     * Nuclear reset. Stops the cached wallet, clears its persisted IndexedDB
+     * entry, and forces the next operation to cold-sync from chain. Midnight's
+     * officially recommended workaround when UTXOs get stuck in pending state
+     * that can't be reverted through the normal API.
+     */
+    resetWalletCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.callRevertTransaction({ resetCache: true });
+        });
+    }
+    // Internal shared glue: resolves auth + forwards to the iframe handler.
+    callRevertTransaction(args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            return walletClient.revertTransaction({
+                accountAddress: this.activeAccountAddress,
+                all: args.all,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                elevatedAccessToken,
+                mfaToken,
+                resetCache: args.resetCache,
+                signedSessionId,
+                transaction: args.transaction,
+            });
+        });
+    }
+    /**
+     * Step 3 of the unshielded public transfer flow.
+     * Broadcasts a finalized transaction via the wallet's NodeClient.
+     * Optionally waits for the unshielded balance to stabilize.
+     */
+    submitTransaction(serializedFinalizedTransaction, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.ensureActiveAccountFromVerifiedCredentials();
+            if (!this.activeAccountAddress) {
+                throw new DynamicError('Active account address is required');
+            }
+            const walletClient = yield this.getWaasWalletClient();
+            const signedSessionId = yield this.requireSignedSessionId();
+            const mfaToken = yield ((_a = this.getMfaToken) === null || _a === void 0 ? void 0 : _a.call(this, {
+                mfaAction: MFAAction.WalletWaasSign,
+            }));
+            const elevatedAccessToken = yield ((_b = this.getElevatedAccessToken) === null || _b === void 0 ? void 0 : _b.call(this, {
+                scope: TokenScope.Walletsign,
+            }));
+            return walletClient.submitTransaction({
+                accountAddress: this.activeAccountAddress,
+                authToken: (_c = this.getAuthToken) === null || _c === void 0 ? void 0 : _c.call(this),
+                balanceBefore: options === null || options === void 0 ? void 0 : options.balanceBefore,
+                elevatedAccessToken,
+                mfaToken,
+                signedSessionId,
+                tokenType: options === null || options === void 0 ? void 0 : options.tokenType,
+                transaction: serializedFinalizedTransaction,
+                waitForBalance: options === null || options === void 0 ? void 0 : options.waitForBalance,
+            });
+        });
+    }
+}
+
+export { DynamicWaasMidnightConnector };

package/src/waas/connector/buildMidnightWaasConnectedApi.cjs

@@ -0,0 +1,48 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+const toBigIntBalanceMap = (record) => {
+    const out = {};
+    for (const [tokenType, value] of Object.entries(record)) {
+        out[tokenType] = BigInt(value);
+    }
+    return out;
+};
+// Normalizes the cap-tolerant `dust` field to `{ balance, cap }` bigints.
+// cap is 0n on clients that don't yet surface it.
+const normalizeDustBalance = (dust) => typeof dust === 'string'
+    ? { balance: BigInt(dust), cap: BigInt(0) }
+    : { balance: BigInt(dust.balance), cap: BigInt(dust.cap) };
+/**
+ * Builds a minimal `ConnectedAPI` adapter for WaaS Midnight wallets so the
+ * shared `MidnightWalletConnector` balance methods — which delegate to
+ * `getConnectedAPI()` — behave the same as they do for injected wallets.
+ *
+ * Only the balance dimensions are derivable from MPC state. Address lookups
+ * (which need coin/encryption public keys) and transfers use the
+ * WaaS-specific paths (server `additionalAddresses` and the 3-step
+ * createTransferTransaction → sign → submit flow), so they throw here.
+ */
+const buildMidnightWaasConnectedApi = (getPrivateBalance) => {
+    const unsupported = (method) => () => {
+        throw new Error(`${method} is not available on WaaS Midnight wallets; use the WaaS-specific flow`);
+    };
+    return {
+        getDustAddress: unsupported('getDustAddress'),
+        getDustBalance: () => _tslib.__awaiter(void 0, void 0, void 0, function* () { return normalizeDustBalance((yield getPrivateBalance()).dust); }),
+        getShieldedAddresses: unsupported('getShieldedAddresses'),
+        getShieldedBalances: () => _tslib.__awaiter(void 0, void 0, void 0, function* () { return toBigIntBalanceMap((yield getPrivateBalance()).shielded); }),
+        getUnshieldedAddress: unsupported('getUnshieldedAddress'),
+        getUnshieldedBalances: () => _tslib.__awaiter(void 0, void 0, void 0, function* () { return toBigIntBalanceMap((yield getPrivateBalance()).unshielded); }),
+        makeTransfer: unsupported('makeTransfer'),
+        submitTransaction: unsupported('submitTransaction'),
+    };
+};
+
+exports.buildMidnightWaasConnectedApi = buildMidnightWaasConnectedApi;
+exports.normalizeDustBalance = normalizeDustBalance;
+exports.toBigIntBalanceMap = toBigIntBalanceMap;

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

@@ -0,0 +1,26 @@
+import type { ConnectedAPI, TokenType } from '@midnight-ntwrk/dapp-connector-api';
+export type WaasPrivateBalance = {
+    unshielded: Record<string, string>;
+    shielded: Record<string, string>;
+    dust: string | {
+        balance: string;
+        cap: string;
+    };
+    address: string;
+};
+export declare const toBigIntBalanceMap: (record: Record<string, string>) => Record<TokenType, bigint>;
+export declare const normalizeDustBalance: (dust: WaasPrivateBalance['dust']) => {
+    balance: bigint;
+    cap: bigint;
+};
+/**
+ * Builds a minimal `ConnectedAPI` adapter for WaaS Midnight wallets so the
+ * shared `MidnightWalletConnector` balance methods — which delegate to
+ * `getConnectedAPI()` — behave the same as they do for injected wallets.
+ *
+ * Only the balance dimensions are derivable from MPC state. Address lookups
+ * (which need coin/encryption public keys) and transfers use the
+ * WaaS-specific paths (server `additionalAddresses` and the 3-step
+ * createTransferTransaction → sign → submit flow), so they throw here.
+ */
+export declare const buildMidnightWaasConnectedApi: (getPrivateBalance: () => Promise<WaasPrivateBalance>) => ConnectedAPI;