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/experimental/erc7821/utils/encodeCalls.ts

@@ -0,0 +1,38 @@
+import * as AbiParameters from 'ox/AbiParameters'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Call, Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+
+export type EncodeCallsErrorType =
+  | AbiParameters.encode.ErrorType
+  | AbiParameters.from.ErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeCalls(
+  calls_: Calls<readonly unknown[]>,
+  opData?: Hex | undefined,
+) {
+  const calls = calls_.map((call_) => {
+    const call = call_ as Call
+    return {
+      data: call.abi ? encodeFunctionData(call) : (call.data ?? '0x'),
+      value: call.value ?? 0n,
+      target: call.to,
+    }
+  })
+
+  return AbiParameters.encode(
+    AbiParameters.from([
+      'struct Call { address target; uint256 value; bytes data; }',
+      'Call[] calls',
+      ...(opData ? ['bytes opData'] : []),
+    ]),
+    [calls, ...(opData ? [opData] : [])] as any,
+  )
+}

node_modules/viem/experimental/erc7821/utils/encodeExecuteBatchesData.ts

@@ -0,0 +1,48 @@
+import type { Narrow } from 'abitype'
+import * as AbiParameters from 'ox/AbiParameters'
+import type { ErrorType } from '../../../errors/utils.js'
+
+import type { Batches } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import { abi, executionMode } from '../constants.js'
+import { type EncodeCallsErrorType, encodeCalls } from './encodeCalls.js'
+
+/** @internal */
+export type Batch = { calls: readonly unknown[]; opData?: Hex | undefined }
+
+export type EncodeExecuteBatchesDataParameters<
+  batches extends readonly Batch[] = readonly Batch[],
+> = {
+  /** Batches to execute. */
+  batches: Batches<Narrow<batches>, { opData?: Hex | undefined }>
+}
+
+export type EncodeExecuteBatchesDataReturnType = Hex
+
+export type EncodeExecuteBatchesDataErrorType =
+  | EncodeCallsErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeExecuteBatchesData<batches extends readonly Batch[]>(
+  parameters: EncodeExecuteBatchesDataParameters<batches>,
+): EncodeExecuteBatchesDataReturnType {
+  const { batches } = parameters
+
+  const encodedBatches = AbiParameters.encode(AbiParameters.from('bytes[]'), [
+    batches.map((b) => {
+      const batch = b as Batch
+      return encodeCalls(batch.calls, batch.opData)
+    }),
+  ])
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'execute',
+    args: [executionMode.batchOfBatches, encodedBatches],
+  })
+}

node_modules/viem/experimental/erc7821/utils/encodeExecuteData.ts

@@ -0,0 +1,42 @@
+import type { Narrow } from 'abitype'
+
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import {
+  type EncodeFunctionDataErrorType,
+  encodeFunctionData,
+} from '../../../utils/abi/encodeFunctionData.js'
+import { abi, executionMode } from '../constants.js'
+import { type EncodeCallsErrorType, encodeCalls } from './encodeCalls.js'
+
+export type EncodeExecuteDataParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Calls to execute. */
+  calls: Calls<Narrow<calls>>
+  /** Additional data to include for execution. */
+  opData?: Hex | undefined
+}
+
+export type EncodeExecuteDataReturnType = Hex
+
+export type EncodeExecuteDataErrorType =
+  | EncodeCallsErrorType
+  | EncodeFunctionDataErrorType
+  | ErrorType
+
+export function encodeExecuteData<const calls extends readonly unknown[]>(
+  parameters: EncodeExecuteDataParameters<calls>,
+): EncodeExecuteDataReturnType {
+  const { calls, opData } = parameters
+
+  const encodedCalls = encodeCalls(calls, opData)
+  const mode = opData ? executionMode.opData : executionMode.default
+
+  return encodeFunctionData({
+    abi,
+    functionName: 'execute',
+    args: [mode, encodedCalls],
+  })
+}

node_modules/viem/experimental/erc7821/utils/getExecuteError.ts

@@ -0,0 +1,67 @@
+import type { Abi, Narrow } from 'abitype'
+import * as AbiError from 'ox/AbiError'
+
+import type { BaseError } from '../../../errors/base.js'
+import type { Call, Calls } from '../../../types/calls.js'
+import type { Hex } from '../../../types/misc.js'
+import { decodeErrorResult } from '../../../utils/abi/decodeErrorResult.js'
+import {
+  type GetContractErrorReturnType,
+  getContractError,
+} from '../../../utils/errors/getContractError.js'
+import {
+  FunctionSelectorNotRecognizedError,
+  type FunctionSelectorNotRecognizedErrorType,
+} from '../errors.js'
+
+export type GetExecuteErrorParameters<
+  calls extends readonly unknown[] = readonly unknown[],
+> = {
+  /** Calls to execute. */
+  calls: Calls<Narrow<calls>>
+}
+
+export type GetExecuteErrorReturnType =
+  | FunctionSelectorNotRecognizedErrorType
+  | GetContractErrorReturnType
+
+export function getExecuteError<const calls extends readonly unknown[]>(
+  e: BaseError,
+  parameters: GetExecuteErrorParameters<calls>,
+): GetExecuteErrorReturnType {
+  const error = e.walk((e) => 'data' in (e as Error)) as
+    | (BaseError & { data?: Hex | undefined })
+    | undefined
+
+  if (!error?.data) return e as never
+  if (
+    error.data ===
+    AbiError.getSelector(AbiError.from('error FnSelectorNotRecognized()'))
+  )
+    return new FunctionSelectorNotRecognizedError() as never
+
+  let matched: Call | null = null
+  for (const c of parameters.calls) {
+    const call = c as Call
+    if (!call.abi) continue
+    try {
+      const matches = Boolean(
+        decodeErrorResult({
+          abi: call.abi,
+          data: error.data!,
+        }),
+      )
+      if (!matches) continue
+      matched = call
+    } catch {}
+  }
+  if (matched)
+    return getContractError(error as BaseError, {
+      abi: matched.abi as Abi,
+      address: matched.to,
+      args: matched.args,
+      functionName: matched.functionName,
+    })
+
+  return e as never
+}