@claritydao/midnight-agora-sdk 0.1.0 → 1.2.0

package/dist/browser-providers.js

@@ -1,147 +1,665 @@
-import { concatMap, filter, firstValueFrom, interval, map, of, take, tap, throwError, timeout, catchError } from "rxjs";
-import { pipe as fnPipe } from "fp-ts/function";
-import { levelPrivateStateProvider } from "@midnight-ntwrk/midnight-js-level-private-state-provider";
-import { FetchZkConfigProvider } from "@midnight-ntwrk/midnight-js-fetch-zk-config-provider";
-import { httpClientProofProvider } from "@midnight-ntwrk/midnight-js-http-client-proof-provider";
-import { indexerPublicDataProvider } from "@midnight-ntwrk/midnight-js-indexer-public-data-provider";
-import semver from "semver";
-import { getNetworkId, setNetworkId } from "@midnight-ntwrk/midnight-js-network-id";
-// Helper functions for hex encoding/decoding
-const toHexString = (bytes) => Array.from(bytes)
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-const _fromHexString = (hex) => new Uint8Array(hex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
-/**
- * Initializes and returns the providers required for Governor contract interactions in a browser environment.
- *
- * @param logger The logger instance for logging.
- * @param networkId The network ID to connect to (e.g., 'testnet', 'mainnet').
- * @returns A promise that resolves to configured GovernorProviders.
- *
- * @remarks
- * This function connects to the Midnight Lace wallet extension and retrieves network configuration
- * from the wallet. The network ID is specified by the caller.
- */
-export const initializeProviders = async (logger, networkId = "testnet") => {
-    const { wallet, config } = await connectToWallet(logger, networkId);
-    const zkConfigPath = window.location.origin;
-    logger.info(`Connecting to wallet with network ID: ${getNetworkId()}`);
-    // Get wallet addresses
-    const addresses = await wallet.getShieldedAddresses();
+import { FetchZkConfigProvider } from '@midnight-ntwrk/midnight-js-fetch-zk-config-provider';
+import { httpClientProofProvider } from '@midnight-ntwrk/midnight-js-http-client-proof-provider';
+import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
+import { encodeCoinPublicKey, LedgerParameters, Transaction } from '@midnight-ntwrk/ledger-v8';
+import { setNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
+import { createProofProvider } from '@midnight-ntwrk/midnight-js-types';
+import { mainnet, MidnightBech32m, ShieldedAddress, ShieldedCoinPublicKey, ShieldedEncryptionPublicKey, UnshieldedAddress, } from '@midnight-ntwrk/wallet-sdk-address-format';
+const PRIVATE_STATE_STORAGE_KEY_PREFIX = 'midnight-private-state:';
+const SIGNING_KEY_STORAGE_KEY_PREFIX = 'midnight-signing-key:';
+const MIDNIGHT_HINT_METHODS = [
+    'getProvingProvider',
+    'balanceUnsealedTransaction',
+    'balanceSealedTransaction',
+    'submitTransaction',
+    'getConfiguration',
+    'getShieldedAddresses',
+    'getUnshieldedAddress',
+];
+function bytesToHex(bytes) {
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function hexToBytes(hex) {
+    const normalized = stripHexPrefix(hex);
+    if (normalized.length % 2 !== 0) {
+        throw new Error('Hex transaction payload has an odd number of characters');
+    }
+    const bytes = new Uint8Array(normalized.length / 2);
+    for (let index = 0; index < normalized.length; index += 2) {
+        bytes[index / 2] = Number.parseInt(normalized.slice(index, index + 2), 16);
+    }
+    return bytes;
+}
+function serializeTxToHex(tx) {
+    return bytesToHex(tx.serialize());
+}
+function deserializeFinalizedTransaction(txHex) {
+    return Transaction.deserialize('signature', 'proof', 'binding', hexToBytes(txHex));
+}
+function formatSyntheticCost(cost) {
     return {
-        privateStateProvider: levelPrivateStateProvider({
-            privateStateStoreName: "governor-private-state"
-        }),
-        zkConfigProvider: new FetchZkConfigProvider(zkConfigPath, fetch.bind(window)),
-        proofProvider: config.proverServerUri
-            ? httpClientProofProvider(config.proverServerUri)
-            : httpClientProofProvider(""), // Fallback - proving may be done by wallet
-        publicDataProvider: indexerPublicDataProvider(config.indexerUri, config.indexerWsUri),
-        walletProvider: createWalletProvider(wallet, addresses),
-        midnightProvider: {
-            async submitTx(tx) {
-                // Convert transaction to hex string for the connector API
-                const serialized = tx.serialize();
-                const hexString = toHexString(serialized);
-                await wallet.submitTransaction(hexString);
-                // Return the transaction hash as the ID
-                return tx.transactionHash();
+        readTime: cost.readTime.toString(),
+        computeTime: cost.computeTime.toString(),
+        blockUsage: cost.blockUsage.toString(),
+        bytesWritten: cost.bytesWritten.toString(),
+        bytesChurned: cost.bytesChurned.toString(),
+    };
+}
+function getTransactionCostDebug(tx) {
+    const ledgerParameters = LedgerParameters.initialParameters();
+    const cost = tx.cost(ledgerParameters);
+    try {
+        return {
+            parameterSource: 'LedgerParameters.initialParameters()',
+            cost: formatSyntheticCost(cost),
+            normalized: ledgerParameters.normalizeFullness(cost),
+            exceedsBlockLimits: false,
+        };
+    }
+    catch (error) {
+        return {
+            parameterSource: 'LedgerParameters.initialParameters()',
+            cost: formatSyntheticCost(cost),
+            exceedsBlockLimits: true,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function getSubmittedTransactionCostDebug(txHex) {
+    try {
+        return getTransactionCostDebug(deserializeFinalizedTransaction(txHex));
+    }
+    catch (error) {
+        return {
+            parameterSource: 'LedgerParameters.initialParameters()',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function getErrorDetails(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function getErrorDebug(error) {
+    if (!(error instanceof Error)) {
+        return error;
+    }
+    const enumerableFields = Object.fromEntries(Object.entries(error).map(([key, value]) => [
+        key,
+        value instanceof Error ? getErrorDebug(value) : value,
+    ]));
+    return {
+        name: error.name,
+        message: error.message,
+        cause: 'cause' in error ? getErrorDebug(error.cause) : undefined,
+        stack: error.stack,
+        ...enumerableFields,
+    };
+}
+function isTemporarilyBannedError(error) {
+    return getErrorDetails(error).toLowerCase().includes('temporarily banned');
+}
+function isUserRejectedError(error) {
+    const details = getErrorDetails(error).toLowerCase();
+    const debug = JSON.stringify(getErrorDebug(error)).toLowerCase();
+    return details.includes('user rejected') || details.includes('rejected transaction') || debug.includes('user rejected');
+}
+function stringifyBigIntRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, value.toString()]));
+}
+async function getWalletFundingDebug(wallet) {
+    const [dust, shieldedBalances, unshieldedBalances] = await Promise.allSettled([
+        wallet.getDustBalance(),
+        wallet.getShieldedBalances(),
+        wallet.getUnshieldedBalances(),
+    ]);
+    return {
+        dust: dust.status === 'fulfilled'
+            ? {
+                balance: dust.value.balance.toString(),
+                cap: dust.value.cap.toString(),
             }
+            : {
+                error: getErrorDetails(dust.reason),
+                errorDebug: getErrorDebug(dust.reason),
+            },
+        shieldedBalances: shieldedBalances.status === 'fulfilled'
+            ? stringifyBigIntRecord(shieldedBalances.value)
+            : {
+                error: getErrorDetails(shieldedBalances.reason),
+                errorDebug: getErrorDebug(shieldedBalances.reason),
+            },
+        unshieldedBalances: unshieldedBalances.status === 'fulfilled'
+            ? stringifyBigIntRecord(unshieldedBalances.value)
+            : {
+                error: getErrorDetails(unshieldedBalances.reason),
+                errorDebug: getErrorDebug(unshieldedBalances.reason),
+            },
+    };
+}
+function describeWalletFundingDebug(fundingDebug) {
+    const dust = 'balance' in fundingDebug.dust ? fundingDebug.dust : undefined;
+    if (!dust) {
+        return 'Wallet funding diagnostics could not read dust balance.';
+    }
+    return `Wallet dust balance: ${dust.balance} / cap ${dust.cap}.`;
+}
+async function withTimeout(promise, timeoutMs, message) {
+    let timeoutId;
+    const timeout = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    }
+}
+function encodeStoredValue(value) {
+    return JSON.stringify(value, (_key, currentValue) => {
+        if (typeof currentValue === 'bigint') {
+            return {
+                __type: 'bigint',
+                value: currentValue.toString(),
+            };
+        }
+        if (currentValue instanceof Uint8Array) {
+            return {
+                __type: 'Uint8Array',
+                value: Array.from(currentValue),
+            };
+        }
+        return currentValue;
+    });
+}
+function decodeStoredValue(value) {
+    if (!value) {
+        return null;
+    }
+    return JSON.parse(value, (_key, currentValue) => {
+        if (currentValue && typeof currentValue === 'object' && currentValue.__type === 'bigint') {
+            return BigInt(currentValue.value);
+        }
+        if (currentValue &&
+            typeof currentValue === 'object' &&
+            currentValue.__type === 'Uint8Array' &&
+            Array.isArray(currentValue.value)) {
+            return new Uint8Array(currentValue.value);
+        }
+        return currentValue;
+    });
+}
+function assertBrowserStorage() {
+    if (typeof localStorage === 'undefined') {
+        throw new Error('Governor browser providers require localStorage');
+    }
+    return localStorage;
+}
+function createLocalStoragePrivateStateProvider(accountId) {
+    let contractAddress = null;
+    const listStorageKeys = (prefix) => Object.keys(assertBrowserStorage()).filter((key) => key.startsWith(prefix));
+    const getScopedStorageKey = (prefix, key, includeContractAddress) => {
+        if (includeContractAddress && !contractAddress) {
+            throw new Error('Contract address not set. Call setContractAddress() before accessing private state.');
         }
+        const contractScope = includeContractAddress ? `${contractAddress}:` : '';
+        return `${prefix}${accountId}:${contractScope}${key}`;
     };
-};
-/**
- * Creates a WalletProvider from the connected wallet API.
- */
-const createWalletProvider = (wallet, addresses) => {
-    // Note: The bech32m addresses need to be converted to the expected key types
-    // This conversion may need adjustment based on the actual key format expected
-    const coinPublicKey = addresses.shieldedCoinPublicKey;
-    const encryptionPublicKey = addresses.shieldedEncryptionPublicKey;
     return {
-        getCoinPublicKey() {
-            return coinPublicKey;
-        },
-        getEncryptionPublicKey() {
-            return encryptionPublicKey;
-        },
-        async balanceTx(tx, _newCoins, _ttl) {
-            // Use the wallet's balancing capability
-            // Convert Uint8Array to hex string for the connector API
-            const serialized = tx.serialize();
-            const hexString = toHexString(serialized);
-            const _result = await wallet.balanceUnsealedTransaction(hexString);
-            // The wallet returns a balanced transaction as a hex string
-            // We need to convert it back and return as NothingToProve
-            // Note: The actual deserialization may need the Transaction.deserialize with proper markers
-            // For now, we return the original transaction as the wallet handles proving internally
+        setContractAddress(address) {
+            contractAddress = address;
+        },
+        async get(key) {
+            return decodeStoredValue(assertBrowserStorage().getItem(getScopedStorageKey(PRIVATE_STATE_STORAGE_KEY_PREFIX, key, true)));
+        },
+        async set(key, value) {
+            assertBrowserStorage().setItem(getScopedStorageKey(PRIVATE_STATE_STORAGE_KEY_PREFIX, key, true), encodeStoredValue(value));
+        },
+        async remove(key) {
+            assertBrowserStorage().removeItem(getScopedStorageKey(PRIVATE_STATE_STORAGE_KEY_PREFIX, key, true));
+        },
+        async clear() {
+            if (!contractAddress) {
+                throw new Error('Contract address not set. Call setContractAddress() before clearing private state.');
+            }
+            const privateStatePrefix = `${PRIVATE_STATE_STORAGE_KEY_PREFIX}${accountId}:${contractAddress}:`;
+            for (const key of listStorageKeys(privateStatePrefix)) {
+                assertBrowserStorage().removeItem(key);
+            }
+        },
+        async getSigningKey(address) {
+            return decodeStoredValue(assertBrowserStorage().getItem(getScopedStorageKey(SIGNING_KEY_STORAGE_KEY_PREFIX, address, false)));
+        },
+        async setSigningKey(address, key) {
+            assertBrowserStorage().setItem(getScopedStorageKey(SIGNING_KEY_STORAGE_KEY_PREFIX, address, false), encodeStoredValue(key));
+        },
+        async removeSigningKey(address) {
+            assertBrowserStorage().removeItem(getScopedStorageKey(SIGNING_KEY_STORAGE_KEY_PREFIX, address, false));
+        },
+        async clearSigningKeys() {
+            const signingKeyPrefix = `${SIGNING_KEY_STORAGE_KEY_PREFIX}${accountId}:`;
+            for (const key of listStorageKeys(signingKeyPrefix)) {
+                assertBrowserStorage().removeItem(key);
+            }
+        },
+        async exportPrivateStates() {
+            if (!contractAddress) {
+                throw new Error('Contract address not set. Call setContractAddress() before exporting private state.');
+            }
+            const privateStatePrefix = `${PRIVATE_STATE_STORAGE_KEY_PREFIX}${accountId}:${contractAddress}:`;
             return {
-                type: "NothingToProve",
-                transaction: tx // The wallet should have balanced this
+                version: 1,
+                entries: listStorageKeys(privateStatePrefix).map((key) => ({
+                    key,
+                    value: assertBrowserStorage().getItem(key),
+                })),
             };
-        }
+        },
+        async importPrivateStates(exportData) {
+            const entries = exportData &&
+                typeof exportData === 'object' &&
+                Array.isArray(exportData.entries)
+                ? exportData.entries
+                : [];
+            let imported = 0;
+            for (const entry of entries) {
+                if (!entry?.key || !entry.key.startsWith(PRIVATE_STATE_STORAGE_KEY_PREFIX)) {
+                    continue;
+                }
+                if (typeof entry.value === 'string') {
+                    assertBrowserStorage().setItem(entry.key, entry.value);
+                    imported += 1;
+                }
+            }
+            return {
+                imported,
+                skipped: entries.length - imported,
+                overwritten: 0,
+            };
+        },
+        async exportSigningKeys() {
+            const signingKeyPrefix = `${SIGNING_KEY_STORAGE_KEY_PREFIX}${accountId}:`;
+            return {
+                version: 1,
+                entries: listStorageKeys(signingKeyPrefix).map((key) => ({
+                    key,
+                    value: assertBrowserStorage().getItem(key),
+                })),
+            };
+        },
+        async importSigningKeys(exportData) {
+            const entries = exportData &&
+                typeof exportData === 'object' &&
+                Array.isArray(exportData.entries)
+                ? exportData.entries
+                : [];
+            let imported = 0;
+            for (const entry of entries) {
+                if (!entry?.key || !entry.key.startsWith(SIGNING_KEY_STORAGE_KEY_PREFIX)) {
+                    continue;
+                }
+                if (typeof entry.value === 'string') {
+                    assertBrowserStorage().setItem(entry.key, entry.value);
+                    imported += 1;
+                }
+            }
+            return {
+                imported,
+                skipped: entries.length - imported,
+                overwritten: 0,
+            };
+        },
     };
+}
+function getZkConfigBaseUrl(override, profile) {
+    if (typeof window === 'undefined') {
+        throw new Error('ZK config base URL requires a browser environment');
+    }
+    const root = override ? resolveBrowserUrl(override) : `${window.location.origin}/`;
+    return new URL(`${profile}/`, root.endsWith('/') ? root : `${root}/`).toString().replace(/\/$/, '');
+}
+function resolveBrowserUrl(url) {
+    if (typeof window === 'undefined') {
+        return url;
+    }
+    return new URL(url, window.location.origin).toString();
+}
+function normalizeGovernorArtifactUrl(input) {
+    if (typeof input !== 'string') {
+        return input;
+    }
+    const match = input.match(/^(.*\/(?:keys|zkir)\/)[^/#]+#([^?#]+)$/);
+    if (!match) {
+        return input;
+    }
+    const [, artifactBaseUrl, circuitFileName] = match;
+    return `${artifactBaseUrl}${circuitFileName}`;
+}
+const fetchGovernorArtifact = async (input, init) => {
+    const normalizedInput = normalizeGovernorArtifactUrl(input);
+    try {
+        const response = await fetch(normalizedInput, init);
+        if (!response.ok) {
+            console.warn('[ZK] Artifact fetch returned non-OK response', {
+                url: String(normalizedInput),
+                status: response.status,
+                statusText: response.statusText,
+            });
+        }
+        return response;
+    }
+    catch (error) {
+        console.error('[ZK] Artifact fetch failed', {
+            url: String(normalizedInput),
+            error: getErrorDetails(error),
+            errorDebug: getErrorDebug(error),
+        });
+        throw error;
+    }
 };
-/**
- * Connects to the Midnight Lace wallet extension.
- *
- * @param logger The logger instance for logging.
- * @param networkId The network ID to connect to.
- * @returns A promise that resolves to the wallet API and configuration.
- */
-const connectToWallet = (logger, networkId) => {
-    const COMPATIBLE_CONNECTOR_API_VERSION = "4.x";
-    return firstValueFrom(fnPipe(interval(100), map(() => {
-        // Find wallet in window.midnight
-        const midnight = window.midnight;
-        if (!midnight)
-            return undefined;
-        // The new API uses rdns keys instead of named keys like mnLace
-        // Look for any available wallet
-        const walletKeys = Object.keys(midnight).filter((key) => key !== "addEventListener");
-        if (walletKeys.length === 0)
-            return undefined;
-        return midnight[walletKeys[0]];
-    }), tap((connectorAPI) => {
-        logger.info(connectorAPI, "Check for wallet connector API");
-    }), filter((connectorAPI) => !!connectorAPI), concatMap((connectorAPI) => semver.satisfies(connectorAPI.apiVersion, COMPATIBLE_CONNECTOR_API_VERSION)
-        ? of(connectorAPI)
-        : throwError(() => {
-            logger.error({
-                expected: COMPATIBLE_CONNECTOR_API_VERSION,
-                actual: connectorAPI.apiVersion
-            }, "Incompatible version of wallet connector API");
-            return new Error(`Incompatible version of Midnight Lace wallet found. Require '${COMPATIBLE_CONNECTOR_API_VERSION}', got '${connectorAPI.apiVersion}'.`);
-        })), tap((connectorAPI) => {
-        logger.info(connectorAPI, "Compatible wallet connector API found. Connecting.");
-    }), take(1), timeout({
-        first: 1_000,
-        with: () => throwError(() => {
-            logger.error("Could not find wallet connector API");
-            return new Error("Could not find Midnight Lace wallet. Extension installed?");
-        })
-    }), concatMap(async (connectorAPI) => {
-        // Connect to the wallet with the specified network ID
-        const connectedAPI = await connectorAPI.connect(networkId);
-        // Set the network ID globally
-        setNetworkId(networkId);
-        logger.info("Connected to wallet");
-        return { walletConnectorAPI: connectedAPI, connectorAPI };
-    }), timeout({
-        first: 30_000, // Increased timeout for user approval
-        with: () => throwError(() => {
-            logger.error("Wallet connector API has failed to respond");
-            return new Error("Midnight Lace wallet has failed to respond. Extension enabled?");
-        })
-    }), catchError((error, apis) => error
-        ? throwError(() => {
-            logger.error("Unable to connect to wallet");
-            return new Error("Application is not authorized or connection failed");
-        })
-        : apis), concatMap(async ({ walletConnectorAPI }) => {
-        const config = await walletConnectorAPI.getConfiguration();
-        logger.info("Connected to wallet connector API and retrieved service configuration");
-        return { wallet: walletConnectorAPI, config };
-    })));
+function getBech32mNetworkId(value, networkId) {
+    if (networkId) {
+        return networkId;
+    }
+    const parsed = MidnightBech32m.parse(value);
+    return parsed.network === mainnet ? 'mainnet' : String(parsed.network);
+}
+function normalizeShieldedCoinPublicKey(value, networkId) {
+    if (!value.startsWith('mn_')) {
+        return value;
+    }
+    const parsed = MidnightBech32m.parse(value);
+    const resolvedNetworkId = getBech32mNetworkId(value, networkId);
+    if (parsed.type === 'shield-cpk') {
+        return ShieldedCoinPublicKey.codec.decode(resolvedNetworkId, parsed).toHexString();
+    }
+    if (parsed.type === 'shield-addr') {
+        return parsed.decode(ShieldedAddress, resolvedNetworkId).coinPublicKeyString();
+    }
+    throw new Error(`Expected shielded coin public key or shielded address, got ${parsed.type}`);
+}
+function normalizeShieldedEncryptionPublicKey(value, networkId) {
+    if (!value.startsWith('mn_')) {
+        return value;
+    }
+    const parsed = MidnightBech32m.parse(value);
+    const resolvedNetworkId = getBech32mNetworkId(value, networkId);
+    if (parsed.type === 'shield-epk') {
+        return ShieldedEncryptionPublicKey.codec.decode(resolvedNetworkId, parsed).toHexString();
+    }
+    if (parsed.type === 'shield-addr') {
+        return parsed.decode(ShieldedAddress, resolvedNetworkId).encryptionPublicKeyString();
+    }
+    throw new Error(`Expected shielded encryption public key or shielded address, got ${parsed.type}`);
+}
+export function parseMidnightRecipientAddress(value, networkId) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error('Recipient address is required');
+    }
+    if (trimmed.startsWith('mn_')) {
+        const parsed = MidnightBech32m.parse(trimmed);
+        const resolvedNetworkId = getBech32mNetworkId(trimmed, networkId);
+        if (parsed.type === 'shield-cpk' || parsed.type === 'shield-addr') {
+            const encoded = encodeCoinPublicKey(normalizeShieldedCoinPublicKey(trimmed, resolvedNetworkId));
+            if (encoded.length !== 32) {
+                throw new Error(`Midnight recipient public key must be 32 bytes, got ${encoded.length}`);
+            }
+            return encoded;
+        }
+        if (parsed.type === 'addr') {
+            return hexToBytes(parsed.decode(UnshieldedAddress, resolvedNetworkId).hexString);
+        }
+        throw new Error(`Expected shielded address, shielded coin public key, or unshielded address, got ${parsed.type}`);
+    }
+    const recipient = hexToBytes(trimmed);
+    if (recipient.length !== 32) {
+        throw new Error(`Recipient hex must encode exactly 32 bytes, got ${recipient.length}`);
+    }
+    return recipient;
+}
+async function getAccountId(wallet, override) {
+    if (override) {
+        return override;
+    }
+    const { unshieldedAddress } = await wallet.getUnshieldedAddress();
+    return unshieldedAddress;
+}
+async function balanceWithWallet(wallet, tx) {
+    const unsealedTx = serializeTxToHex(tx);
+    try {
+        console.log('[MIDNIGHT] Requesting wallet balance', { mode: 'unsealed', bytes: unsealedTx.length / 2 });
+        const result = await wallet.balanceUnsealedTransaction(unsealedTx);
+        console.log('[MIDNIGHT] Wallet balance succeeded', { mode: 'unsealed' });
+        return result;
+    }
+    catch (unsealedError) {
+        const fundingDebug = await getWalletFundingDebug(wallet);
+        console.error('[MIDNIGHT] Wallet balance failed', {
+            mode: 'unsealed',
+            error: getErrorDetails(unsealedError),
+            errorDebug: getErrorDebug(unsealedError),
+            funding: fundingDebug,
+        });
+        const walletError = getErrorDetails(unsealedError) || 'Wallet failed to balance unsealed transaction without returning an error message';
+        throw new Error(`${walletError}. ${describeWalletFundingDebug(fundingDebug)}`);
+    }
+}
+async function createGovernorProofProvider(wallet, config, zkConfigProvider, profile, proofServerUriOverride) {
+    const makeLoggedProvider = (source, provider, fallback) => ({
+        proveTx: async (unprovenTx, proveTxConfig) => {
+            console.log('[MIDNIGHT] Proving transaction', { profile, source });
+            try {
+                const provenTx = await provider.proveTx(unprovenTx, proveTxConfig);
+                console.log('[MIDNIGHT] Proved transaction', { profile, source });
+                return provenTx;
+            }
+            catch (error) {
+                console.error('[MIDNIGHT] Proof provider failed', {
+                    profile,
+                    source,
+                    error: getErrorDetails(error),
+                    errorDebug: getErrorDebug(error),
+                    fallback: fallback ? 'available' : 'none',
+                });
+                if (!fallback) {
+                    throw error;
+                }
+                console.warn('[MIDNIGHT] Retrying proof with fallback provider', { profile, from: source, to: 'http' });
+                return fallback.proveTx(unprovenTx, proveTxConfig);
+            }
+        },
+    });
+    if (proofServerUriOverride) {
+        return makeLoggedProvider('http-override', httpClientProofProvider(resolveBrowserUrl(proofServerUriOverride), zkConfigProvider));
+    }
+    const httpFallbackProvider = config.proverServerUri
+        ? httpClientProofProvider(resolveBrowserUrl(config.proverServerUri), zkConfigProvider)
+        : undefined;
+    try {
+        const walletProvingProvider = await wallet.getProvingProvider(zkConfigProvider.asKeyMaterialProvider());
+        return makeLoggedProvider('wallet', createProofProvider(walletProvingProvider), httpFallbackProvider);
+    }
+    catch (walletProofError) {
+        if (config.proverServerUri) {
+            return makeLoggedProvider('http-config', httpFallbackProvider);
+        }
+        throw new Error(`No proof provider available. Wallet getProvingProvider failed: ${getErrorDetails(walletProofError)}. Provide proofServerUri or configure a wallet proofstation.`);
+    }
+}
+function getInjectedInitialAPI(walletName) {
+    if (typeof window === 'undefined' || !window.midnight) {
+        throw new Error('Could not find Midnight wallet. Extension installed?');
+    }
+    const entries = Object.entries(window.midnight);
+    const normalizedWalletName = walletName?.toLowerCase();
+    const found = walletName
+        ? entries.find(([key, api]) => key.toLowerCase() === normalizedWalletName ||
+            api.name.toLowerCase() === normalizedWalletName ||
+            api.rdns.toLowerCase() === normalizedWalletName)?.[1] ??
+            window.midnight[walletName]
+        : entries[0]?.[1];
+    if (!found) {
+        throw new Error(walletName ? `Could not find Midnight wallet '${walletName}'` : 'Could not find Midnight wallet');
+    }
+    return found;
+}
+export async function connectMidnightWallet(initialAPI, networkId) {
+    const connectableInitialAPI = initialAPI;
+    console.log('[MIDNIGHT] Requesting wallet connection', {
+        walletName: initialAPI.name,
+        rdns: initialAPI.rdns,
+        apiVersion: initialAPI.apiVersion,
+        networkId,
+    });
+    const connectedAPI = await withTimeout(networkId ? connectableInitialAPI.connect(networkId) : connectableInitialAPI.connect(), 30_000, `Wallet '${initialAPI.name}' did not resolve connect(${networkId ? `'${networkId}'` : ''}) within 30 seconds. ` +
+        'Open the wallet extension, approve any pending site connection prompt, verify the wallet is on the requested network, then retry.');
+    if (!connectedAPI) {
+        throw new Error('Failed to connect to Midnight wallet');
+    }
+    console.log('[MIDNIGHT] Wallet connection resolved', {
+        walletName: initialAPI.name,
+        networkId,
+    });
+    if (typeof connectedAPI.hintUsage === 'function') {
+        try {
+            console.log('[MIDNIGHT] Sending wallet usage hints');
+            await connectedAPI.hintUsage(MIDNIGHT_HINT_METHODS);
+            console.log('[MIDNIGHT] Wallet usage hints resolved');
+        }
+        catch {
+            // Wallets may reject hints independently of the actual connection.
+            console.warn('[MIDNIGHT] Wallet usage hints were rejected or ignored');
+        }
+    }
+    return connectedAPI;
+}
+export async function encodeWalletUserId(walletOrCoinPublicKey, networkId) {
+    const coinPublicKey = typeof walletOrCoinPublicKey === 'string'
+        ? normalizeShieldedCoinPublicKey(walletOrCoinPublicKey, networkId)
+        : normalizeShieldedCoinPublicKey((await walletOrCoinPublicKey.getShieldedAddresses()).shieldedCoinPublicKey, (await walletOrCoinPublicKey.getConfiguration()).networkId);
+    const encoded = encodeCoinPublicKey(coinPublicKey);
+    if (encoded.length !== 32) {
+        throw new Error(`Midnight wallet public key must be 32 bytes, got ${encoded.length}`);
+    }
+    return encoded;
+}
+export async function initializeGovernorProviders(wallet, options = {}) {
+    const [config, shieldedAddresses, accountId] = await Promise.all([
+        wallet.getConfiguration(),
+        wallet.getShieldedAddresses(),
+        getAccountId(wallet, options.accountId),
+    ]);
+    setNetworkId(config.networkId);
+    const walletPublicKey = await encodeWalletUserId(shieldedAddresses.shieldedCoinPublicKey, config.networkId);
+    const baseZkConfigProvider = new FetchZkConfigProvider(getZkConfigBaseUrl(options.zkConfigBaseUrl, 'base'), fetchGovernorArtifact);
+    const fullZkConfigProvider = new FetchZkConfigProvider(getZkConfigBaseUrl(options.zkConfigBaseUrl, 'full'), fetchGovernorArtifact);
+    const [baseProofProvider, fullProofProvider] = await Promise.all([
+        createGovernorProofProvider(wallet, config, baseZkConfigProvider, 'base', options.proofServerUri),
+        createGovernorProofProvider(wallet, config, fullZkConfigProvider, 'full', options.proofServerUri),
+    ]);
+    const finalizedTxHexById = new Map();
+    const providers = {
+        privateStateProvider: createLocalStoragePrivateStateProvider(accountId),
+        zkConfigProvider: fullZkConfigProvider,
+        proofProvider: fullProofProvider,
+        publicDataProvider: indexerPublicDataProvider(config.indexerUri, config.indexerWsUri),
+        walletProvider: {
+            balanceTx: async (tx) => {
+                const result = await balanceWithWallet(wallet, tx);
+                if (!result.tx || typeof result.tx !== 'string') {
+                    throw new Error('Wallet returned an empty balanced transaction');
+                }
+                const finalizedTx = deserializeFinalizedTransaction(result.tx);
+                const txId = finalizedTx.identifiers()[0];
+                if (txId) {
+                    finalizedTxHexById.set(txId, stripHexPrefix(result.tx));
+                }
+                return finalizedTx;
+            },
+            getCoinPublicKey: () => shieldedAddresses.shieldedCoinPublicKey,
+            getEncryptionPublicKey: () => shieldedAddresses.shieldedEncryptionPublicKey,
+        },
+        midnightProvider: {
+            submitTx: async (tx) => {
+                const txId = tx.identifiers()[0];
+                if (!txId) {
+                    throw new Error('Unable to derive transaction identifier');
+                }
+                const txHex = finalizedTxHexById.get(txId) ?? serializeTxToHex(tx);
+                const submissionDetails = {
+                    txId,
+                    bytes: txHex.length / 2,
+                    source: finalizedTxHexById.has(txId) ? 'wallet-balanced' : 'serialized',
+                    ledgerCost: getSubmittedTransactionCostDebug(txHex),
+                };
+                console.log('[MIDNIGHT] Submitting transaction', submissionDetails);
+                try {
+                    await wallet.submitTransaction(txHex);
+                }
+                catch (error) {
+                    if (isTemporarilyBannedError(error)) {
+                        console.warn('[MIDNIGHT] Transaction is temporarily banned; watching for existing submission', {
+                            ...submissionDetails,
+                            error: getErrorDetails(error),
+                            errorDebug: getErrorDebug(error),
+                        });
+                        finalizedTxHexById.delete(txId);
+                        return txId;
+                    }
+                    console.error('[MIDNIGHT] Submit transaction failed', {
+                        ...submissionDetails,
+                        error: getErrorDetails(error),
+                        errorDebug: getErrorDebug(error),
+                    });
+                    throw error;
+                }
+                finalizedTxHexById.delete(txId);
+                return txId;
+            },
+        },
+        governorProfiles: {
+            base: {
+                zkConfigProvider: baseZkConfigProvider,
+                proofProvider: baseProofProvider,
+            },
+            full: {
+                zkConfigProvider: fullZkConfigProvider,
+                proofProvider: fullProofProvider,
+            },
+        },
+    };
+    if (options.contractAddress) {
+        providers.privateStateProvider.setContractAddress(options.contractAddress);
+    }
+    return {
+        providers,
+        config,
+        walletPublicKey,
+        accountId,
+    };
+}
+export const initializeProviders = async (logger, options = {}) => {
+    const initialAPI = options.initialAPI ?? getInjectedInitialAPI(options.walletName);
+    logger.info({ walletName: initialAPI.name, networkId: options.networkId }, options.networkId ? 'Connecting Midnight wallet with requested network' : 'Connecting Midnight wallet with configured network');
+    const wallet = await connectMidnightWallet(initialAPI, options.networkId);
+    logger.info({ walletName: initialAPI.name }, 'Connected Midnight wallet');
+    logger.info({ walletName: initialAPI.name }, 'Initializing governor providers');
+    const { providers } = await initializeGovernorProviders(wallet, options);
+    logger.info({ walletName: initialAPI.name }, 'Initialized governor providers');
+    return providers;
 };
+export function stripHexPrefix(value) {
+    return value.startsWith('0x') ? value.slice(2) : value;
+}
 //# sourceMappingURL=browser-providers.js.map