viem 0.0.0-w-20230828183856 → 0.0.0-w-20230904174840

package/src/actions/public/watchContractEvent.ts

@@ -3,7 +3,10 @@ import type { Abi, AbiEvent, Address, ExtractAbiEvent } from 'abitype'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
-import type { GetEventArgs, InferEventName } from '../../types/contract.js'
+import type {
+  ContractEventArgs,
+  ContractEventName,
+} from '../../types/contract.js'
 import type { Filter } from '../../types/filter.js'
 import type { Log } from '../../types/log.js'
 import type { GetTransportConfig } from '../../types/transport.js'
@@ -37,74 +40,75 @@ import { getFilterChanges } from './getFilterChanges.js'
 import { getLogs } from './getLogs.js'
 import { uninstallFilter } from './uninstallFilter.js'
 
-type PollOptions = {
-  /**
-   * Whether or not the transaction hashes should be batched on each invocation.
-   * @default true
-   */
-  batch?: boolean
-  /**
-   * Polling frequency (in ms). Defaults to Client's pollingInterval config.
-   * @default client.pollingInterval
-   */
-  pollingInterval?: number
-}
-
 export type WatchContractEventOnLogsParameter<
-  TAbi extends Abi | readonly unknown[] = readonly unknown[],
-  TEventName extends string = string,
-  TStrict extends boolean | undefined = undefined,
-> = TAbi extends Abi
-  ? Log<bigint, number, false, ExtractAbiEvent<TAbi, TEventName>, TStrict>[]
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> = ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+> = abi extends Abi
+  ? Abi extends abi
+    ? Log[]
+    : Log<bigint, number, false, ExtractAbiEvent<abi, eventName>, strict>[]
   : Log[]
+
 export type WatchContractEventOnLogsFn<
-  TAbi extends Abi | readonly unknown[] = readonly unknown[],
-  TEventName extends string = string,
-  TStrict extends boolean | undefined = undefined,
-> = (logs: WatchContractEventOnLogsParameter<TAbi, TEventName, TStrict>) => void
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> = ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
+> = (logs: WatchContractEventOnLogsParameter<abi, eventName, strict>) => void
 
 export type WatchContractEventParameters<
-  TAbi extends Abi | readonly unknown[] = readonly unknown[],
-  TEventName extends string = string,
-  TStrict extends boolean | undefined = undefined,
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> = ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
 > = {
   /** The address of the contract. */
-  address?: Address | Address[]
+  address?: Address | Address[] | undefined
   /** Contract ABI. */
-  abi: TAbi
-  args?: GetEventArgs<TAbi, TEventName>
+  abi: abi
+  args?: ContractEventArgs<abi, eventName> | undefined
   /** Contract event. */
-  eventName?: InferEventName<TAbi, TEventName>
+  eventName?: eventName | ContractEventName<abi> | undefined
   /** The callback to call when an error occurred when trying to get for a new block. */
-  onError?: (error: Error) => void
+  onError?: ((error: Error) => void) | undefined
   /** The callback to call when new event logs are received. */
-  onLogs: WatchContractEventOnLogsFn<TAbi, TEventName, TStrict>
+  onLogs: WatchContractEventOnLogsFn<abi, eventName, strict>
   /**
    * Whether or not the logs must match the indexed/non-indexed arguments on `event`.
    * @default false
    */
-  strict?: TStrict
+  strict?: strict | undefined
 } & (GetTransportConfig<Transport>['type'] extends 'webSocket'
   ?
       | {
-          batch?: never
+          batch?: undefined
           /**
            * Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`.
            * @default false
            */
-          poll?: false
-          pollingInterval?: never
+          poll?: false | undefined
+          pollingInterval?: undefined
         }
       | (PollOptions & {
           /**
            * Whether or not the WebSocket Transport should poll the JSON-RPC, rather than using `eth_subscribe`.
            * @default true
            */
-          poll?: true
+          poll?: true | undefined
         })
-  : PollOptions & {
-      poll?: true
-    })
+  : PollOptions & { poll?: true | undefined })
+
+type PollOptions = {
+  /**
+   * Whether or not the transaction hashes should be batched on each invocation.
+   * @default true
+   */
+  batch?: boolean | undefined
+  /**
+   * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+   * @default client.pollingInterval
+   */
+  pollingInterval?: number | undefined
+}
 
 export type WatchContractEventReturnType = () => void
 
