viem 0.0.1-alpha.24 → 0.0.1-alpha.25

package/src/actions/ens/getEnsName.ts

@@ -0,0 +1,106 @@
+import { PublicClient } from '../../clients'
+import { panicReasons } from '../../constants'
+import {
+  ChainDoesNotSupportContract,
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+} from '../../errors'
+import type { Address, Prettify } from '../../types'
+import { encodeHex } from '../../utils'
+import { packetToBytes } from '../../utils/ens'
+import { readContract, ReadContractArgs } from '../public'
+
+export type GetEnsNameArgs = Prettify<
+  Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
+    /** Address to get ENS name for. */
+    address: Address
+    /** Address of ENS Universal Resolver Contract. */
+    universalResolverAddress?: Address
+  }
+>
+
+/**
+ * @description Gets primary name for specified address.
+ *
+ * - Calls `reverse(bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensName = await getEnsName(publicClient, {
+ *   address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
+ * })
+ * // 'wagmi-dev.eth'
+ */
+export async function getEnsName(
+  client: PublicClient,
+  {
+    address,
+    blockNumber,
+    blockTag,
+    universalResolverAddress: universalResolverAddress_,
+  }: GetEnsNameArgs,
+) {
+  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 reverseNode = `${address.toLowerCase().substring(2)}.addr.reverse`
+  try {
+    const res = await readContract(client, {
+      address: universalResolverAddress,
+      abi: [
+        {
+          name: 'reverse',
+          type: 'function',
+          stateMutability: 'view',
+          inputs: [{ type: 'bytes', name: 'reverseName' }],
+          outputs: [
+            { type: 'string', name: 'resolvedName' },
+            { type: 'address', name: 'resolvedAddress' },
+            { type: 'address', name: 'reverseResolver' },
+            { type: 'address', name: 'resolver' },
+          ],
+        },
+      ],
+      functionName: 'reverse',
+      args: [encodeHex(packetToBytes(reverseNode))],
+      blockNumber,
+      blockTag,
+    })
+    return res[0]
+  } catch (error) {
+    if (
+      error instanceof ContractFunctionExecutionError &&
+      (error.cause as ContractFunctionRevertedError).reason === panicReasons[50]
+    )
+      // No primary name set for address.
+      return null
+    throw error
+  }
+}

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

@@ -0,0 +1,12 @@
+import { expect, test } from 'vitest'
+
+import * as actions from './index'
+
+test('exports actions', () => {
+  expect(actions).toMatchInlineSnapshot(`
+    {
+      "getEnsAddress": [Function],
+      "getEnsName": [Function],
+    }
+  `)
+})

package/src/actions/ens/index.ts

@@ -0,0 +1,3 @@
+export { getEnsAddress, type GetEnsAddressArgs } from './getEnsAddress'
+
+export { getEnsName, type GetEnsNameArgs } from './getEnsName'

package/src/actions/index.ts

