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

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

@@ -17,7 +17,7 @@ import {
   setIntervalMining,
   stopImpersonatingAccount,
 } from '../test'
-import { sendTransaction } from '../wallet'
+import { sendTransaction, writeContract } from '../wallet'
 import type { Log } from '../../types'
 import { createEventFilter } from './createEventFilter'
 import { getFilterLogs } from './getFilterLogs'
@@ -27,6 +27,9 @@ beforeAll(async () => {
   await impersonateAccount(testClient, {
     address: address.vitalik,
   })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 afterAll(async () => {
@@ -34,6 +37,9 @@ afterAll(async () => {
   await stopImpersonatingAccount(testClient, {
     address: address.vitalik,
   })
+  await stopImpersonatingAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 test('default', async () => {
@@ -84,6 +90,7 @@ describe('events', () => {
     await mine(testClient, { blocks: 1 })
 
     let logs = await getFilterLogs(publicClient, { filter })
+    console.log(logs[0])
     assertType<Log[]>(logs)
     expect(logs.length).toBe(2)
   })
@@ -100,5 +107,191 @@ describe('events', () => {
     expect(logs.length).toBe(1056)
   })
 
-  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 getFilterLogs(publicClient, { filter: namedFilter })).length,
+    ).toBe(2)
+    expect(
+      (await getFilterLogs(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 getFilterLogs(publicClient, { filter: namedFilter })).length,
+    ).toBe(3)
+    expect(
+      (await getFilterLogs(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 getFilterLogs(publicClient, { filter: namedFilter })).length,
+    ).toBe(1)
+    expect(
+      (await getFilterLogs(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 getFilterLogs(publicClient, { filter: namedFilter })).length,
+    ).toBe(3)
+    expect(
+      (await getFilterLogs(publicClient, { filter: unnamedFilter })).length,
+    ).toBe(3)
+  })
 })

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

@@ -17,7 +17,7 @@ import {
   setIntervalMining,
   stopImpersonatingAccount,
 } from '../test'
-import { sendTransaction } from '../wallet'
+import { sendTransaction, writeContract } from '../wallet'
 import type { Log } from '../../types'
 import { getLogs } from './getLogs'
 import { getBlock } from './getBlock'
@@ -27,6 +27,9 @@ beforeAll(async () => {
   await impersonateAccount(testClient, {
     address: address.vitalik,
   })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 afterAll(async () => {
@@ -34,6 +37,9 @@ afterAll(async () => {
   await stopImpersonatingAccount(testClient, {
     address: address.vitalik,
   })
+  await impersonateAccount(testClient, {
+    address: address.usdcHolder,
+  })
 })
 
 test('default', async () => {
@@ -103,5 +109,198 @@ describe('events', () => {
     expect(logs.length).toBe(118)
   })
 
-  test.todo('args: args')
+  test('args: singular `from`', async () => {
+    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 getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: address.vitalik,
+          },
+        })
+      ).length,
+    ).toBe(2)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [address.vitalik],
+        })
+      ).length,
+    ).toBe(2)
+  })
+
+  test('args: multiple `from`', async () => {
+    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 getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: [address.usdcHolder, address.vitalik],
+          },
+        })
+      ).length,
+    ).toBe(3)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            from: [address.usdcHolder, address.vitalik],
+          },
+        })
+      ).length,
+    ).toBe(3)
+  })
+
+  test('args: singular `to`', async () => {
+    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 getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            to: accounts[0].address,
+          },
+        })
+      ).length,
+    ).toBe(1)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [null, accounts[0].address],
+        })
+      ).length,
+    ).toBe(1)
+  })
+
+  test('args: multiple `to`', async () => {
+    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 getLogs(publicClient, {
+          event:
+            'Transfer(address indexed from, address indexed to, uint256 value)',
+          args: {
+            to: [accounts[0].address, accounts[1].address],
+          },
+        })
+      ).length,
+    ).toBe(3)
+    expect(
+      (
+        await getLogs(publicClient, {
+          event: 'Transfer(address indexed, address indexed, uint256)',
+          args: [null, [accounts[0].address, accounts[1].address]],
+        })
+      ).length,
+    ).toBe(3)
+  })
 })

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

