viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/utils/formatters/transactionReceipt.ts

@@ -0,0 +1,63 @@
+import type {
+  Chain,
+  Formatter,
+  Formatters,
+  RpcTransactionReceipt,
+  TransactionReceipt,
+} from '../../types'
+import { hexToNumber } from '../encoding'
+import { defineFormatter, ExtractFormatter, Formatted } from './format'
+import { formatLog } from './log'
+import { transactionType } from './transaction'
+
+export type TransactionReceiptFormatter<TChain extends Chain = Chain> =
+  ExtractFormatter<
+    TChain,
+    'transactionReceipt',
+    NonNullable<Formatters['transactionReceipt']>
+  >
+
+export type FormattedTransactionReceipt<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, TransactionReceipt>
+
+const statuses = {
+  '0x0': 'reverted',
+  '0x1': 'success',
+} as const
+
+export function formatTransactionReceipt(
+  transactionReceipt: Partial<RpcTransactionReceipt>,
+) {
+  return {
+    ...transactionReceipt,
+    blockNumber: transactionReceipt.blockNumber
+      ? BigInt(transactionReceipt.blockNumber)
+      : null,
+    cumulativeGasUsed: transactionReceipt.cumulativeGasUsed
+      ? BigInt(transactionReceipt.cumulativeGasUsed)
+      : null,
+    effectiveGasPrice: transactionReceipt.effectiveGasPrice
+      ? BigInt(transactionReceipt.effectiveGasPrice)
+      : null,
+    gasUsed: transactionReceipt.gasUsed
+      ? BigInt(transactionReceipt.gasUsed)
+      : null,
+    logs: transactionReceipt.logs
+      ? transactionReceipt.logs.map(formatLog)
+      : null,
+    transactionIndex: transactionReceipt.transactionIndex
+      ? hexToNumber(transactionReceipt.transactionIndex)
+      : null,
+    status: transactionReceipt.status
+      ? statuses[transactionReceipt.status]
+      : null,
+    type: transactionReceipt.type
+      ? transactionType[transactionReceipt.type]
+      : null,
+  } as TransactionReceipt
+}
+
+export const defineTransactionReceipt = defineFormatter({
+  format: formatTransactionReceipt,
+})

package/src/utils/formatters/transactionRequest.bench.ts

@@ -0,0 +1,29 @@
+import { providers } from 'ethers'
+import { bench, describe } from 'vitest'
+
+import type { TransactionRequest } from '../../types'
+
+import { formatTransactionRequest } from './transactionRequest'
+
+const receipt: TransactionRequest = {
+  data: '0x0000000000000000000000000000000000000000000000000000002b3b6fb3d0',
+  from: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+  gas: 69420420n,
+  nonce: 1,
+  to: '0xa5cc3c03994DB5b0d9A5eEdD10CabaB0813678AC',
+  value: 1n,
+  maxFeePerGas: 69n,
+  maxPriorityFeePerGas: 69n,
+}
+
+const formatter = new providers.Formatter()
+
+describe('Format Transaction Request', () => {
+  bench('viem: `formatTransactionReceipt`', () => {
+    formatTransactionRequest(receipt)
+  })
+
+  bench('ethers: `formatter.transactionRequest`', () => {
+    formatter.transactionRequest(receipt)
+  })
+})

package/src/utils/formatters/transactionRequest.test.ts

