viem 0.0.1-alpha.23 → 0.0.1-alpha.25

package/dist/utils/index.mjs

@@ -10,6 +10,7 @@ import {
   decodeAbi,
   decodeBytes,
   decodeErrorResult,
+  decodeEventLog,
   decodeFunctionData,
   decodeFunctionResult,
   decodeHex,
@@ -63,9 +64,6 @@ import {
   isBytes,
   isHex,
   keccak256,
-  labelhash,
-  namehash,
-  normalize,
   numberToBytes,
   numberToHex,
   pad,
@@ -85,7 +83,7 @@ import {
   transactionType,
   trim,
   weiUnits
-} from "../chunk-XBUH66KN.mjs";
+} from "../chunk-KSAO4Y4Q.mjs";
 export {
   boolToBytes,
   boolToHex,
@@ -98,6 +96,7 @@ export {
   decodeAbi,
   decodeBytes,
   decodeErrorResult,
+  decodeEventLog,
   decodeFunctionData,
   decodeFunctionResult,
   decodeHex,
@@ -151,9 +150,6 @@ export {
   isBytes,
   isHex,
   keccak256,
-  labelhash,
-  namehash,
-  normalize,
   numberToBytes,
   numberToHex,
   pad,

package/dist/wallet.d.ts

@@ -1,8 +1,42 @@
-export { G as GetPermissionsResponse, R as RequestPermissionsResponse, S as SignMessageArgs, a as SignMessageResponse, b as SwitchChainArgs, W as WatchAssetArgs, c as WatchAssetResponse, d as addChain, g as getAccounts, e as getPermissions, r as requestAccounts, f as requestPermissions, s as signMessage, h as switchChain, w as watchAsset } from './watchAsset-efd3dd05.js';
-export { F as FormattedTransactionRequest, S as SendTransactionArgs, a as SendTransactionResponse, s as sendTransaction } from './sendTransaction-f17a2389.js';
-import './chain-4b39613a.js';
+import { C as Chain, A as Address, H as Hex, B as ByteArray } from './chain-f16512e8.js';
+import { W as WalletClient } from './createWalletClient-75813d83.js';
+import { a as WalletPermission, b as WatchAssetParams } from './eip1193-6f9ba163.js';
+export { F as FormattedTransactionRequest, S as SendTransactionArgs, a as SendTransactionResponse, s as sendTransaction } from './sendTransaction-e713f90c.js';
 import '@wagmi/chains';
-import './createWalletClient-c10df94d.js';
-import './eip1193-4c24765a.js';
-import './createClient-55a04188.js';
-import './transactionRequest-93e9f001.js';
+import './createClient-68ee4bb4.js';
+import './transactionRequest-c7794f5e.js';
+
+declare function addChain(client: WalletClient, chain: Chain): Promise<void>;
+
+declare function getAccounts(client: WalletClient): Promise<`0x${string}`[]>;
+
+type GetPermissionsResponse = WalletPermission[];
+declare function getPermissions(client: WalletClient): Promise<WalletPermission[]>;
+
+declare function requestAccounts(client: WalletClient): Promise<`0x${string}`[]>;
+
+type RequestPermissionsArgs = {
+    eth_accounts: Record<string, any>;
+} & {
+    [key: string]: Record<string, any>;
+};
+type RequestPermissionsResponse = WalletPermission[];
+declare function requestPermissions(client: WalletClient, permissions: RequestPermissionsArgs): Promise<WalletPermission[]>;
+
+type SignMessageArgs = {
+    from: Address;
+    data: Hex | ByteArray;
+};
+type SignMessageResponse = Hex;
+declare function signMessage(client: WalletClient, { from, data: data_ }: SignMessageArgs): Promise<SignMessageResponse>;
+
+type SwitchChainArgs = {
+    id: Chain['id'];
+};
+declare function switchChain(client: WalletClient, { id }: SwitchChainArgs): Promise<void>;
+
+type WatchAssetArgs = WatchAssetParams;
+type WatchAssetResponse = boolean;
+declare function watchAsset(client: WalletClient, params: WatchAssetParams): Promise<WatchAssetResponse>;
+
+export { GetPermissionsResponse, RequestPermissionsResponse, SignMessageArgs, SignMessageResponse, SwitchChainArgs, WatchAssetArgs, WatchAssetResponse, addChain, getAccounts, getPermissions, requestAccounts, requestPermissions, signMessage, switchChain, watchAsset };

package/dist/wallet.js

@@ -8,8 +8,8 @@
 
 
 
-var _chunk7Y5QVLX7js = require('./chunk-7Y5QVLX7.js');
-require('./chunk-SSPRUPGN.js');
+var _chunkNUXMGPMKjs = require('./chunk-NUXMGPMK.js');
+require('./chunk-THMRUG4D.js');
 
 
 
@@ -20,5 +20,5 @@ require('./chunk-SSPRUPGN.js');
 
 
 
-exports.addChain = _chunk7Y5QVLX7js.addChain; exports.getAccounts = _chunk7Y5QVLX7js.getAccounts; exports.getPermissions = _chunk7Y5QVLX7js.getPermissions; exports.requestAccounts = _chunk7Y5QVLX7js.requestAccounts; exports.requestPermissions = _chunk7Y5QVLX7js.requestPermissions; exports.sendTransaction = _chunk7Y5QVLX7js.sendTransaction; exports.signMessage = _chunk7Y5QVLX7js.signMessage; exports.switchChain = _chunk7Y5QVLX7js.switchChain; exports.watchAsset = _chunk7Y5QVLX7js.watchAsset;
+exports.addChain = _chunkNUXMGPMKjs.addChain; exports.getAccounts = _chunkNUXMGPMKjs.getAccounts; exports.getPermissions = _chunkNUXMGPMKjs.getPermissions; exports.requestAccounts = _chunkNUXMGPMKjs.requestAccounts; exports.requestPermissions = _chunkNUXMGPMKjs.requestPermissions; exports.sendTransaction = _chunkNUXMGPMKjs.sendTransaction; exports.signMessage = _chunkNUXMGPMKjs.signMessage; exports.switchChain = _chunkNUXMGPMKjs.switchChain; exports.watchAsset = _chunkNUXMGPMKjs.watchAsset;
 //# sourceMappingURL=wallet.js.map

package/dist/wallet.mjs

@@ -8,8 +8,8 @@ import {
   signMessage,
   switchChain,
   watchAsset
-} from "./chunk-TXHOG6KU.mjs";
-import "./chunk-XBUH66KN.mjs";
+} from "./chunk-LEPQJNVO.mjs";
+import "./chunk-KSAO4Y4Q.mjs";
 export {
   addChain,
   getAccounts,

package/dist/watchEvent-c346c12d.d.ts

@@ -0,0 +1,41 @@
+import { A as Address, b as BlockTag, H as Hex, L as Log } from './chain-f16512e8.js';
+import { P as PublicClient } from './createPublicClient-b732194e.js';
+import { j as EventDefinition, k as ExtractArgsFromEventDefinition } from './contract-9e76e561.js';
+
+type EventFilterArgs<TEventDefinition extends EventDefinition> = ExtractArgsFromEventDefinition<TEventDefinition>;
+
+type GetBytecodeArgs = {
+    address: Address;
+} & ({
+    blockNumber?: never;
+    blockTag?: BlockTag;
+} | {
+    blockNumber?: bigint;
+    blockTag?: never;
+});
+type GetBytecodeResponse = Hex | undefined;
+declare function getBytecode(client: PublicClient, { address, blockNumber, blockTag }: GetBytecodeArgs): Promise<GetBytecodeResponse>;
+
+type OnLogsResponse = Log[];
+type OnLogs = (logs: OnLogsResponse) => void;
+type WatchEventArgs<TEventDefinition extends EventDefinition> = {
+    /** The address of the contract. */
+    address?: Address | Address[];
+    /** Whether or not the event logs should be batched on each invocation. */
+    batch?: boolean;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** The callback to call when new event logs are received. */
+    onLogs: OnLogs;
+    /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+    pollingInterval?: number;
+} & ({
+    event: TEventDefinition;
+    args?: EventFilterArgs<TEventDefinition>;
+} | {
+    event?: never;
+    args?: never;
+});
+declare function watchEvent<TEventDefinition extends EventDefinition>(client: PublicClient, { address, args, batch, event, onError, onLogs, pollingInterval, }: WatchEventArgs<TEventDefinition>): () => void;
+
+export { EventFilterArgs as E, GetBytecodeArgs as G, OnLogs as O, GetBytecodeResponse as a, OnLogsResponse as b, getBytecode as g, watchEvent as w };

package/dist/window.d.ts

@@ -1,5 +1,5 @@
-import { R as Requests, E as Events } from './eip1193-4c24765a.js';
-import './chain-4b39613a.js';
+import { R as Requests, E as Events } from './eip1193-6f9ba163.js';
+import './chain-f16512e8.js';
 import '@wagmi/chains';
 
 type WindowProvider = Requests & Events;

package/ens/package.json

@@ -0,0 +1,4 @@
+{
+  "module": "../dist/ens.mjs",
+  "main": "../dist/ens.js"
+}

package/package.json

@@ -3,19 +3,23 @@
   "description": "TypeScript Interface for Ethereum",
   "dependencies": {
     "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "~0.2.6",
+    "@wagmi/chains": "~0.2.8",
     "abitype": "~0.3.0",
-    "idna-uts46-hx": "^4.1.2"
+    "idna-uts46-hx": "^4.1.2",
+    "isomorphic-unfetch": "^4.0.2",
+    "isomorphic-ws": "^5.0.0",
+    "ws": "^8.12.0"
   },
-  "version": "0.0.1-alpha.23",
+  "version": "0.0.1-alpha.25",
   "files": [
-    "/actions",
     "/chains",
+    "/contract",
     "/dist",
-    "/clients",
+    "/ens",
     "/src",
     "/types",
     "/utils",
+    "/wallet",
     "/window"
   ],
   "exports": {
@@ -29,10 +33,10 @@
       "module": "./dist/chains.mjs",
       "default": "./dist/chains.js"
     },
-    "./clients": {
-      "types": "./dist/clients/index.d.ts",
-      "module": "./dist/clients/index.mjs",
-      "default": "./dist/clients/index.js"
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "module": "./dist/contract.mjs",
+      "default": "./dist/contract.js"
     },
     "./ens": {
       "types": "./dist/ens.d.ts",

package/src/_test/constants.ts

@@ -44,6 +44,8 @@ export const accounts = [
 ] as const
 
 export const address = {
+  burn: '0x0000000000000000000000000000000000000000',
+  usdcHolder: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
   vitalik: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
 } as const
 

package/src/_test/utils.ts

@@ -7,7 +7,7 @@ import {
   getTransactionReceipt,
   mine,
 } from '../actions'
-import { Chain, localhost } from '../chains'
+import { Chain, localhost, mainnet } from '../chains'
 import {
   createPublicClient,
   createTestClient,
@@ -27,15 +27,20 @@ import type { AddressInfo } from 'net'
 import { baycContractConfig } from './abis'
 import { Hex } from '../types'
 
+const anvil = {
+  ...localhost,
+  contracts: mainnet.contracts,
+} as const satisfies Chain
+
 export const publicClient =
   process.env.VITE_NETWORK_TRANSPORT_MODE === 'webSocket'
     ? createPublicClient({
-        chain: localhost,
+        chain: anvil,
         pollingInterval: 1_000,
         transport: webSocket(localWsUrl),
       })
     : createPublicClient({
-        chain: localhost,
+        chain: anvil,
         pollingInterval: 1_000,
         transport: http(),
       })
@@ -86,7 +91,7 @@ export const walletClient = createWalletClient({
           },
         ]
 
-      const { result } = await rpc.http(localhost.rpcUrls.default.http[0], {
+      const { result } = await rpc.http(anvil.rpcUrls.default.http[0], {
         body: {
           method,
           params,
@@ -98,7 +103,7 @@ export const walletClient = createWalletClient({
 })
 
 export const testClient = createTestClient({
-  chain: localhost,
+  chain: anvil,
   mode: 'anvil',
   transport: http(),
 })

package/src/actions/ens/getEnsAddress.bench.ts

@@ -0,0 +1,26 @@
+import { bench, describe } from 'vitest'
+
+import {
+  ethersProvider,
+  ethersV6Provider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+
+import { getEnsAddress } from './getEnsAddress'
+
+describe('Get ENS Name', () => {
+  bench('viem: `getEnsAddress`', async () => {
+    await getEnsAddress(publicClient, {
+      name: 'awkweb.eth',
+    })
+  })
+
+  bench('ethers: `resolveName`', async () => {
+    await ethersProvider.resolveName('awkweb.eth')
+  })
+
+  bench('ethers@6: `resolveName`', async () => {
+    await ethersV6Provider.resolveName('awkweb.eth')
+  })
+})

package/src/actions/ens/getEnsAddress.test.ts

@@ -0,0 +1,97 @@
+import { expect, test } from 'vitest'
+import { optimism } from '../../chains'
+import { createPublicClient, http } from '../../clients'
+
+import { localHttpUrl, publicClient } from '../../_test'
+import { getEnsAddress } from './getEnsAddress'
+
+test('gets address for name', async () => {
+  await expect(
+    getEnsAddress(publicClient, { name: 'awkweb.eth' }),
+  ).resolves.toMatchInlineSnapshot(
+    '"0xA0Cf798816D4b9b9866b5330EEa46a18382f251e"',
+  )
+})
+
+test('name without address', async () => {
+  await expect(
+    getEnsAddress(publicClient, { name: 'unregistered-name.eth' }),
+  ).resolves.toMatchInlineSnapshot(
+    '"0x0000000000000000000000000000000000000000"',
+  )
+})
+
+test('custom universal resolver address', async () => {
+  await expect(
+    getEnsAddress(publicClient, {
+      name: 'awkweb.eth',
+      universalResolverAddress: '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',
+    }),
+  ).resolves.toMatchInlineSnapshot(
+    '"0xA0Cf798816D4b9b9866b5330EEa46a18382f251e"',
+  )
+})
+
+test('chain not provided', async () => {
+  await expect(
+    getEnsAddress(
+      createPublicClient({
+        transport: http(localHttpUrl),
+      }),
+      { name: 'awkweb.eth' },
+    ),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(
+    '"client chain not configured. universalResolverAddress is required."',
+  )
+})
+
+test('universal resolver contract not configured for chain', async () => {
+  await expect(
+    getEnsAddress(
+      createPublicClient({
+        chain: optimism,
+        transport: http(),
+      }),
+      { name: 'awkweb.eth' },
+    ),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Chain \\"Optimism\\" does not support contract \\"ensUniversalResolver\\".
+
+    This could be due to any of the following:
+    - The chain does not have the contract \\"ensUniversalResolver\\" configured.
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('universal resolver contract deployed on later block', async () => {
+  await expect(
+    getEnsAddress(publicClient, { name: 'awkweb.eth', blockNumber: 14353601n }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Chain \\"Localhost\\" does not support contract \\"ensUniversalResolver\\".
+
+    This could be due to any of the following:
+    - The contract \\"ensUniversalResolver\\" was not deployed until block 16172161 (current block 14353601).
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('invalid universal resolver address', async () => {
+  await expect(
+    getEnsAddress(publicClient, {
+      name: 'awkweb.eth',
+      universalResolverAddress: '0xecb504d39723b0be0e3a9aa33d646642d1051ee1',
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "The contract function \\"resolve\\" reverted with the following reason:
+    execution reverted
+
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  resolve(bytes name, bytes data)
+    Arguments:        (0x0661776b7765620365746800, 0x3b3b57de52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c)
+
+    Docs: https://viem.sh/docs/contract/readContract
+    Version: viem@1.0.2"
+  `)
+})

package/src/actions/ens/getEnsAddress.ts

@@ -0,0 +1,122 @@
+import { PublicClient } from '../../clients'
+import { ChainDoesNotSupportContract } from '../../errors'
+import type { Address, Prettify } from '../../types'
+import {
+  decodeFunctionResult,
+  encodeFunctionData,
+  encodeHex,
+} from '../../utils'
+import { namehash, packetToBytes } from '../../utils/ens'
+import { readContract, ReadContractArgs } from '../public'
+
+export type GetEnsAddressArgs = Prettify<
+  Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
+    /** ENS name to get address. */
+    name: string
+    /** Address of ENS Universal Resolver Contract */
+    universalResolverAddress?: Address
+  }
+>
+
+/**
+ * @description Gets address for ENS name.
+ *
+ * - Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensAddress = await getEnsAddress(publicClient, {
+ *   name: 'wagmi-dev.eth',
+ * })
+ * // '0xd2135CfB216b74109775236E36d4b433F1DF507B'
+ */
+export async function getEnsAddress(
+  client: PublicClient,
+  {
+    blockNumber,
+    blockTag,
+    name,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsAddressArgs,
+) {
+  let universalResolverAddress = universalResolverAddress_
+  if (!universalResolverAddress) {
+    if (!client.chain)
+      throw new Error(
+        'client chain not configured. universalResolverAddress is required.',
+      )
+
+    const contract = client.chain?.contracts?.ensUniversalResolver
+    if (!contract)
+      throw new ChainDoesNotSupportContract({
+        chain: client.chain,
+        contract: { name: 'ensUniversalResolver' },
+      })
+
+    if (
+      blockNumber &&
+      contract.blockCreated &&
+      contract.blockCreated > blockNumber
+    )
+      throw new ChainDoesNotSupportContract({
+        blockNumber,
+        chain: client.chain,
+        contract: {
+          name: 'ensUniversalResolver',
+          blockCreated: contract.blockCreated,
+        },
+      })
+
+    universalResolverAddress = contract.address
+  }
+
+  const res = await readContract(client, {
+    address: universalResolverAddress,
+    abi: [
+      {
+        name: 'resolve',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+          { name: 'name', type: 'bytes' },
+          { name: 'data', type: 'bytes' },
+        ],
+        outputs: [
+          { name: '', type: 'bytes' },
+          { name: 'address', type: 'address' },
+        ],
+      },
+    ],
+    functionName: 'resolve',
+    args: [
+      encodeHex(packetToBytes(name)),
+      encodeFunctionData({
+        abi: [
+          {
+            name: 'addr',
+            type: 'function',
+            stateMutability: 'view',
+            inputs: [{ name: 'name', type: 'bytes32' }],
+            outputs: [],
+          },
+        ],
+        functionName: 'addr',
+        args: [namehash(name)],
+      }),
+    ],
+    blockNumber,
+    blockTag,
+  })
+  return decodeFunctionResult({
+    abi: [
+      {
+        name: 'addr',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [],
+        outputs: [{ name: 'name', type: 'address' }],
+      },
+    ],
+    functionName: 'addr',
+    data: res[0],
+  })
+}

package/src/actions/ens/getEnsName.bench.ts

@@ -0,0 +1,30 @@
+import { bench, describe } from 'vitest'
+
+import {
+  ethersProvider,
+  ethersV6Provider,
+  publicClient,
+  web3Provider,
+} from '../../_test'
+
+import { getEnsName } from './getEnsName'
+
+describe('Get ENS Name', () => {
+  bench('viem: `getEnsName`', async () => {
+    await getEnsName(publicClient, {
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    })
+  })
+
+  bench('ethers: `lookupAddress`', async () => {
+    await ethersProvider.lookupAddress(
+      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    )
+  })
+
+  bench('ethers@6: `lookupAddress`', async () => {
+    await ethersV6Provider.lookupAddress(
+      '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    )
+  })
+})

package/src/actions/ens/getEnsName.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from 'vitest'
+import { localhost, mainnet, optimism } from '../../chains'
+import { createPublicClient, http } from '../../clients'
+
+import { address, localHttpUrl, publicClient } from '../../_test'
+
+import { getEnsName } from './getEnsName'
+
+test('gets primary name for address', async () => {
+  await expect(
+    getEnsName(publicClient, {
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+    }),
+  ).resolves.toMatchInlineSnapshot('"awkweb.eth"')
+})
+
+test('address with no primary name', async () => {
+  await expect(
+    getEnsName(publicClient, {
+      address: address.burn,
+    }),
+  ).resolves.toMatchInlineSnapshot('null')
+})
+
+test('custom universal resolver address', async () => {
+  await expect(
+    getEnsName(publicClient, {
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+      universalResolverAddress: '0x74E20Bd2A1fE0cdbe45b9A1d89cb7e0a45b36376',
+    }),
+  ).resolves.toMatchInlineSnapshot('"awkweb.eth"')
+})
+
+test('chain not provided', async () => {
+  await expect(
+    getEnsName(
+      createPublicClient({
+        transport: http(localHttpUrl),
+      }),
+      { address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e' },
+    ),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(
+    '"client chain not configured. universalResolverAddress is required."',
+  )
+})
+
+test('universal resolver contract not configured for chain', async () => {
+  await expect(
+    getEnsName(
+      createPublicClient({
+        chain: optimism,
+        transport: http(),
+      }),
+      {
+        address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+      },
+    ),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Chain \\"Optimism\\" does not support contract \\"ensUniversalResolver\\".
+
+    This could be due to any of the following:
+    - The chain does not have the contract \\"ensUniversalResolver\\" configured.
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('universal resolver contract deployed on later block', async () => {
+  await expect(
+    getEnsName(publicClient, {
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+      blockNumber: 14353601n,
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "Chain \\"Localhost\\" does not support contract \\"ensUniversalResolver\\".
+
+    This could be due to any of the following:
+    - The contract \\"ensUniversalResolver\\" was not deployed until block 16172161 (current block 14353601).
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('invalid universal resolver address', async () => {
+  await expect(
+    getEnsName(publicClient, {
+      address: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+      universalResolverAddress: '0xecb504d39723b0be0e3a9aa33d646642d1051ee1',
+    }),
+  ).rejects.toThrowErrorMatchingInlineSnapshot(`
+    "The contract function \\"reverse\\" reverted with the following reason:
+    execution reverted
+
+    Contract:  0x0000000000000000000000000000000000000000
+    Function:  reverse(bytes reverseName)
+    Arguments:        (0x28613063663739383831366434623962393836366235333330656561343661313833383266323531650461646472077265766572736500)
+
+    Docs: https://viem.sh/docs/contract/readContract
+    Version: viem@1.0.2"
+  `)
+})