viem 0.0.1-alpha.20 → 0.0.1-alpha.22

package/src/utils/ens/namehash.test.ts

@@ -0,0 +1,65 @@
+import { test, expect } from 'vitest'
+
+import { namehash } from './namehash'
+
+test.each([
+  {
+    name: '',
+    expected:
+      '0x0000000000000000000000000000000000000000000000000000000000000000',
+  },
+  {
+    name: 'eth',
+    expected:
+      '0x93cdeb708b7545dc668eb9280176169d1c33cfd8ed6f04690a0bcc88a93fc4ae',
+  },
+  {
+    name: 'alice.eth',
+    expected:
+      '0x787192fc5378cc32aa956ddfdedbf26b24e8d78e40109add0eea2c1a012c3dec',
+  },
+  {
+    name: 'iam.alice.eth',
+    expected:
+      '0x5bec9e288ed3df984a80a1ac48538a7f19370794d676506adfbddefad210775b',
+  },
+  {
+    name: 'awkweb.eth',
+    expected:
+      '0x52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c',
+  },
+  {
+    name: 'awkw𝝣b.eth',
+    expected:
+      '0x4e372358e2e47fdbba39e5ca56d412e6dc4216a260a733b1b5d8df0001d28202',
+  },
+  {
+    name: '\u{0061}wkweb.eth',
+    expected:
+      '0x52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c',
+  },
+  {
+    name: '\u{0061}wkw\u{0065}b.eth',
+    expected:
+      '0x52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c',
+  },
+  {
+    name: 'awkweb.eth',
+    //     ^ latin small "a"
+    expected:
+      '0x52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c',
+  },
+  {
+    name: 'awkweb.eth',
+    //         ^ latin small "e"
+    expected:
+      '0x52d0f5fbf348925621be297a61b88ec492ebbbdfa9477d82892e2786020ad61c',
+  },
+  {
+    name: 'ʘ‿ʘ.eth',
+    expected:
+      '0x61e4a7cb09f4b512f41d02fedcc851cf8e43161e1f34e4264d7d911bb6c9c7af',
+  },
+])("namehash('$name') -> '$expected'", ({ name, expected }) => {
+  expect(namehash(name)).toBe(expected)
+})

package/src/utils/ens/namehash.ts

@@ -0,0 +1,28 @@
+import { concat } from '../data'
+import { bytesToHex, stringToBytes } from '../encoding'
+import { keccak256 } from '../hash'
+import { normalize } from './normalize'
+
+/**
+ * @description Hashes ENS name
+ *
+ * @example
+ * namehash('wagmi-dev.eth')
+ * '0xf246651c1b9a6b141d19c2604e9a58f567973833990f830d882534a747801359'
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-137
+ * @see https://docs.ens.domains/contract-api-reference/name-processing#hashing-names
+ */
+export function namehash(name: string) {
+  let result = new Uint8Array(32).fill(0)
+  if (!name) return bytesToHex(result)
+
+  const labels = normalize(name).split('.')
+  // Iterate in reverse order building up hash
+  for (let i = labels.length - 1; i >= 0; i -= 1) {
+    const hashed = keccak256(stringToBytes(labels[i]), 'bytes')
+    result = keccak256(concat([result, hashed]), 'bytes')
+  }
+
+  return bytesToHex(result)
+}

package/src/utils/ens/normalize.bench.ts

@@ -0,0 +1,14 @@
+import { describe, bench } from 'vitest'
+import { ens_normalize } from '@adraffy/ens-normalize'
+
+import { normalize } from './normalize'
+
+describe('Normalize ENS name', () => {
+  bench('viem: `normalize`', () => {
+    normalize('\u{0061}wkw𝝣b.eth')
+  })
+
+  bench('@adraffy/ens-normalize: `ens_normalize`', () => {
+    ens_normalize('\u{0061}wkw𝝣b.eth')
+  })
+})

package/src/utils/ens/normalize.test.ts

@@ -0,0 +1,35 @@
+import { test, expect } from 'vitest'
+import { normalize } from './normalize'
+
+test.each([
+  { name: 'awkweb.eth', expected: 'awkweb.eth' },
+  { name: 'Awkweb.eth', expected: 'awkweb.eth' },
+  { name: '🖖.eth', expected: '🖖.eth' },
+  { name: 'awkw𝝣b.eth', expected: 'awkwξb.eth' },
+  { name: '\u{0061}wkweb.eth', expected: 'awkweb.eth' },
+  { name: '\u{0061}wkw\u{0065}b.eth', expected: 'awkweb.eth' },
+  { name: 'awkweb.eth', expected: 'awkweb.eth' },
+  //       ^ latin small "a"
+  { name: 'awkweb.eth', expected: 'awkweb.eth' },
+  //           ^ latin small "e"
+])("normalize('$name') -> '$expected'", ({ name, expected }) => {
+  expect(normalize(name)).toBe(expected)
+})
+
+test('invalid label extension', () => {
+  expect(() => normalize('34--A.eth')).toThrowErrorMatchingInlineSnapshot(
+    '"Failed to validate 34--a"',
+  )
+})
+
+test('illegal placement: leading combining mark', () => {
+  expect(() => normalize('\u{303}.eth')).toThrowErrorMatchingInlineSnapshot(
+    '"Label contains illegal character: 771"',
+  )
+})
+
+test('underscore allowed only at start', () => {
+  expect(() => normalize('a_b_c.eth')).toThrowErrorMatchingInlineSnapshot(
+    '"Illegal char _"',
+  )
+})