@@ -10,7 +10,6 @@ test('exports actions', () => {
       "createContractEventFilter": [Function],
       "createEventFilter": [Function],
       "createPendingTransactionFilter": [Function],
-      "deployContract": [Function],
       "estimateGas": [Function],
       "getBalance": [Function],
       "getBlock": [Function],

package/src/actions/public/index.ts

@@ -25,12 +25,6 @@ export type {
   CreateContractEventFilterResponse,
 } from './createContractEventFilter'
 
-export { deployContract } from './deployContract'
-export type {
-  DeployContractArgs,
-  DeployContractResponse,
-} from './deployContract'
-
 export { estimateGas } from './estimateGas'
 export type { EstimateGasArgs, EstimateGasResponse } from './estimateGas'
 
@@ -106,7 +100,7 @@ export type {
 } from './getTransactionReceipt'
 
 export { multicall } from './multicall'
-export type { MulticallArgs } from './multicall'
+export type { MulticallArgs, MulticallResponse } from './multicall'
 
 export { readContract } from './readContract'
 export type {

package/src/actions/public/multicall.ts

@@ -8,16 +8,16 @@ import {
 import { Address, ContractConfig, Hex, MulticallContracts } from '../../types'
 import { MulticallResults } from '../../types/multicall'
 import {
+  EncodeFunctionDataArgs,
   decodeFunctionResult,
   encodeFunctionData,
-  EncodeFunctionDataArgs,
   getContractError,
 } from '../../utils'
 import { CallArgs } from './call'
 import { readContract } from './readContract'
 
 export type MulticallArgs<
-  TContracts extends ContractConfig[],
+  TContracts extends ContractConfig[] = ContractConfig[],
   TAllowFailure extends boolean = true,
 > = Pick<CallArgs, 'blockNumber' | 'blockTag'> & {
   allowFailure?: TAllowFailure
@@ -25,13 +25,18 @@ export type MulticallArgs<
   multicallAddress: Address
 }
 
+export type MulticallResponse<
+  TContracts extends ContractConfig[] = ContractConfig[],
+  TAllowFailure extends boolean = true,
+> = MulticallResults<TContracts, TAllowFailure>
+
 export async function multicall<
   TContracts extends ContractConfig[],
   TAllowFailure extends boolean = true,
 >(
   client: PublicClient,
   args: MulticallArgs<TContracts, TAllowFailure>,
-): Promise<MulticallResults<TContracts, TAllowFailure>> {
+): Promise<MulticallResponse<TContracts, TAllowFailure>> {
   const {
     allowFailure = true,
     blockNumber,

package/src/actions/public/simulateContract.ts

@@ -3,20 +3,17 @@ import { Abi, Narrow } from 'abitype'
 import type { PublicClient } from '../../clients'
 import { BaseError } from '../../errors'
 import type {
-  Address,
   Chain,
   ContractConfig,
-  ExtractArgsFromAbi,
   ExtractResultFromAbi,
-  ExtractFunctionNameFromAbi,
   GetValue,
 } from '../../types'
 import {
+  DecodeFunctionResultArgs,
   EncodeFunctionDataArgs,
   decodeFunctionResult,
   encodeFunctionData,
   getContractError,
-  DecodeFunctionResultArgs,
 } from '../../utils'
 import { WriteContractArgs } from '../wallet'
 import { call, CallArgs } from './call'

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

@@ -19,7 +19,7 @@ beforeAll(async () => {
     address: address.vitalik,
   })
   await impersonateAccount(testClient, {
-    address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+    address: address.usdcHolder,
   })
 })
 
@@ -28,7 +28,7 @@ afterAll(async () => {
     address: address.vitalik,
   })
   await stopImpersonatingAccount(testClient, {
-    address: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+    address: address.usdcHolder,
   })
 })
 
@@ -231,14 +231,14 @@ test('args: args', async () => {
     ...usdcContractConfig,
     eventName: 'Transfer',
     args: {
-      from: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+      from: address.usdcHolder,
     },
     onLogs: (logs_) => logs.push(logs_),
   })
 
   await writeContract(walletClient, {
     ...usdcContractConfig,
-    from: '0x5414d89a8bf7e99d732bc52f3e6a3ef461c0c078',
+    from: address.usdcHolder,
     functionName: 'transfer',
     args: [accounts[0].address, 1n],
   })

package/src/actions/{public → wallet}/deployContract.test.ts

@@ -5,8 +5,7 @@ import { parseEther } from '../../utils'
 import { mine, setBalance } from '../test'
 
 import { deployContract } from './deployContract'
-import { getTransactionReceipt } from './getTransactionReceipt'
-import { simulateContract } from './simulateContract'
+import { getTransactionReceipt } from '../public'
 
 test('default', async () => {
   const hash = await deployContract(walletClient, {

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

@@ -6,6 +6,7 @@ test('exports actions', () => {
   expect(actions).toMatchInlineSnapshot(`
     {
       "addChain": [Function],
+      "deployContract": [Function],
       "getAccounts": [Function],
       "getPermissions": [Function],
       "requestAccounts": [Function],

package/src/actions/wallet/index.ts

@@ -1,5 +1,11 @@
 export { addChain } from './addChain'
 
+export { deployContract } from './deployContract'
+export type {
+  DeployContractArgs,
+  DeployContractResponse,
+} from './deployContract'
+
 export { getAccounts } from './getAccounts'
 
 export { getPermissions } from './getPermissions'