@@ -4,7 +4,6 @@ export {
   createContractEventFilter,
   createEventFilter,
   createPendingTransactionFilter,
-  deployContract,
   estimateGas,
   getBalance,
   getBlock,
@@ -43,8 +42,6 @@ export type {
   CreateEventFilterArgs,
   CreateEventFilterResponse,
   CreatePendingTransactionFilterResponse,
-  DeployContractArgs,
-  DeployContractResponse,
   EstimateGasArgs,
   EstimateGasResponse,
   GetBalanceArgs,
@@ -156,6 +153,7 @@ export type {
 
 export {
   addChain,
+  deployContract,
   getAccounts,
   getPermissions,
   requestAccounts,
@@ -167,6 +165,8 @@ export {
   writeContract,
 } from './wallet'
 export type {
+  DeployContractArgs,
+  DeployContractResponse,
   FormattedTransactionRequest,
   GetPermissionsResponse,
   RequestPermissionsResponse,

package/src/actions/public/createEventFilter.test.ts

@@ -111,7 +111,7 @@ describe('buildFilterTopics', () => {
     ])
   })
 
-  test.skip('named args', () => {
+  test('named args', () => {
     expect(
       buildFilterTopics({
         event: 'Transfer(address indexed from, address indexed to)',
@@ -155,9 +155,43 @@ describe('buildFilterTopics', () => {
       '0x000000000000000000000000000000000000000000000000000000000000000c',
       '0x0000000000000000000000000000000000000000000000000000000000000001',
     ])
+
+    expect(
+      buildFilterTopics({
+        event:
+          'Transfer(string indexed baz, uint indexed foo, bool indexed bar)',
+        args: {
+          baz: 'watermelon sugar high',
+          foo: 12,
+          bar: true,
+        },
+      }),
+    ).toEqual([
+      '0xd72ffe8f642f870a4e0b389d4e008752294ecfa2a379b4a9790c067aef635088',
+      '0xdb31e24017b555ff340729aa37fadedf910b5395e13a218e76e155c39527bf02',
+      '0x000000000000000000000000000000000000000000000000000000000000000c',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    ])
+
+    expect(
+      buildFilterTopics({
+        event:
+          'Transfer(bytes indexed baz, uint indexed foo, bool indexed bar)',
+        args: {
+          baz: '0x69420',
+          foo: 12,
+          bar: true,
+        },
+      }),
+    ).toEqual([
+      '0xd0ac01db7189fe6027705e6dda462153bf4aec72630a11dcec054ac78bac314d',
+      '0xd36b1a27d526376a81ba9b34292f4103e8340cc80a493e43aa00a14ebd0df4c5',
+      '0x000000000000000000000000000000000000000000000000000000000000000c',
+      '0x0000000000000000000000000000000000000000000000000000000000000001',
+    ])
   })
 
-  test.skip('unnamed args', () => {
+  test('unnamed args', () => {
     expect(
       buildFilterTopics({
         event: 'Transfer(address indexed, address indexed, uint indexed)',
@@ -240,6 +274,4 @@ describe('buildFilterTopics', () => {
       ],
     ])
   })
-
-  // TODO: more arg types
 })

package/src/actions/public/createEventFilter.ts

@@ -1,3 +1,4 @@
+import { Abi } from 'abitype'
 import type { PublicClient } from '../../clients'
 
 import type {
@@ -9,7 +10,14 @@ import type {
   Filter,
   LogTopic,
 } from '../../types'
-import { getEventSignature, numberToHex } from '../../utils'
+import {
+  EncodeEventTopicsArgs,
+  encodeEventTopics,
+  extractFunctionName,
+  extractFunctionParams,
+  numberToHex,
+  getAbiItem,
+} from '../../utils'
 
 export type EventFilterArgs<TEventDefinition extends EventDefinition> =
   ExtractArgsFromEventDefinition<TEventDefinition>
@@ -43,9 +51,7 @@ export async function createEventFilter<
   }: CreateEventFilterArgs<TEventDefinition> = {},
 ): Promise<CreateEventFilterResponse> {
   let topics: LogTopic[] = []
-  if (event) {
-    topics = buildFilterTopics({ event, args })
-  }
+  if (event) topics = buildFilterTopics({ event, args })
   const id = await client.request({
     method: 'eth_newFilter',
     params: [
@@ -61,16 +67,27 @@ export async function createEventFilter<
   return { id, type: 'event' }
 }
 
-export function buildFilterTopics<TEventDefinition extends EventDefinition,>({
+export function buildFilterTopics<TEventDefinition extends EventDefinition>({
   event,
-  args: _args,
+  args,
 }: {
   event: TEventDefinition
   args?: EventFilterArgs<TEventDefinition>
 }) {
-  const signature = getEventSignature(event)
-
-  // TODO: support args
+  const eventName = extractFunctionName(event)!
+  const abi = unstable_parseAbi(event)
+  return encodeEventTopics({ abi, eventName, args } as EncodeEventTopicsArgs)
+}
 
-  return [signature]
+// REFACTOR: Implement a full version of `parseAbi` that supports more types (functions, errors) & more complex arg types (structs & arrays).
+function unstable_parseAbi(definition: EventDefinition): Abi {
+  const name = extractFunctionName(definition)!
+  const params = extractFunctionParams(definition)
+  return [
+    {
+      type: 'event',
+      name,
+      inputs: params || [],
+    },
+  ]
 }

package/src/actions/public/getFilterChanges.test.ts

@@ -17,7 +17,7 @@ import {
   setIntervalMining,
   stopImpersonatingAccount,
 } from '../test'
-import { sendTransaction } from '../wallet'
+import { sendTransaction, writeContract } from '../wallet'
 import { parseEther } from '../../utils'
 import type { Hash, Log } from '../../types'
 import { createBlockFilter } from './createBlockFilter'
@@ -30,6 +30,9 @@ beforeAll(async () => {
   await impersonateAccount(testClient, {
     address: address.vitalik,
   })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 afterAll(async () => {
@@ -37,6 +40,9 @@ afterAll(async () => {
   await stopImpersonatingAccount(testClient, {
     address: address.vitalik,
   })
+  await stopImpersonatingAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 test('default', async () => {
@@ -135,7 +141,8 @@ describe('events', () => {
 
   test('args: event', async () => {
     const filter = await createEventFilter(publicClient, {
-      event: 'Transfer(address from, address to, uint256 value)',
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
     })
 
     await sendTransaction(walletClient, {
@@ -172,7 +179,8 @@ describe('events', () => {
 
   test('args: fromBlock/toBlock', async () => {
     const filter = await createEventFilter(publicClient, {
-      event: 'Transfer(address from, address to, uint256 value)',
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
       fromBlock: initialBlockNumber - 5n,
       toBlock: initialBlockNumber,
     })
@@ -185,5 +193,191 @@ describe('events', () => {
     expect(logs.length).toBe(0)
   })
 
-  test.todo('args: args')
+  test('args: singular `from`', async () => {
+    const namedFilter = await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        from: address.vitalik,
+      },
+    })
+    const unnamedFilter = await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [address.vitalik],
+    })
+
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (await getFilterChanges(publicClient, { filter: namedFilter })).length,
+    ).toBe(2)
+    expect(
+      (await getFilterChanges(publicClient, { filter: unnamedFilter })).length,
+    ).toBe(2)
+  })
+
+  test('args: multiple `from`', async () => {
+    const namedFilter = await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        from: [address.usdcHolder, address.vitalik],
+      },
+    })
+    const unnamedFilter = await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [[address.usdcHolder, address.vitalik]],
+    })
+
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (await getFilterChanges(publicClient, { filter: namedFilter })).length,
+    ).toBe(3)
+    expect(
+      (await getFilterChanges(publicClient, { filter: unnamedFilter })).length,
+    ).toBe(3)
+  })
+
+  test('args: singular `to`', async () => {
+    const namedFilter = await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        to: accounts[0].address,
+      },
+    })
+    const unnamedFilter = await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [null, accounts[0].address],
+    })
+
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (await getFilterChanges(publicClient, { filter: namedFilter })).length,
+    ).toBe(1)
+    expect(
+      (await getFilterChanges(publicClient, { filter: unnamedFilter })).length,
+    ).toBe(1)
+  })
+
+  test('args: multiple `to`', async () => {
+    const namedFilter = await createEventFilter(publicClient, {
+      event:
+        'Transfer(address indexed from, address indexed to, uint256 value)',
+      args: {
+        to: [accounts[0].address, accounts[1].address],
+      },
+    })
+    const unnamedFilter = await createEventFilter(publicClient, {
+      event: 'Transfer(address indexed, address indexed, uint256)',
+      args: [null, [accounts[0].address, accounts[1].address]],
+    })
+
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.usdcHolder,
+      functionName: 'transfer',
+      args: [accounts[0].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'transfer',
+      args: [accounts[1].address, 1n],
+    })
+    await writeContract(walletClient, {
+      ...usdcContractConfig,
+      from: address.vitalik,
+      functionName: 'approve',
+      args: [address.vitalik, 1n],
+    })
+    await mine(testClient, { blocks: 1 })
+
+    expect(
+      (await getFilterChanges(publicClient, { filter: namedFilter })).length,
+    ).toBe(3)
+    expect(
+      (await getFilterChanges(publicClient, { filter: unnamedFilter })).length,
+    ).toBe(3)
+  })
 })