@@ -139,13 +143,15 @@ export type WatchContractEventReturnType = () => void
  * })
  */
 export function watchContractEvent<
-  TChain extends Chain | undefined,
-  const TAbi extends Abi | readonly unknown[],
-  TEventName extends string,
-  TStrict extends boolean | undefined = undefined,
+  chain extends Chain | undefined,
+  const abi extends Abi | readonly unknown[],
+  eventName extends ContractEventName<abi>,
+  strict extends boolean | undefined = undefined,
 >(
-  client: Client<Transport, TChain>,
-  {
+  client: Client<Transport, chain>,
+  parameters: WatchContractEventParameters<abi, eventName, strict>,
+): WatchContractEventReturnType {
+  const {
     abi,
     address,
     args,
@@ -156,8 +162,8 @@ export function watchContractEvent<
     poll: poll_,
     pollingInterval = client.pollingInterval,
     strict: strict_,
-  }: WatchContractEventParameters<TAbi, TEventName, TStrict>,
-): WatchContractEventReturnType {
+  } = parameters
+
   const enablePolling =
     typeof poll_ !== 'undefined' ? poll_ : client.transport.type !== 'webSocket'
 
@@ -175,7 +181,7 @@ export function watchContractEvent<
 
     return observe(observerId, { onLogs, onError }, (emit) => {
       let previousBlockNumber: bigint
-      let filter: Filter<'event', TAbi, TEventName> | undefined
+      let filter: Filter<'event', abi, eventName> | undefined
       let initialized = false
 
       const unwatch = poll(
@@ -190,8 +196,8 @@ export function watchContractEvent<
                 strict,
               } as unknown as CreateContractEventFilterParameters)) as Filter<
                 'event',
-                TAbi,
-                TEventName
+                abi,
+                eventName
               >
             } catch {}
             initialized = true