package/src/utils/ens/normalize.ts

@@ -0,0 +1,14 @@
+import { toUnicode } from 'idna-uts46-hx'
+
+/**
+ * @description Normalizes ENS name
+ *
+ * @example
+ * normalize('wagmi-dev.eth')
+ * 'wagmi-dev.eth'
+ *
+ * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names
+ */
+export function normalize(name: string) {
+  return toUnicode(name, { useStd3ASCII: true })
+}

package/src/utils/hash/keccak256.ts

@@ -6,11 +6,9 @@ import { encodeHex } from '../encoding'
 
 type To = 'hex' | 'bytes'
 
-export type Keccak256Hash<TTo extends To> = TTo extends 'bytes'
-  ? ByteArray
-  : TTo extends 'hex'
-  ? Hex
-  : never
+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,

package/src/utils/index.test.ts

@@ -75,6 +75,9 @@ test('exports utils', () => {
       "isBytes": [Function],
       "isHex": [Function],
       "keccak256": [Function],
+      "labelhash": [Function],
+      "namehash": [Function],
+      "normalize": [Function],
       "numberToBytes": [Function],
       "numberToHex": [Function],
       "pad": [Function],

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 export type {
   DecodeAbiArgs,
   DecodeErrorResultArgs,
+  DecodeErrorResultResponse,
   DecodeFunctionDataArgs,
   DecodeFunctionResultArgs,
   DecodeFunctionResultResponse,
@@ -10,6 +11,7 @@ export type {
   EncodeEventTopicsArgs,
   EncodeFunctionDataArgs,
   EncodeFunctionResultArgs,
+  GetAbiItemArgs,
 } from './abi'
 export {
   decodeAbi,
@@ -66,6 +68,8 @@ export {
   trim,
 } from './data'
 
+export { labelhash, namehash, normalize } from './ens'
+
 export type {
   BlockFormatter,
   ExtractFormatter,

package/src/utils/rpc.test.ts

@@ -70,8 +70,7 @@ describe('http', () => {
       Request body: {\\"method\\":\\"eth_wagmi\\"}
 
       Details: Method not found
-      Version: viem@1.0.2
-      Internal Error: {\\"code\\":-32601,\\"message\\":\\"Method not found\\"}"
+      Version: viem@1.0.2"
     `)
   })
 
@@ -706,8 +705,7 @@ describe('webSocket (subscription)', () => {
       Request body: {"method":"eth_subscribe","params":["fakeHeadz"]}
 
       Details: data did not match any variant of untagged enum EthRpcCall
-      Version: viem@1.0.2
-      Internal Error: {"code":-32602,"message":"data did not match any variant of untagged enum EthRpcCall"}]
+      Version: viem@1.0.2]
     `)
   })
 })
@@ -961,8 +959,7 @@ describe('webSocketAsync', () => {
       Request body: {\\"method\\":\\"wagmi_lol\\"}
 
       Details: data did not match any variant of untagged enum EthRpcCall
-      Version: viem@1.0.2
-      Internal Error: {\\"code\\":-32602,\\"message\\":\\"data did not match any variant of untagged enum EthRpcCall\\"}"
+      Version: viem@1.0.2"
     `,
     )
   })

package/src/utils/unit/formatUnit.bench.ts

@@ -1,7 +1,6 @@
 import { bench, describe } from 'vitest'
 import { utils } from 'ethers'
 import Web3 from 'web3'
-import { weiToEther } from 'essential-eth'
 
 import { formatUnit } from './formatUnit'
 
@@ -19,8 +18,4 @@ describe('Format Unit', () => {
   bench('web3.js: `toWei`', () => {
     web3.utils.toWei('40000000000000000000')
   })
-
-  bench('essential-eth: `etherToWei`', () => {
-    weiToEther('40000000000000000000')
-  })
 })

package/src/utils/unit/parseUnit.bench.ts

@@ -1,7 +1,6 @@
 import { bench, describe } from 'vitest'
 import { utils } from 'ethers'
 import Web3 from 'web3'
-import { etherToWei } from 'essential-eth'
 
 import { parseUnit } from './parseUnit'
 
@@ -19,8 +18,4 @@ describe('Parse Unit', () => {
   bench('web3.js: `fromWei`', () => {
     web3.utils.fromWei('40')
   })
-
-  bench('essential-eth: `etherToWei`', () => {
-    etherToWei('40')
-  })
 })