# Shared Browser Session + Providers Canonical provider wiring for 1AM wallet browser dApps. Copy into `lib/midnight.ts`. See also [gotchas.md](gotchas.md) and [versions.json](versions.json). ## `lib/midnight.ts` ```typescript import { setNetworkId } from '@midnight-ntwrk/midnight-js-network-id'; import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider'; import { FetchZkConfigProvider } from '@midnight-ntwrk/midnight-js-fetch-zk-config-provider'; import { ContractState } from '@midnight-ntwrk/compact-runtime'; import type { MidnightProvider, WalletProvider } from '@midnight-ntwrk/midnight-js-types'; export type ConnectedSession = { api: any; config: any; providers: { privateStateProvider: ReturnType; publicDataProvider: ReturnType; zkConfigProvider: FetchZkConfigProvider; proofProvider: { proveTx: (unprovenTx: any) => Promise }; walletProvider: WalletProvider; midnightProvider: MidnightProvider; }; unshieldedAddress: string; coinPublicKeyBytes: Uint8Array; }; export function fromHex(hex: string): Uint8Array { const h = hex.startsWith('0x') ? hex.slice(2) : hex; return Uint8Array.from(h.match(/.{1,2}/g)!.map((b) => parseInt(b, 16))); } export function toHex(bytes: Uint8Array): string { return Array.from(bytes) .map((b) => b.toString(16).padStart(2, '0')) .join(''); } function coinPublicKeyToBytes(pk: unknown): Uint8Array { if (pk instanceof Uint8Array) return pk.length === 32 ? pk : pk.slice(0, 32); if (typeof pk === 'string') { const hex = pk.startsWith('0x') ? pk.slice(2) : pk; if (hex.length === 64 && /^[0-9a-fA-F]+$/.test(hex)) return fromHex(hex); return new Uint8Array(32); } if (Array.isArray(pk)) { return new Uint8Array(pk.length >= 32 ? pk.slice(0, 32) : [...pk, ...new Uint8Array(32 - pk.length)]); } if (pk && typeof pk === 'object' && 'bytes' in (pk as object)) { return coinPublicKeyToBytes((pk as { bytes: unknown }).bytes); } return new Uint8Array(32); } function createPrivateStateProvider() { let scope = ''; const stateStore = new Map(); const signingKeyStore = new Map(); const key = (id: string) => `${scope}:${id}`; return { setContractAddress(address: string) { scope = address; }, async set(id: string, state: unknown) { stateStore.set(key(id), state); }, async get(id: string) { return stateStore.get(key(id)) ?? null; }, async remove(id: string) { stateStore.delete(key(id)); }, async clear() { stateStore.clear(); }, async setSigningKey(addr: string, k: unknown) { signingKeyStore.set(addr, k); }, async getSigningKey(addr: string) { return signingKeyStore.get(addr) ?? null; }, async removeSigningKey(addr: string) { signingKeyStore.delete(addr); }, async clearSigningKeys() { signingKeyStore.clear(); }, async exportPrivateStates(): Promise { throw new Error('Not implemented.'); }, async importPrivateStates(): Promise { throw new Error('Not implemented.'); }, async exportSigningKeys(): Promise { throw new Error('Not implemented.'); }, async importSigningKeys(): Promise { throw new Error('Not implemented.'); }, }; } function createPatchedPublicDataProvider(queryUrl: string, subscriptionUrl: string) { const base = indexerPublicDataProvider(queryUrl, subscriptionUrl); return { ...base, async queryContractState(contractAddress: string, config?: unknown) { if (config) return base.queryContractState(contractAddress, config as never); const res = await fetch(queryUrl, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ query: `query LATEST_CONTRACT_STATE($address: HexEncoded!) { contractAction(address: $address) { state } }`, variables: { address: contractAddress }, }), }); if (!res.ok) throw new Error(`Indexer HTTP error: ${res.status}`); const payload = await res.json(); if (payload.errors?.length) { throw new Error(payload.errors.map((e: { message: string }) => e.message).join('; ')); } const action = payload.data?.contractAction ?? null; return action ? ContractState.deserialize(fromHex(action.state)) : null; }, }; } export async function createConnectedSession( api: any, zkAssetBasePath: string, ): Promise { const [config, unshieldedAddress, shieldedAddress] = await Promise.all([ api.getConfiguration(), api.getUnshieldedAddress(), api.getShieldedAddresses(), ]); setNetworkId(config.networkId); const zkConfigProvider = new FetchZkConfigProvider( new URL(zkAssetBasePath, window.location.origin).toString(), window.fetch.bind(window), ); const provingProvider = await api.getProvingProvider(zkConfigProvider); const proofProvider = { async proveTx(unprovenTx: any) { const { CostModel } = await import('@midnight-ntwrk/ledger-v8'); return unprovenTx.prove(provingProvider, CostModel.initialCostModel()); }, }; const walletProvider: WalletProvider = { getCoinPublicKey: () => shieldedAddress.shieldedCoinPublicKey, getEncryptionPublicKey: () => shieldedAddress.shieldedEncryptionPublicKey, balanceTx: async (tx: any) => { const txHex = toHex(tx.serialize()); const balanced = await api.balanceUnsealedTransaction(txHex); if (!balanced?.tx) throw new Error('balanceUnsealedTransaction returned invalid result'); const { Transaction } = await import('@midnight-ntwrk/ledger-v8'); return Transaction.deserialize('signature', 'proof', 'binding', fromHex(balanced.tx)); }, }; const midnightProvider: MidnightProvider = { submitTx: async (tx: any) => { const txHex = toHex(tx.serialize()); const result = await api.submitTransaction(txHex); if (typeof result === 'string' && result) return result; if (result?.transactionId) return result.transactionId; if (result?.id) return result.id; return txHex.slice(0, 64); }, }; return { api, config, providers: { privateStateProvider: createPrivateStateProvider(), publicDataProvider: createPatchedPublicDataProvider(config.indexerUri, config.indexerWsUri), zkConfigProvider, proofProvider, walletProvider, midnightProvider, }, unshieldedAddress: unshieldedAddress.unshieldedAddress, coinPublicKeyBytes: coinPublicKeyToBytes(shieldedAddress.shieldedCoinPublicKey), }; } export async function pollForState( queryUrl: string, contractAddress: string, maxAttempts = 120, intervalMs = 2000, ): Promise { for (let i = 0; i < maxAttempts; i++) { const res = await fetch(queryUrl, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ query: `query LATEST_CONTRACT_STATE($address: HexEncoded!) { contractAction(address: $address) { state } }`, variables: { address: contractAddress }, }), }); if (res.ok) { const payload = await res.json(); const state = payload.data?.contractAction?.state; if (state) return state; } await new Promise((r) => setTimeout(r, intervalMs)); } throw new Error(`Contract state not indexed after ${(maxAttempts * intervalMs) / 1000}s`); } ``` ## Wallet detection ```typescript export async function detectWallet(): Promise { const w = (window as any).midnight?.['1am'] ?? Object.values((window as any).midnight ?? {})[0]; if (!w) throw new Error('No Midnight wallet extension found'); return w; } ```