FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/viem/utils/chain/assertCurrentChain.ts

@@ -0,0 +1,27 @@
+import {
+  ChainMismatchError,
+  type ChainMismatchErrorType,
+  ChainNotFoundError,
+  type ChainNotFoundErrorType,
+} from '../../errors/chain.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+
+export type AssertCurrentChainParameters = {
+  chain?: Chain | undefined
+  currentChainId: number
+}
+
+export type AssertCurrentChainErrorType =
+  | ChainNotFoundErrorType
+  | ChainMismatchErrorType
+  | ErrorType
+
+export function assertCurrentChain({
+  chain,
+  currentChainId,
+}: AssertCurrentChainParameters): void {
+  if (!chain) throw new ChainNotFoundError()
+  if (currentChainId !== chain.id)
+    throw new ChainMismatchError({ chain, currentChainId })
+}

node_modules/viem/utils/chain/defineChain.ts

@@ -0,0 +1,44 @@
+import type { Chain, ChainFormatters } from '../../types/chain.js'
+import type { Assign, Prettify } from '../../types/utils.js'
+
+export type DefineChainReturnType<chain extends Chain = Chain> = Prettify<
+  chain &
+    (chain['extendSchema'] extends Record<string, unknown>
+      ? {
+          extend: <const extended extends chain['extendSchema']>(
+            extended: extended,
+          ) => Assign<chain, extended>
+        }
+      : {})
+>
+
+export function defineChain<
+  formatters extends ChainFormatters,
+  const chain extends Chain<formatters>,
+>(chain: chain): DefineChainReturnType<Assign<Chain<undefined>, chain>> {
+  const chainInstance = {
+    formatters: undefined,
+    fees: undefined,
+    serializers: undefined,
+    ...chain,
+  } as Assign<Chain<undefined>, chain>
+
+  function extend(base: typeof chainInstance) {
+    type ExtendFn = (base: typeof chainInstance) => unknown
+    return (fnOrExtended: ExtendFn | Record<string, unknown>) => {
+      const properties = (
+        typeof fnOrExtended === 'function' ? fnOrExtended(base) : fnOrExtended
+      ) as (typeof chainInstance)['extendSchema']
+      const combined = { ...base, ...properties }
+      return Object.assign(combined, { extend: extend(combined) })
+    }
+  }
+
+  return Object.assign(chainInstance, {
+    extend: extend(chainInstance),
+  }) as never
+}
+
+export function extendSchema<schema extends Record<string, unknown>>(): schema {
+  return {} as schema
+}

node_modules/viem/utils/chain/extractChain.ts

@@ -0,0 +1,33 @@
+import type { ErrorType } from '../../errors/utils.js'
+import type { Chain } from '../../types/chain.js'
+
+export type ExtractChainParameters<
+  chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+> = {
+  chains: chains
+  id: chainId | chains[number]['id']
+}
+
+export type ExtractChainReturnType<
+  chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+> = Extract<chains[number], { id: chainId }>
+
+export type ExtractChainErrorType = ErrorType
+
+export function extractChain<
+  const chains extends readonly Chain[],
+  chainId extends chains[number]['id'],
+>({
+  chains,
+  id,
+}: ExtractChainParameters<chains, chainId>): ExtractChainReturnType<
+  chains,
+  chainId
+> {
+  return chains.find((chain) => chain.id === id) as ExtractChainReturnType<
+    chains,
+    chainId
+  >
+}

node_modules/viem/utils/chain/getChainContractAddress.ts

@@ -0,0 +1,41 @@
+import {
+  ChainDoesNotSupportContract,
+  type ChainDoesNotSupportContractErrorType,
+} from '../../errors/chain.js'
+import type { Chain, ChainContract } from '../../types/chain.js'
+
+export type GetChainContractAddressErrorType =
+  ChainDoesNotSupportContractErrorType
+
+export function getChainContractAddress({
+  blockNumber,
+  chain,
+  contract: name,
+}: {
+  blockNumber?: bigint | undefined
+  chain: Chain
+  contract: string
+}) {
+  const contract = (chain?.contracts as Record<string, ChainContract>)?.[name]
+  if (!contract)
+    throw new ChainDoesNotSupportContract({
+      chain,
+      contract: { name },
+    })
+
+  if (
+    blockNumber &&
+    contract.blockCreated &&
+    contract.blockCreated > blockNumber
+  )
+    throw new ChainDoesNotSupportContract({
+      blockNumber,
+      chain,
+      contract: {
+        name,
+        blockCreated: contract.blockCreated,
+      },
+    })
+
+  return contract.address
+}