@@ -215,7 +221,7 @@ export function watchContractEvent<
               if (previousBlockNumber && previousBlockNumber !== blockNumber) {
                 logs = await getLogs(client, {
                   address,
-                  args,
+                  args: args as any,
                   fromBlock: previousBlockNumber + 1n,
                   toBlock: blockNumber,
                   event: getAbiItem({

package/src/actions/public/watchEvent.ts

@@ -1,4 +1,4 @@
-import type { Abi, AbiEvent, Address } from 'abitype'
+import type { AbiEvent, Address } from 'abitype'
 
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
@@ -312,15 +312,12 @@ export function watchEvent<
             const log = data.result
             try {
               const { eventName, args } = decodeEventLog({
-                abi: events_ as Abi,
+                abi: events_ ?? [],
                 data: log.data,
-                topics: log.topics as any,
+                topics: log.topics,
                 strict,
               })
-              const formatted = formatLog(log, {
-                args,
-                eventName: eventName as string,
-              })
+              const formatted = formatLog(log, { args, eventName })
               onLogs([formatted] as any)
             } catch (err) {
               let eventName

package/src/actions/wallet/deployContract.ts

@@ -5,9 +5,9 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import type { Chain } from '../../types/chain.js'
 import type { GetChain } from '../../types/chain.js'
-import type { GetConstructorArgs } from '../../types/contract.js'
+import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
-import type { UnionOmit } from '../../types/utils.js'
+import type { UnionEvaluate, UnionOmit } from '../../types/utils.js'
 import { encodeDeployData } from '../../utils/abi/encodeDeployData.js'
 
 import {
@@ -17,18 +17,25 @@ import {
 } from './sendTransaction.js'
 
 export type DeployContractParameters<
-  TAbi extends Abi | readonly unknown[] = Abi,
-  TChain extends Chain | undefined = Chain | undefined,
-  TAccount extends Account | undefined = Account | undefined,
-  TChainOverride extends Chain | undefined = Chain | undefined,
+  abi extends Abi | readonly unknown[] = Abi,
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  ///
+  allArgs = ContractConstructorArgs<abi>,
 > = UnionOmit<
-  SendTransactionParameters<TChain, TAccount, TChainOverride>,
+  SendTransactionParameters<chain, account, chainOverride>,
   'accessList' | 'chain' | 'to' | 'data'
-> & {
-  abi: TAbi
-  bytecode: Hex
-} & GetChain<TChain, TChainOverride> &
-  GetConstructorArgs<TAbi>
+> &
+  GetChain<chain, chainOverride> &
+  UnionEvaluate<
+    readonly [] extends allArgs
+      ? { args?: allArgs | undefined }
+      : { args: allArgs }
+  > & {
+    abi: abi
+    bytecode: Hex
+  }
 
 export type DeployContractReturnType = SendTransactionReturnType
 
@@ -60,31 +67,19 @@ export type DeployContractReturnType = SendTransactionReturnType
  * })
  */
 export function deployContract<
-  const TAbi extends Abi | readonly unknown[],
-  TChain extends Chain | undefined,
-  TAccount extends Account | undefined,
-  TChainOverride extends Chain | undefined,
+  const abi extends Abi | readonly unknown[],
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined,
 >(
-  walletClient: Client<Transport, TChain, TAccount>,
-  {
-    abi,
-    args,
-    bytecode,
-    ...request
-  }: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>,
+  walletClient: Client<Transport, chain, account>,
+  parameters: DeployContractParameters<abi, chain, account, chainOverride>,
 ): Promise<DeployContractReturnType> {
-  const calldata = encodeDeployData({
-    abi,
-    args,
-    bytecode,
-  } as unknown as DeployContractParameters<
-    TAbi,
-    TChain,
-    TAccount,
-    TChainOverride
-  >)
+  const { abi, args, bytecode, ...request } =
+    parameters as DeployContractParameters
+  const calldata = encodeDeployData({ abi, args, bytecode })
   return sendTransaction(walletClient, {
     ...request,
     data: calldata,
-  } as unknown as SendTransactionParameters<TChain, TAccount, TChainOverride>)
+  } as unknown as SendTransactionParameters<chain, account, chainOverride>)
 }

package/src/actions/wallet/prepareTransactionRequest.ts

@@ -41,11 +41,8 @@ export type PrepareTransactionRequestReturnType<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
   TChainOverride extends Chain | undefined = Chain | undefined,
-> = UnionOmit<
-  FormattedTransactionRequest<
-    TChainOverride extends Chain ? TChainOverride : TChain
-  >,
-  'from'
+> = FormattedTransactionRequest<
+  TChainOverride extends Chain ? TChainOverride : TChain
 > &
   GetAccountParameter<TAccount> &
   GetChain<TChain, TChainOverride>
@@ -171,7 +168,7 @@ export async function prepareTransactionRequest<
 
   assertRequest(request as AssertRequestParameters)
 
-  return request as PrepareTransactionRequestReturnType<
+  return request as unknown as PrepareTransactionRequestReturnType<
     TChain,
     TAccount,
     TChainOverride

package/src/actions/wallet/signTypedData.ts

@@ -11,7 +11,10 @@ import type { Hex } from '../../types/misc.js'
 import type { TypedDataDefinition } from '../../types/typedData.js'
 import { isHex } from '../../utils/data/isHex.js'
 import { stringify } from '../../utils/stringify.js'
-import { validateTypedData } from '../../utils/typedData.js'
+import {
+  getTypesForEIP712Domain,
+  validateTypedData,
+} from '../../utils/typedData.js'
 
 export type SignTypedDataParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
@@ -143,19 +146,7 @@ export async function signTypedData<
   const account = parseAccount(account_)
 
   const types = {
-    EIP712Domain: [
-      typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-      domain?.version && { name: 'version', type: 'string' },
-      typeof domain?.chainId === 'number' && {
-        name: 'chainId',
-        type: 'uint256',
-      },
-      domain?.verifyingContract && {
-        name: 'verifyingContract',
-        type: 'address',
-      },
-      domain?.salt && { name: 'salt', type: 'bytes32' },
-    ].filter(Boolean),
+    EIP712Domain: getTypesForEIP712Domain({ domain }),
     ...parameters.types,
   }
 

package/src/chains/definitions/arbitrum.ts

@@ -0,0 +1,34 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const arbitrum = /*#__PURE__*/ defineChain({
+  id: 42_161,
+  name: 'Arbitrum One',
+  network: 'arbitrum',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    alchemy: {
+      http: ['https://arb-mainnet.g.alchemy.com/v2'],
+      webSocket: ['wss://arb-mainnet.g.alchemy.com/v2'],
+    },
+    infura: {
+      http: ['https://arbitrum-mainnet.infura.io/v3'],
+      webSocket: ['wss://arbitrum-mainnet.infura.io/ws/v3'],
+    },
+    default: {
+      http: ['https://arb1.arbitrum.io/rpc'],
+    },
+    public: {
+      http: ['https://arb1.arbitrum.io/rpc'],
+    },
+  },
+  blockExplorers: {
+    etherscan: { name: 'Arbiscan', url: 'https://arbiscan.io' },
+    default: { name: 'Arbiscan', url: 'https://arbiscan.io' },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 7654707,
+    },
+  },
+})

package/src/chains/definitions/arbitrumGoerli.ts

@@ -0,0 +1,39 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const arbitrumGoerli = /*#__PURE__*/ defineChain({
+  id: 421_613,
+  name: 'Arbitrum Goerli',
+  network: 'arbitrum-goerli',
+  nativeCurrency: {
+    name: 'Arbitrum Goerli Ether',
+    symbol: 'ETH',
+    decimals: 18,
+  },
+  rpcUrls: {
+    alchemy: {
+      http: ['https://arb-goerli.g.alchemy.com/v2'],
+      webSocket: ['wss://arb-goerli.g.alchemy.com/v2'],
+    },
+    infura: {
+      http: ['https://arbitrum-goerli.infura.io/v3'],
+      webSocket: ['wss://arbitrum-goerli.infura.io/ws/v3'],
+    },
+    default: {
+      http: ['https://goerli-rollup.arbitrum.io/rpc'],
+    },
+    public: {
+      http: ['https://goerli-rollup.arbitrum.io/rpc'],
+    },
+  },
+  blockExplorers: {
+    etherscan: { name: 'Arbiscan', url: 'https://goerli.arbiscan.io/' },
+    default: { name: 'Arbiscan', url: 'https://goerli.arbiscan.io/' },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 88114,
+    },
+  },
+  testnet: true,
+})