@@ -0,0 +1,237 @@
+import { expect, test } from 'vitest'
+
+import type {
+  TransactionRequest,
+  TransactionRequestEIP1559,
+  TransactionRequestEIP2930,
+  TransactionRequestLegacy,
+} from '../../types'
+
+import { formatTransactionRequest } from './transactionRequest'
+
+const base: TransactionRequest = {
+  data: '0x1',
+  from: '0x1',
+  gas: 69420420n,
+  nonce: 1,
+  to: '0x1',
+  value: 1n,
+}
+
+test('legacy transaction', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      gasPrice: 69n,
+    } as TransactionRequestLegacy),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": "0x45",
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('eip2930 transaction', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      accessList: [
+        {
+          address: '0x1',
+          storageKeys: ['0x1'],
+        },
+      ],
+      gasPrice: 69n,
+    } as TransactionRequestEIP2930),
+  ).toMatchInlineSnapshot(`
+    {
+      "accessList": [
+        {
+          "address": "0x1",
+          "storageKeys": [
+            "0x1",
+          ],
+        },
+      ],
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": "0x45",
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('eip1559 transaction', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      accessList: [
+        {
+          address: '0x1',
+          storageKeys: ['0x1'],
+        },
+      ],
+      maxFeePerGas: 69n,
+      maxPriorityFeePerGas: 69n,
+    } as TransactionRequestEIP1559),
+  ).toMatchInlineSnapshot(`
+    {
+      "accessList": [
+        {
+          "address": "0x1",
+          "storageKeys": [
+            "0x1",
+          ],
+        },
+      ],
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": "0x45",
+      "maxPriorityFeePerGas": "0x45",
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish gas', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      gas: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": undefined,
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish gasPrice', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      gasPrice: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish maxFeePerGas', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      maxFeePerGas: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish maxPriorityFeePerGas', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      maxPriorityFeePerGas: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish nonce', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      nonce: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": undefined,
+      "to": "0x1",
+      "value": "0x1",
+    }
+  `)
+})
+
+test('nullish value', () => {
+  expect(
+    formatTransactionRequest({
+      ...base,
+      value: undefined,
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "data": "0x1",
+      "from": "0x1",
+      "gas": "0x4234584",
+      "gasPrice": undefined,
+      "maxFeePerGas": undefined,
+      "maxPriorityFeePerGas": undefined,
+      "nonce": "0x1",
+      "to": "0x1",
+      "value": undefined,
+    }
+  `)
+})

package/src/utils/formatters/transactionRequest.ts

@@ -0,0 +1,56 @@
+import type {
+  Chain,
+  Formatter,
+  Formatters,
+  RpcTransactionRequest,
+  TransactionRequest,
+} from '../../types'
+import { defineFormatter, ExtractFormatter, Formatted } from './format'
+import { numberToHex } from '../encoding'
+
+export type TransactionRequestFormatter<TChain extends Chain = Chain> =
+  ExtractFormatter<
+    TChain,
+    'transactionRequest',
+    NonNullable<Formatters['transactionRequest']>
+  >
+
+export type FormattedTransactionRequest<
+  TFormatter extends Formatter | undefined = Formatter,
+> = Formatted<TFormatter, RpcTransactionRequest>
+
+export function formatTransactionRequest(
+  transactionRequest: Partial<TransactionRequest>,
+) {
+  return {
+    ...transactionRequest,
+    gas:
+      typeof transactionRequest.gas !== 'undefined'
+        ? numberToHex(transactionRequest.gas)
+        : undefined,
+    gasPrice:
+      typeof transactionRequest.gasPrice !== 'undefined'
+        ? numberToHex(transactionRequest.gasPrice)
+        : undefined,
+    maxFeePerGas:
+      typeof transactionRequest.maxFeePerGas !== 'undefined'
+        ? numberToHex(transactionRequest.maxFeePerGas)
+        : undefined,
+    maxPriorityFeePerGas:
+      typeof transactionRequest.maxPriorityFeePerGas !== 'undefined'
+        ? numberToHex(transactionRequest.maxPriorityFeePerGas)
+        : undefined,
+    nonce:
+      typeof transactionRequest.nonce !== 'undefined'
+        ? numberToHex(transactionRequest.nonce)
+        : undefined,
+    value:
+      typeof transactionRequest.value !== 'undefined'
+        ? numberToHex(transactionRequest.value)
+        : undefined,
+  } as RpcTransactionRequest
+}
+
+export const defineTransactionRequest = defineFormatter({
+  format: formatTransactionRequest,
+})

package/src/utils/hash/getEventSignature.test.ts

