viem 0.0.1-alpha.14 → 0.0.1-alpha.16

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,47 @@
+import type { Chain, Formatter, Formatters } from '../../chains'
+import type { RpcTransactionRequest, TransactionRequest } from '../../types'
+import type { 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
+}

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 { hashFunction } from './hashFunction'
+
+export const getEventSignature = (event: `${string}(${string})`) =>
+  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,23 @@
+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
+  : 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>
+}

package/src/utils/index.test.ts

@@ -0,0 +1,87 @@
+import { expect, test } from 'vitest'
+
+import * as utils from './index'
+
+test('exports utils', () => {
+  expect(utils).toMatchInlineSnapshot(`
+    {
+      "boolToBytes": [Function],
+      "boolToHex": [Function],
+      "buildRequest": [Function],
+      "bytesToBigint": [Function],
+      "bytesToBool": [Function],
+      "bytesToHex": [Function],
+      "bytesToNumber": [Function],
+      "bytesToString": [Function],
+      "decodeAbi": [Function],
+      "decodeBytes": [Function],
+      "decodeErrorResult": [Function],
+      "decodeFunctionData": [Function],
+      "decodeFunctionResult": [Function],
+      "decodeHex": [Function],
+      "decodeRlp": [Function],
+      "encodeAbi": [Function],
+      "encodeBytes": [Function],
+      "encodeDeployData": [Function],
+      "encodeErrorResult": [Function],
+      "encodeEventTopics": [Function],
+      "encodeFunctionData": [Function],
+      "encodeFunctionResult": [Function],
+      "encodeHex": [Function],
+      "encodeRlp": [Function],
+      "extract": [Function],
+      "extractFunctionName": [Function],
+      "extractFunctionParams": [Function],
+      "extractFunctionParts": [Function],
+      "extractFunctionType": [Function],
+      "format": [Function],
+      "formatAbiItemWithArgs": [Function],
+      "formatAbiItemWithParams": [Function],
+      "formatBlock": [Function],
+      "formatEther": [Function],
+      "formatGwei": [Function],
+      "formatTransaction": [Function],
+      "formatTransactionRequest": [Function],
+      "formatUnit": [Function],
+      "getAbiItem": [Function],
+      "getAddress": [Function],
+      "getContractAddress": [Function],
+      "getContractError": [Function],
+      "getCreate2Address": [Function],
+      "getCreateAddress": [Function],
+      "getEventSignature": [Function],
+      "getFunctionSignature": [Function],
+      "hexToBigInt": [Function],
+      "hexToBool": [Function],
+      "hexToBytes": [Function],
+      "hexToNumber": [Function],
+      "hexToString": [Function],
+      "isAddress": [Function],
+      "isAddressEqual": [Function],
+      "isBytes": [Function],
+      "isHex": [Function],
+      "keccak256": [Function],
+      "numberToBytes": [Function],
+      "numberToHex": [Function],
+      "pad": [Function],
+      "padBytes": [Function],
+      "padHex": [Function],
+      "parseEther": [Function],
+      "parseGwei": [Function],
+      "parseUnit": [Function],
+      "rpc": {
+        "http": [Function],
+        "webSocket": [Function],
+        "webSocketAsync": [Function],
+      },
+      "size": [Function],
+      "slice": [Function],
+      "sliceBytes": [Function],
+      "sliceHex": [Function],
+      "stringToBytes": [Function],
+      "stringToHex": [Function],
+      "stringify": [Function],
+      "trim": [Function],
+    }
+  `)
+})