package/src/chains/definitions/arbitrumNova.ts

@@ -0,0 +1,34 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const arbitrumNova = /*#__PURE__*/ defineChain({
+  id: 42_170,
+  name: 'Arbitrum Nova',
+  network: 'arbitrum-nova',
+  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    blast: {
+      http: ['https://arbitrum-nova.public.blastapi.io'],
+      webSocket: ['wss://arbitrum-nova.public.blastapi.io'],
+    },
+    default: {
+      http: ['https://nova.arbitrum.io/rpc'],
+    },
+    public: {
+      http: ['https://nova.arbitrum.io/rpc'],
+    },
+  },
+  blockExplorers: {
+    etherscan: { name: 'Arbiscan', url: 'https://nova.arbiscan.io' },
+    blockScout: {
+      name: 'BlockScout',
+      url: 'https://nova-explorer.arbitrum.io/',
+    },
+    default: { name: 'Arbiscan', url: 'https://nova.arbiscan.io' },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 1746963,
+    },
+  },
+})

package/src/chains/definitions/aurora.ts

@@ -0,0 +1,21 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const aurora = /*#__PURE__*/ defineChain({
+  id: 1313161554,
+  name: 'Aurora',
+  network: 'aurora',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Ether',
+    symbol: 'ETH',
+  },
+  rpcUrls: {
+    infura: { http: ['https://aurora-mainnet.infura.io/v3'] },
+    default: { http: ['https://mainnet.aurora.dev'] },
+    public: { http: ['https://mainnet.aurora.dev'] },
+  },
+  blockExplorers: {
+    etherscan: { name: 'Aurorascan', url: 'https://aurorascan.dev' },
+    default: { name: 'Aurorascan', url: 'https://aurorascan.dev' },
+  },
+})

package/src/chains/definitions/auroraTestnet.ts

@@ -0,0 +1,22 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const auroraTestnet = /*#__PURE__*/ defineChain({
+  id: 1313161555,
+  name: 'Aurora Testnet',
+  network: 'aurora-testnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Ether',
+    symbol: 'ETH',
+  },
+  rpcUrls: {
+    infura: { http: ['https://aurora-testnet.infura.io/v3'] },
+    default: { http: ['https://testnet.aurora.dev'] },
+    public: { http: ['https://testnet.aurora.dev'] },
+  },
+  blockExplorers: {
+    etherscan: { name: 'Aurorascan', url: 'https://testnet.aurorascan.dev' },
+    default: { name: 'Aurorascan', url: 'https://testnet.aurorascan.dev' },
+  },
+  testnet: true,
+})

package/src/chains/definitions/avalanche.ts

