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/tempo/internal/concurrent.ts

@@ -0,0 +1,24 @@
+const concurrentCounts = new Map<string, number>()
+
+/**
+ * Detects if there are concurrent tasks occuring for a given key
+ * within the same event loop tick. Registers the request, yields to allow
+ * other concurrent calls to register, then returns whether multiple requests
+ * were detected.
+ *
+ * @example
+ * ```ts
+ * const isConcurrent = await Concurrent.detect(address)
+ * ```
+ */
+export async function detect(key: string): Promise<boolean> {
+  concurrentCounts.set(key, (concurrentCounts.get(key) ?? 0) + 1)
+  await Promise.resolve()
+  const isConcurrent = (concurrentCounts.get(key) ?? 0) > 1
+  queueMicrotask(() => {
+    const count = concurrentCounts.get(key) ?? 0
+    if (count <= 1) concurrentCounts.delete(key)
+    else concurrentCounts.set(key, count - 1)
+  })
+  return isConcurrent
+}

node_modules/viem/tempo/internal/types.ts

@@ -0,0 +1,60 @@
+import type { Address } from 'abitype'
+import type { Account } from '../../accounts/types.js'
+import type { ReadContractParameters as viem_ReadContractParameters } from '../../actions/public/readContract.js'
+import type { WriteContractSyncParameters as viem_WriteContractSyncParameters } from '../../actions/wallet/writeContractSync.js'
+import type { Chain } from '../../types/chain.js'
+import type {
+  IsUndefined,
+  MaybeRequired,
+  UnionPick,
+} from '../../types/utils.js'
+import type { TransactionRequestTempo } from '../Transaction.js'
+
+export type GetAccountParameter<
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | Address | undefined = Account | Address,
+  required extends boolean = true,
+  nullish extends boolean = false,
+> = MaybeRequired<
+  {
+    account?:
+      | accountOverride
+      | Account
+      | Address
+      | (nullish extends true ? null : never)
+      | undefined
+  },
+  IsUndefined<account> extends true
+    ? required extends true
+      ? true
+      : false
+    : false
+>
+
+export type ReadParameters = Pick<
+  viem_ReadContractParameters<never, never, never>,
+  'account' | 'blockNumber' | 'blockOverrides' | 'blockTag' | 'stateOverride'
+>
+
+export type WriteParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = UnionPick<
+  viem_WriteContractSyncParameters<never, never, never, chain, account>,
+  | 'account'
+  | 'chain'
+  | 'gas'
+  | 'maxFeePerGas'
+  | 'maxPriorityFeePerGas'
+  | 'nonce'
+  | 'throwOnReceiptRevert'
+> &
+  UnionPick<
+    TransactionRequestTempo,
+    | 'keyAuthorization'
+    | 'feeToken'
+    | 'feePayer'
+    | 'nonceKey'
+    | 'validAfter'
+    | 'validBefore'
+  >

node_modules/viem/tempo/internal/utils.ts

@@ -0,0 +1,57 @@
+import type { Abi, AbiStateMutability, Address } from 'abitype'
+import type {
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ExtractAbiItem,
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { encodeFunctionData } from '../../utils/index.js'
+
+export function defineCall<
+  const abi extends Abi,
+  const functionName extends ContractFunctionName<abi, AbiStateMutability>,
+  call extends ContractFunctionParameters<
+    abi,
+    AbiStateMutability,
+    functionName
+  >,
+>(
+  call:
+    | call
+    | ContractFunctionParameters<abi, AbiStateMutability, functionName>,
+): ContractFunctionParameters<
+  [ExtractAbiItem<abi, functionName>],
+  AbiStateMutability,
+  functionName
+> & {
+  data: Hex
+  to: Address
+} {
+  return {
+    ...(call as any),
+    data: encodeFunctionData(call as never),
+    to: call.address,
+  } as const
+}
+
+/**
+ * Normalizes a value into a structured-clone compatible format.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
+ * @internal
+ */
+export function normalizeValue<type>(value: type): type {
+  if (Array.isArray(value)) return value.map(normalizeValue) as never
+  if (typeof value === 'function') return undefined as never
+  if (typeof value !== 'object' || value === null) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    try {
+      return structuredClone(value)
+    } catch {
+      return undefined as never
+    }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
+  return normalized as never
+}