@@ -0,0 +1,61 @@
+import { expect, test } from 'vitest'
+
+import { getEventSignature } from './getEventSignature'
+
+test('creates event signature', () => {
+  expect(getEventSignature('Transfer(address,address,uint256)')).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(
+    getEventSignature(
+      'Transfer(address indexed from, address indexed to, uint256 amount)',
+    ),
+  ).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(
+    getEventSignature(
+      'event Transfer(address indexed from, address indexed to, uint256 amount)',
+    ),
+  ).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(getEventSignature('drawNumber()')).toEqual(
+    '0xd80ffb20d597d029eb14b9def3d14da7e6d862943d830906185b1b0b576d8f26',
+  )
+  expect(getEventSignature('drawNumber( )')).toEqual(
+    '0xd80ffb20d597d029eb14b9def3d14da7e6d862943d830906185b1b0b576d8f26',
+  )
+  expect(
+    getEventSignature(
+      'ProcessedAccountDividendTracker(uint256,uint256,uint256,uint256,bool,uint256,address)',
+    ),
+  ).toEqual(
+    '0x4a73985b7c9415b88fbbfbb5e2fb377c08586d96f5c42646ecef7e3717587f6a',
+  )
+  expect(
+    getEventSignature(
+      'ProcessedAccountDividendTracker(uint256 indexed foo, uint256 indexed bar, uint256 baz, uint256 a, bool b, uint256 c, address d)',
+    ),
+  ).toEqual(
+    '0x4a73985b7c9415b88fbbfbb5e2fb377c08586d96f5c42646ecef7e3717587f6a',
+  )
+  expect(
+    getEventSignature('BlackListMultipleAddresses(address[], bool)'),
+  ).toEqual(
+    '0x170cd84eddb1952bf41adcce9be0e44b66ff38f07cddda1cf64d32708742bd2d',
+  )
+  expect(getEventSignature('checkBatch(bytes)')).toEqual(
+    '0x9b6f373667d9cf576e3a17e6aa047c5d864fcb7f41836b11613215db446698d8',
+  )
+  expect(
+    getEventSignature(
+      'Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)',
+    ),
+  ).toBe('0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925')
+  expect(
+    getEventSignature(
+      'ApprovalForAll(address indexed owner, address indexed operator, bool approved)',
+    ),
+  ).toBe('0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31')
+})

package/src/utils/hash/getEventSignature.ts

@@ -0,0 +1,4 @@
+import { EventDefinition } from '../../types'
+import { hashFunction } from './hashFunction'
+
+export const getEventSignature = (event: EventDefinition) => hashFunction(event)

package/src/utils/hash/getFunctionSignature.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from 'vitest'
+
+import { getFunctionSignature } from './getFunctionSignature'
+
+test('creates function signature', () => {
+  expect(getFunctionSignature('_compound(uint256,uint256,uint256)')).toEqual(
+    '0xf4fbb312',
+  )
+  expect(
+    getFunctionSignature('function _compound(uint256 a, uint256 b, uint256 c)'),
+  ).toEqual('0xf4fbb312')
+  expect(getFunctionSignature('function ownerOf(uint256 tokenId)')).toEqual(
+    '0x6352211e',
+  )
+  expect(getFunctionSignature('ownerOf(uint256)')).toEqual('0x6352211e')
+  expect(
+    getFunctionSignature('processInvestment(address,uint256,bool)'),
+  ).toEqual('0xcf4b8f61')
+  expect(getFunctionSignature('processAccount(uint256 , address )')).toEqual(
+    '0x73933128',
+  )
+})

package/src/utils/hash/getFunctionSignature.ts

@@ -0,0 +1,5 @@
+import { slice } from '../data'
+import { hashFunction } from './hashFunction'
+
+export const getFunctionSignature = (fn: string) =>
+  slice(hashFunction(fn), 0, 4)

package/src/utils/hash/hashFunction.test.ts