@@ -0,0 +1,26 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const avalanche = /*#__PURE__*/ defineChain({
+  id: 43_114,
+  name: 'Avalanche',
+  network: 'avalanche',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Avalanche',
+    symbol: 'AVAX',
+  },
+  rpcUrls: {
+    default: { http: ['https://api.avax.network/ext/bc/C/rpc'] },
+    public: { http: ['https://api.avax.network/ext/bc/C/rpc'] },
+  },
+  blockExplorers: {
+    etherscan: { name: 'SnowTrace', url: 'https://snowtrace.io' },
+    default: { name: 'SnowTrace', url: 'https://snowtrace.io' },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 11907934,
+    },
+  },
+})

package/src/chains/definitions/avalancheFuji.ts

@@ -0,0 +1,27 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const avalancheFuji = /*#__PURE__*/ defineChain({
+  id: 43_113,
+  name: 'Avalanche Fuji',
+  network: 'avalanche-fuji',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'Avalanche Fuji',
+    symbol: 'AVAX',
+  },
+  rpcUrls: {
+    default: { http: ['https://api.avax-test.network/ext/bc/C/rpc'] },
+    public: { http: ['https://api.avax-test.network/ext/bc/C/rpc'] },
+  },
+  blockExplorers: {
+    etherscan: { name: 'SnowTrace', url: 'https://testnet.snowtrace.io' },
+    default: { name: 'SnowTrace', url: 'https://testnet.snowtrace.io' },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+      blockCreated: 7096959,
+    },
+  },
+  testnet: true,
+})

package/src/chains/definitions/base.ts

@@ -0,0 +1,42 @@
+import { defineChain } from '../../utils/chain.js'
+import { formattersOptimism } from '../optimism/formatters.js'
+
+export const base = /*#__PURE__*/ defineChain(
+  {
+    id: 8453,
+    network: 'base',
+    name: 'Base',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+      default: {
+        http: ['https://mainnet.base.org'],
+      },
+      public: {
+        http: ['https://mainnet.base.org'],
+      },
+    },
+    blockExplorers: {
+      blockscout: {
+        name: 'Basescout',
+        url: 'https://base.blockscout.com',
+      },
+      default: {
+        name: 'Basescan',
+        url: 'https://basescan.org',
+      },
+      etherscan: {
+        name: 'Basescan',
+        url: 'https://basescan.org',
+      },
+    },
+    contracts: {
+      multicall3: {
+        address: '0xca11bde05977b3631167028862be2a173976ca11',
+        blockCreated: 5022,
+      },
+    },
+  },
+  {
+    formatters: formattersOptimism,
+  },
+)

package/src/chains/definitions/baseGoerli.ts

@@ -0,0 +1,40 @@
+import { defineChain } from '../../utils/chain.js'
+import { formattersOptimism } from '../optimism/formatters.js'
+
+export const baseGoerli = /*#__PURE__*/ defineChain(
+  {
+    id: 84531,
+    network: 'base-goerli',
+    name: 'Base Goerli',
+    nativeCurrency: { name: 'Goerli Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+      default: {
+        http: ['https://goerli.base.org'],
+      },
+      public: {
+        http: ['https://goerli.base.org'],
+      },
+    },
+    blockExplorers: {
+      etherscan: {
+        name: 'Basescan',
+        url: 'https://goerli.basescan.org',
+      },
+      default: {
+        name: 'Basescan',
+        url: 'https://goerli.basescan.org',
+      },
+    },
+    contracts: {
+      multicall3: {
+        address: '0xca11bde05977b3631167028862be2a173976ca11',
+        blockCreated: 1376988,
+      },
+    },
+    testnet: true,
+    sourceId: 5, // goerli
+  },
+  {
+    formatters: formattersOptimism,
+  },
+)

package/src/chains/definitions/bearNetworkChainMainnet.ts

@@ -0,0 +1,19 @@
+import { defineChain } from '../../utils/chain.js'
+
+export const bearNetworkChainMainnet = /*#__PURE__*/ defineChain({
+  id: 641230,
+  name: 'Bear Network Chain Mainnet',
+  network: 'BearNetworkChainMainnet',
+  nativeCurrency: {
+    decimals: 18,
+    name: 'BearNetworkChain',
+    symbol: 'BRNKC',
+  },
+  rpcUrls: {
+    public: { http: ['https://brnkc-mainnet.bearnetwork.net'] },
+    default: { http: ['https://brnkc-mainnet.bearnetwork.net'] },
+  },
+  blockExplorers: {
+    default: { name: 'BrnkScan', url: 'https://brnkscan.bearnetwork.net' },
+  },
+})