@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/ethereum.ts

@@ -0,0 +1,590 @@
+import {
+  JsonRpcProvider,
+  Interface,
+  ParamType,
+  Result,
+  Wallet,
+  getBytes,
+  getAddress,
+  isAddress,
+  keccak256,
+  type JsonFragment,
+  type TransactionRequest,
+  type TypedDataDomain,
+  type TypedDataField,
+} from 'ethers'
+
+import { decryptKey, encryptKey } from './storage'
+
+export type EvmNetworkId = 'ethereum' | 'arbitrum' | 'base'
+
+export interface EvmNetworkConfig {
+  id: EvmNetworkId
+  label: string
+  chainId: number
+  rpcUrl: string
+  addressExplorerBaseUrl: string
+  transactionExplorerBaseUrl: string
+}
+
+export interface EthereumExecutionOptions {
+  network?: EvmNetworkId | string | null
+  rpcUrl?: string | null
+}
+
+export interface EthereumMessageInput {
+  message?: string | null
+  messageHex?: string | null
+  messageBase64?: string | null
+}
+
+function serializeEvmValue(value: unknown): unknown {
+  if (typeof value === 'bigint') return value.toString()
+  if (Array.isArray(value)) return value.map((entry) => serializeEvmValue(entry))
+  if (value instanceof Uint8Array) return `0x${Buffer.from(value).toString('hex')}`
+  if (value && typeof value === 'object') {
+    if (value instanceof Result) {
+      return Array.from(value).map((entry) => serializeEvmValue(entry))
+    }
+    const out: Record<string, unknown> = {}
+    for (const [key, entry] of Object.entries(value)) {
+      if (/^\d+$/.test(key)) continue
+      out[key] = serializeEvmValue(entry)
+    }
+    return out
+  }
+  return value
+}
+
+const DEFAULT_RPC_URL = process.env.ETHEREUM_RPC_URL || process.env.EVM_RPC_URL || 'https://ethereum-rpc.publicnode.com'
+const DEFAULT_EVM_RPC_TIMEOUT_MS = (() => {
+  const parsed = Number.parseInt(process.env.EVM_RPC_TIMEOUT_MS || '20000', 10)
+  if (!Number.isFinite(parsed) || parsed <= 0) return 20_000
+  return parsed
+})()
+
+const EVM_NETWORKS: Record<EvmNetworkId, EvmNetworkConfig> = {
+  ethereum: {
+    id: 'ethereum',
+    label: 'Ethereum',
+    chainId: 1,
+    rpcUrl: process.env.ETHEREUM_RPC_URL || process.env.EVM_RPC_URL || 'https://ethereum-rpc.publicnode.com',
+    addressExplorerBaseUrl: 'https://etherscan.io/address/',
+    transactionExplorerBaseUrl: 'https://etherscan.io/tx/',
+  },
+  arbitrum: {
+    id: 'arbitrum',
+    label: 'Arbitrum',
+    chainId: 42161,
+    rpcUrl: process.env.ARBITRUM_RPC_URL || 'https://arbitrum-one-rpc.publicnode.com',
+    addressExplorerBaseUrl: 'https://arbiscan.io/address/',
+    transactionExplorerBaseUrl: 'https://arbiscan.io/tx/',
+  },
+  base: {
+    id: 'base',
+    label: 'Base',
+    chainId: 8453,
+    rpcUrl: process.env.BASE_RPC_URL || 'https://base-rpc.publicnode.com',
+    addressExplorerBaseUrl: 'https://basescan.org/address/',
+    transactionExplorerBaseUrl: 'https://basescan.org/tx/',
+  },
+}
+
+function normalizeHexData(value: string, fieldName: string): string {
+  const trimmed = value.trim()
+  if (!/^0x[0-9a-fA-F]*$/.test(trimmed)) {
+    throw new Error(`${fieldName} must be a 0x-prefixed hex string`)
+  }
+  return trimmed
+}
+
+function parseBigIntField(value: unknown, fieldName: string): bigint | undefined {
+  if (value === undefined || value === null || value === '') return undefined
+  if (typeof value === 'bigint') return value
+  if (typeof value === 'number' && Number.isFinite(value)) return BigInt(Math.trunc(value))
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (!trimmed) return undefined
+    if (/^\d+$/.test(trimmed)) return BigInt(trimmed)
+    if (/^0x[0-9a-fA-F]+$/.test(trimmed)) return BigInt(trimmed)
+  }
+  throw new Error(`${fieldName} must be an integer or hex quantity`)
+}
+
+function parseNumberField(value: unknown, fieldName: string): number | undefined {
+  if (value === undefined || value === null || value === '') return undefined
+  if (typeof value === 'number' && Number.isFinite(value)) return Math.trunc(value)
+  if (typeof value === 'bigint') return Number(value)
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    if (!trimmed) return undefined
+    if (/^\d+$/.test(trimmed)) return Number.parseInt(trimmed, 10)
+    if (/^0x[0-9a-fA-F]+$/.test(trimmed)) return Number(BigInt(trimmed))
+  }
+  throw new Error(`${fieldName} must be an integer`)
+}
+
+function normalizeAddressInput(value: string, fieldName: string): string {
+  const trimmed = value.trim()
+  if (!/^0x[0-9a-fA-F]{40}$/.test(trimmed)) {
+    throw new Error(`${fieldName} must be a 20-byte hex address`)
+  }
+  return getAddress(trimmed.toLowerCase())
+}
+
+function normalizeAbiArgument(param: ParamType, value: unknown, fieldName: string): unknown {
+  if (param.baseType === 'address') {
+    if (typeof value !== 'string') throw new Error(`${fieldName} must be an address string`)
+    return normalizeAddressInput(value, fieldName)
+  }
+  if (param.baseType === 'array') {
+    if (!Array.isArray(value)) throw new Error(`${fieldName} must be an array`)
+    return value.map((entry, index) => normalizeAbiArgument(param.arrayChildren!, entry, `${fieldName}[${index}]`))
+  }
+  if (param.baseType === 'tuple') {
+    const components = param.components ?? []
+    if (Array.isArray(value)) {
+      return components.map((component, index) => normalizeAbiArgument(component, value[index], `${fieldName}[${index}]`))
+    }
+    if (!value || typeof value !== 'object') throw new Error(`${fieldName} must be an object or array for tuple input`)
+    return components.map((component, index) => {
+      const record = value as Record<string, unknown>
+      const componentValue = component.name && component.name in record
+        ? record[component.name]
+        : record[String(index)]
+      return normalizeAbiArgument(component, componentValue, `${fieldName}.${component.name || index}`)
+    })
+  }
+  return value
+}
+
+function normalizeFunctionArgs(
+  fragment: NonNullable<ReturnType<Interface['getFunction']>>,
+  args: unknown[] | Record<string, unknown>,
+  functionName: string,
+): unknown[] {
+  const source = Array.isArray(args) ? args : args && typeof args === 'object' ? args : []
+  if (!Array.isArray(source) && fragment.inputs.length === 1 && fragment.inputs[0].baseType === 'tuple') {
+    const tupleInput = fragment.inputs[0]
+    const hasNamedWrapper = tupleInput.name && tupleInput.name in source
+    const hasIndexWrapper = '0' in source
+    if (!hasNamedWrapper && !hasIndexWrapper) {
+      return [normalizeAbiArgument(tupleInput, source, `${functionName}.args[${tupleInput.name || 0}]`)]
+    }
+  }
+  return fragment.inputs.map((input, index) => {
+    const rawValue = Array.isArray(source)
+      ? source[index]
+      : input.name && input.name in source
+        ? source[input.name]
+        : source[String(index)]
+    return normalizeAbiArgument(input, rawValue, `${functionName}.args[${input.name || index}]`)
+  })
+}
+
+function normalizeMessageInput(input: EthereumMessageInput): string | Uint8Array {
+  if (typeof input.messageHex === 'string' && input.messageHex.trim()) {
+    return getBytes(normalizeHexData(input.messageHex, 'messageHex'))
+  }
+  if (typeof input.messageBase64 === 'string' && input.messageBase64.trim()) {
+    return Uint8Array.from(Buffer.from(input.messageBase64.trim(), 'base64'))
+  }
+  if (typeof input.message === 'string') return input.message
+  throw new Error('message, messageHex, or messageBase64 is required')
+}
+
+function normalizeTypedDataDomain(domain: Record<string, unknown>): TypedDataDomain {
+  const normalized: TypedDataDomain = { ...domain }
+  if (domain.chainId !== undefined) {
+    normalized.chainId = parseBigIntField(domain.chainId, 'typed data domain.chainId')
+  }
+  return normalized
+}
+
+function normalizeTypedDataTypes(types: Record<string, unknown>): Record<string, TypedDataField[]> {
+  const out: Record<string, TypedDataField[]> = {}
+  for (const [key, value] of Object.entries(types)) {
+    if (key === 'EIP712Domain') continue
+    if (!Array.isArray(value)) throw new Error(`typed data types.${key} must be an array`)
+    out[key] = value.map((entry) => {
+      if (!entry || typeof entry !== 'object') throw new Error(`typed data types.${key} entries must be objects`)
+      const field = entry as Record<string, unknown>
+      if (typeof field.name !== 'string' || typeof field.type !== 'string') {
+        throw new Error(`typed data types.${key} entries require name and type`)
+      }
+      return { name: field.name, type: field.type }
+    })
+  }
+  return out
+}
+
+function normalizeAbiInput(abi: unknown): ReadonlyArray<string | JsonFragment> {
+  if (Array.isArray(abi)) return abi as ReadonlyArray<string | JsonFragment>
+  if (typeof abi === 'string') {
+    const trimmed = abi.trim()
+    if (!trimmed) throw new Error('abi is required')
+    if (trimmed.startsWith('[')) {
+      const parsed = JSON.parse(trimmed)
+      if (!Array.isArray(parsed)) throw new Error('abi JSON must be an array')
+      return parsed as ReadonlyArray<string | JsonFragment>
+    }
+    return [trimmed]
+  }
+  throw new Error('abi must be an array or JSON string')
+}
+
+function normalizeTransactionRequest(tx: Record<string, unknown>): TransactionRequest {
+  const normalized: TransactionRequest = {}
+  if (tx.to !== undefined && tx.to !== null && tx.to !== '') normalized.to = normalizeAddressInput(String(tx.to), 'transaction.to')
+  if (tx.data !== undefined && tx.data !== null && tx.data !== '') normalized.data = normalizeHexData(String(tx.data), 'transaction.data')
+  if (tx.value !== undefined) normalized.value = parseBigIntField(tx.value, 'transaction.value')
+  if (tx.nonce !== undefined) normalized.nonce = parseNumberField(tx.nonce, 'transaction.nonce')
+  if (tx.chainId !== undefined) normalized.chainId = parseNumberField(tx.chainId, 'transaction.chainId')
+  if (tx.type !== undefined) normalized.type = parseNumberField(tx.type, 'transaction.type')
+  if (tx.gasLimit !== undefined) normalized.gasLimit = parseBigIntField(tx.gasLimit, 'transaction.gasLimit')
+  if (tx.gasPrice !== undefined) normalized.gasPrice = parseBigIntField(tx.gasPrice, 'transaction.gasPrice')
+  if (tx.maxFeePerGas !== undefined) normalized.maxFeePerGas = parseBigIntField(tx.maxFeePerGas, 'transaction.maxFeePerGas')
+  if (tx.maxPriorityFeePerGas !== undefined) normalized.maxPriorityFeePerGas = parseBigIntField(tx.maxPriorityFeePerGas, 'transaction.maxPriorityFeePerGas')
+  if (tx.accessList !== undefined) normalized.accessList = tx.accessList as TransactionRequest['accessList']
+  return normalized
+}
+
+async function withEthereumRpcTimeout<T>(promise: Promise<T>, label: string, timeoutMs = DEFAULT_EVM_RPC_TIMEOUT_MS): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
+      }),
+    ])
+  } finally {
+    if (timer) clearTimeout(timer)
+  }
+}
+
+async function resolveWalletAndTransaction(
+  encryptedPrivateKey: string,
+  tx: Record<string, unknown>,
+  options?: EthereumExecutionOptions,
+): Promise<{ provider: JsonRpcProvider; wallet: Wallet; txRequest: TransactionRequest; network: EvmNetworkConfig }> {
+  const network = getEvmNetworkConfig(options?.network)
+  const provider = getProviderForNetwork(options?.network, options?.rpcUrl)
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey).connect(provider)
+  const fromAddress = typeof tx.from === 'string' ? tx.from.trim() : ''
+  if (fromAddress && fromAddress.toLowerCase() !== wallet.address.toLowerCase()) {
+    throw new Error(`transaction.from does not match wallet address ${wallet.address}`)
+  }
+  const txRequest = normalizeTransactionRequest(tx)
+  if (txRequest.chainId == null) txRequest.chainId = network.chainId
+  const populated = await withEthereumRpcTimeout(
+    wallet.populateTransaction(txRequest),
+    `populate transaction on ${network.label}`,
+  )
+  return { provider, wallet, txRequest: populated, network }
+}
+
+export function generateEthereumWallet(): { publicKey: string; encryptedPrivateKey: string } {
+  const wallet = Wallet.createRandom()
+  return {
+    publicKey: wallet.address,
+    encryptedPrivateKey: encryptKey(wallet.privateKey),
+  }
+}
+
+export function getWalletFromEncrypted(encryptedPrivateKey: string): Wallet {
+  return new Wallet(decryptKey(encryptedPrivateKey))
+}
+
+export function normalizeEvmNetwork(value: unknown, fallback: EvmNetworkId = 'ethereum'): EvmNetworkId {
+  const normalized = String(value ?? '').trim().toLowerCase()
+  if (!normalized) return fallback
+  if (normalized === 'ethereum' || normalized === 'eth' || normalized === 'mainnet') return 'ethereum'
+  if (normalized === 'arbitrum' || normalized === 'arb' || normalized === 'arbitrum-one') return 'arbitrum'
+  if (normalized === 'base') return 'base'
+  throw new Error(`Unsupported EVM network: ${String(value)}`)
+}
+
+export function getEvmNetworkConfig(value?: unknown): EvmNetworkConfig {
+  return EVM_NETWORKS[normalizeEvmNetwork(value)]
+}
+
+export function listEvmNetworkConfigs(): EvmNetworkConfig[] {
+  return Object.values(EVM_NETWORKS)
+}
+
+export function getEvmExplorerUrl(network: EvmNetworkId | string | null | undefined, kind: 'address' | 'transaction', value: string): string {
+  const config = getEvmNetworkConfig(network)
+  return `${kind === 'address' ? config.addressExplorerBaseUrl : config.transactionExplorerBaseUrl}${value}`
+}
+
+export function getProvider(rpcUrl?: string): JsonRpcProvider {
+  return new JsonRpcProvider(rpcUrl || DEFAULT_RPC_URL)
+}
+
+export function getProviderForNetwork(network?: EvmNetworkId | string | null, rpcUrl?: string | null): JsonRpcProvider {
+  return new JsonRpcProvider(rpcUrl || getEvmNetworkConfig(network).rpcUrl)
+}
+
+export async function getBalance(address: string, rpcUrl?: string): Promise<bigint> {
+  return withEthereumRpcTimeout(getProvider(rpcUrl).getBalance(address), 'get balance')
+}
+
+export async function sendEth(
+  encryptedPrivateKey: string,
+  toAddress: string,
+  amountWei: string,
+  rpcUrl?: string,
+): Promise<{ signature: string; fee?: string }> {
+  const provider = getProvider(rpcUrl)
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey).connect(provider)
+  const tx = await withEthereumRpcTimeout(wallet.sendTransaction({
+    to: toAddress,
+    value: BigInt(amountWei),
+  }), 'send ETH transaction')
+  const receipt = await withEthereumRpcTimeout(tx.wait(), 'wait for ETH transaction receipt')
+  return {
+    signature: tx.hash,
+    fee: receipt?.fee ? receipt.fee.toString() : undefined,
+  }
+}
+
+export function encodeEthereumContractCall(
+  abi: unknown,
+  functionName: string,
+  args: unknown[] | Record<string, unknown> = [],
+): { data: string; fragment: string } {
+  const iface = new Interface(normalizeAbiInput(abi))
+  const fragment = iface.getFunction(functionName)
+  if (!fragment) throw new Error(`Function not found in ABI: ${functionName}`)
+  const normalizedArgs = normalizeFunctionArgs(fragment, args, functionName)
+  return {
+    data: iface.encodeFunctionData(fragment, normalizedArgs),
+    fragment: fragment.format('full'),
+  }
+}
+
+export async function callEthereumContract(
+  encryptedPrivateKey: string,
+  input: {
+    contractAddress: string
+    abi: unknown
+    functionName: string
+    args?: unknown[] | Record<string, unknown>
+  },
+  options?: EthereumExecutionOptions,
+): Promise<{
+    network: EvmNetworkConfig
+    address: string
+    fragment: string
+    data: string
+    rawResult: string
+    decoded: unknown
+    namedOutputs: Record<string, unknown>
+  }> {
+  const network = getEvmNetworkConfig(options?.network)
+  const provider = getProviderForNetwork(options?.network, options?.rpcUrl)
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey)
+  const iface = new Interface(normalizeAbiInput(input.abi))
+  const fragment = iface.getFunction(input.functionName)
+  if (!fragment) throw new Error(`Function not found in ABI: ${input.functionName}`)
+  const normalizedArgs = normalizeFunctionArgs(fragment, input.args || [], input.functionName)
+  const data = iface.encodeFunctionData(fragment, normalizedArgs)
+  const rawResult = await withEthereumRpcTimeout(provider.call({
+    to: normalizeAddressInput(input.contractAddress, 'contractAddress'),
+    data,
+    from: wallet.address,
+  }), `call contract ${input.functionName} on ${network.label}`)
+  const decodedResult = iface.decodeFunctionResult(fragment, rawResult)
+  const decodedValues = Array.from(decodedResult).map((entry) => serializeEvmValue(entry))
+  const namedOutputs: Record<string, unknown> = {}
+  for (let index = 0; index < fragment.outputs?.length; index += 1) {
+    const output = fragment.outputs[index]
+    if (!output?.name) continue
+    namedOutputs[output.name] = serializeEvmValue(decodedResult[index])
+  }
+
+  return {
+    network,
+    address: wallet.address,
+    fragment: fragment.format('full'),
+    data,
+    rawResult,
+    decoded: decodedValues.length === 1 ? decodedValues[0] : decodedValues,
+    namedOutputs,
+  }
+}
+
+export async function signEthereumMessage(
+  encryptedPrivateKey: string,
+  input: EthereumMessageInput,
+): Promise<{ signature: string; address: string }> {
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey)
+  return {
+    signature: await wallet.signMessage(normalizeMessageInput(input)),
+    address: wallet.address,
+  }
+}
+
+export async function signEthereumTypedData(
+  encryptedPrivateKey: string,
+  input: {
+    domain: Record<string, unknown>
+    types: Record<string, unknown>
+    value: Record<string, unknown>
+  },
+): Promise<{ signature: string; address: string }> {
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey)
+  return {
+    signature: await wallet.signTypedData(
+      normalizeTypedDataDomain(input.domain),
+      normalizeTypedDataTypes(input.types),
+      input.value,
+    ),
+    address: wallet.address,
+  }
+}
+
+export async function signEthereumTransaction(
+  encryptedPrivateKey: string,
+  tx: Record<string, unknown>,
+  options?: EthereumExecutionOptions,
+): Promise<{
+    signedTransaction: string
+    transactionHash: string
+    address: string
+    chainId: number | null
+    network: EvmNetworkConfig
+  }> {
+  const { wallet, txRequest, network } = await resolveWalletAndTransaction(encryptedPrivateKey, tx, options)
+  const signedTransaction = await wallet.signTransaction(txRequest)
+  return {
+    signedTransaction,
+    transactionHash: keccak256(signedTransaction),
+    address: wallet.address,
+    chainId: txRequest.chainId != null ? Number(txRequest.chainId) : null,
+    network,
+  }
+}
+
+export async function simulateEthereumTransaction(
+  encryptedPrivateKey: string,
+  tx: Record<string, unknown>,
+  options?: EthereumExecutionOptions,
+): Promise<{
+    estimateGas?: string
+    callResult?: string
+    callError?: string
+    address: string
+    chainId: number | null
+    network: EvmNetworkConfig
+  }> {
+  const { provider, wallet, txRequest, network } = await resolveWalletAndTransaction(encryptedPrivateKey, tx, options)
+  let estimateGas: string | undefined
+  let callResult: string | undefined
+  let callError: string | undefined
+
+  try {
+    estimateGas = (await withEthereumRpcTimeout(
+      provider.estimateGas({ ...txRequest, from: wallet.address }),
+      `estimate gas on ${network.label}`,
+    )).toString()
+  } catch (err: unknown) {
+    callError = err instanceof Error ? err.message : String(err)
+  }
+
+  try {
+    callResult = await withEthereumRpcTimeout(
+      provider.call({ ...txRequest, from: wallet.address }),
+      `simulate transaction call on ${network.label}`,
+    )
+  } catch (err: unknown) {
+    if (!callError) callError = err instanceof Error ? err.message : String(err)
+  }
+
+  return {
+    estimateGas,
+    callResult,
+    callError,
+    address: wallet.address,
+    chainId: txRequest.chainId != null ? Number(txRequest.chainId) : null,
+    network,
+  }
+}
+
+export async function sendEthereumTransaction(
+  encryptedPrivateKey: string,
+  input: {
+    transaction?: Record<string, unknown>
+    signedTransaction?: string | null
+    waitForReceipt?: boolean
+  },
+  options?: EthereumExecutionOptions,
+): Promise<{
+    transactionHash: string
+    address: string
+    chainId: number | null
+    explorerUrl: string
+    receipt?: Record<string, unknown> | null
+    network: EvmNetworkConfig
+  }> {
+  const waitForReceipt = input.waitForReceipt === true
+  const network = getEvmNetworkConfig(options?.network)
+  const provider = getProviderForNetwork(options?.network, options?.rpcUrl)
+  const wallet = getWalletFromEncrypted(encryptedPrivateKey).connect(provider)
+
+  if (typeof input.signedTransaction === 'string' && input.signedTransaction.trim()) {
+    const response = await withEthereumRpcTimeout(
+      provider.broadcastTransaction(input.signedTransaction.trim()),
+      `broadcast signed transaction on ${network.label}`,
+    )
+    const receipt = waitForReceipt
+      ? await withEthereumRpcTimeout(response.wait(), `wait for transaction receipt on ${network.label}`)
+      : null
+    return {
+      transactionHash: response.hash,
+      address: wallet.address,
+      chainId: network.chainId,
+      explorerUrl: getEvmExplorerUrl(network.id, 'transaction', response.hash),
+      receipt: receipt ? {
+        blockHash: receipt.blockHash,
+        blockNumber: receipt.blockNumber,
+        gasUsed: receipt.gasUsed?.toString?.(),
+        fee: receipt.fee?.toString?.(),
+        status: receipt.status,
+      } : null,
+      network,
+    }
+  }
+
+  if (!input.transaction || typeof input.transaction !== 'object') {
+    throw new Error('transaction or signedTransaction is required')
+  }
+
+  const { txRequest } = await resolveWalletAndTransaction(encryptedPrivateKey, input.transaction, options)
+  const response = await withEthereumRpcTimeout(
+    wallet.sendTransaction(txRequest),
+    `send transaction on ${network.label}`,
+  )
+  const receipt = waitForReceipt
+    ? await withEthereumRpcTimeout(response.wait(), `wait for transaction receipt on ${network.label}`)
+    : null
+  return {
+    transactionHash: response.hash,
+    address: wallet.address,
+    chainId: txRequest.chainId != null ? Number(txRequest.chainId) : network.chainId,
+    explorerUrl: getEvmExplorerUrl(network.id, 'transaction', response.hash),
+    receipt: receipt ? {
+      blockHash: receipt.blockHash,
+      blockNumber: receipt.blockNumber,
+      gasUsed: receipt.gasUsed?.toString?.(),
+      fee: receipt.fee?.toString?.(),
+      status: receipt.status,
+    } : null,
+    network,
+  }
+}
+
+export function isValidEthereumAddress(address: string): boolean {
+  return isAddress(address)
+}