@@ -0,0 +1,65 @@
+import { expect, test } from 'vitest'
+
+import { hashFunction } from './hashFunction'
+
+test('hashes functions', () => {
+  expect(hashFunction('Transfer(address,address,uint256)')).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(
+    hashFunction(
+      'Transfer(address indexed from, address indexed to, uint256 amount)',
+    ),
+  ).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(
+    hashFunction(
+      'event Transfer(address indexed from, address indexed to, uint256 amount)',
+    ),
+  ).toEqual(
+    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+  )
+  expect(hashFunction('drawNumber()')).toEqual(
+    '0xd80ffb20d597d029eb14b9def3d14da7e6d862943d830906185b1b0b576d8f26',
+  )
+  expect(hashFunction('drawNumber( )')).toEqual(
+    '0xd80ffb20d597d029eb14b9def3d14da7e6d862943d830906185b1b0b576d8f26',
+  )
+  expect(
+    hashFunction(
+      'ProcessedAccountDividendTracker(uint256,uint256,uint256,uint256,bool,uint256,address)',
+    ),
+  ).toEqual(
+    '0x4a73985b7c9415b88fbbfbb5e2fb377c08586d96f5c42646ecef7e3717587f6a',
+  )
+  expect(
+    hashFunction(
+      'ProcessedAccountDividendTracker(uint256 indexed foo, uint256 indexed bar, uint256 baz, uint256 a, bool b, uint256 c, address d)',
+    ),
+  ).toEqual(
+    '0x4a73985b7c9415b88fbbfbb5e2fb377c08586d96f5c42646ecef7e3717587f6a',
+  )
+  expect(hashFunction('BlackListMultipleAddresses(address[], bool)')).toEqual(
+    '0x170cd84eddb1952bf41adcce9be0e44b66ff38f07cddda1cf64d32708742bd2d',
+  )
+  expect(hashFunction('checkBatch(bytes)')).toEqual(
+    '0x9b6f373667d9cf576e3a17e6aa047c5d864fcb7f41836b11613215db446698d8',
+  )
+  expect(
+    hashFunction(
+      'Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)',
+    ),
+  ).toBe('0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925')
+  expect(
+    hashFunction(
+      'ApprovalForAll(address indexed owner, address indexed operator, bool approved)',
+    ),
+  ).toBe('0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31')
+  expect(hashFunction('function balanceOf(address owner)')).toBe(
+    '0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be',
+  )
+  expect(hashFunction('function ownerOf(uint256 tokenId)')).toBe(
+    '0x6352211e6566aa027e75ac9dbf2423197fbd9b82b9d981a3ab367d355866aa1c',
+  )
+})

package/src/utils/hash/hashFunction.ts

@@ -0,0 +1,12 @@
+import { encodeBytes } from '../encoding'
+import { extractFunctionName, extractFunctionParams } from '../contract'
+import { keccak256 } from './keccak256'
+
+const hash = (value: string) => keccak256(encodeBytes(value))
+
+export function hashFunction(def: string) {
+  const name = extractFunctionName(def)
+  const params = extractFunctionParams(def)
+  if (!params || params.length === 0) return hash(def.replace(/ /g, ''))
+  return hash(`${name}(${params.map(({ type }) => type).join(',')})`)
+}

package/src/utils/hash/index.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "getEventSignature": [Function],
+      "getFunctionSignature": [Function],
+      "keccak256": [Function],
+    }
+  `)
+})

package/src/utils/hash/index.ts

@@ -0,0 +1,5 @@
+export { getEventSignature } from './getEventSignature'
+
+export { getFunctionSignature } from './getFunctionSignature'
+
+export { keccak256 } from './keccak256'

package/src/utils/hash/keccak256.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from 'vitest'
+
+import { keccak256 } from './keccak256'
+
+test('to hex', () => {
+  expect(
+    keccak256(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot(
+    '"0x3ea2f1d0abf3fc66cf29eebb70cbd4e7fe762ef8a09bcc06c8edf641230afec0"',
+  )
+})
+
+test('to bytes', () => {
+  expect(
+    keccak256(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+      'bytes',
+    ),
+  ).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      62,
+      162,
+      241,
+      208,
+      171,
+      243,
+      252,
+      102,
+      207,
+      41,
+      238,
+      187,
+      112,
+      203,
+      212,
+      231,
+      254,
+      118,
+      46,
+      248,
+      160,
+      155,
+      204,
+      6,
+      200,
+      237,
+      246,
+      65,
+      35,
+      10,
+      254,
+      192,
+    ]
+  `,
+  )
+})

package/src/utils/hash/keccak256.ts

@@ -0,0 +1,21 @@
+import { keccak_256 } from '@noble/hashes/sha3'
+
+import type { ByteArray, Hex } from '../../types'
+
+import { encodeHex } from '../encoding'
+
+type To = 'hex' | 'bytes'
+
+export type Keccak256Hash<TTo extends To> =
+  | (TTo extends 'bytes' ? ByteArray : never)
+  | (TTo extends 'hex' ? Hex : never)
+
+export function keccak256<TTo extends To = 'hex'>(
+  value: ByteArray,
+  to_?: TTo,
+): Keccak256Hash<TTo> {
+  const to = to_ || 'hex'
+  const bytes = keccak_256(value)
+  if (to === 'bytes') return bytes as Keccak256Hash<TTo>
+  return encodeHex(bytes) as Keccak256Hash<TTo>
+}