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

package/src/utils/encoding/decodeRlp.ts

@@ -0,0 +1,121 @@
+import {
+  DataLengthTooLongError,
+  DataLengthTooShortError,
+  InvalidHexValueError,
+  OffsetOutOfBoundsError,
+} from '../../errors'
+import type { ByteArray, Hex } from '../../types'
+import { trim } from '../data'
+import { bytesToNumber } from './decodeBytes'
+import { hexToBytes } from './encodeBytes'
+import { bytesToHex } from './encodeHex'
+import type { RecursiveArray } from './encodeRlp'
+
+type DecodeRlpResponse<TTo> = TTo extends 'bytes'
+  ? ByteArray
+  : TTo extends 'hex'
+  ? Hex
+  : never
+
+export function decodeRlp<TTo extends 'bytes' | 'hex'>(
+  value: ByteArray | Hex,
+  to: TTo,
+): RecursiveArray<DecodeRlpResponse<TTo>> {
+  const bytes = parse(value)
+  const [data, consumed] = rlpToBytes(bytes)
+  if (consumed < bytes.length)
+    throw new DataLengthTooLongError({
+      consumed,
+      length: bytes.length,
+    })
+  return format(data, to)
+}
+
+function parse(value: ByteArray | Hex) {
+  if (typeof value === 'string') {
+    if (value.length > 3 && value.length % 2 !== 0)
+      throw new InvalidHexValueError(value)
+    return hexToBytes(value)
+  }
+  return value
+}
+
+function format<TTo extends 'bytes' | 'hex'>(
+  bytes: RecursiveArray<ByteArray>,
+  to: TTo,
+): RecursiveArray<DecodeRlpResponse<TTo>> {
+  if (Array.isArray(bytes)) return bytes.map((b) => format(b, to))
+  return (
+    to === 'hex' ? trim(bytesToHex(bytes)) : bytes
+  ) as DecodeRlpResponse<TTo>
+}
+
+function rlpToBytes(
+  bytes: ByteArray,
+  offset = 0,
+): [result: RecursiveArray<ByteArray>, consumed: number] {
+  if (bytes.length === 0) return [new Uint8Array([]), 0]
+
+  const prefix = bytes[offset]
+
+  if (prefix <= 0x7f) return [new Uint8Array([bytes[offset]]), 1]
+
+  if (prefix <= 0xb7) {
+    const length = prefix - 0x80
+    const offset_ = offset + 1
+
+    if (offset_ + length > bytes.length)
+      throw new DataLengthTooShortError({
+        length: offset_ + length,
+        dataLength: bytes.length,
+      })
+
+    return [bytes.slice(offset_, offset_ + length), 1 + length]
+  }
+
+  if (prefix <= 0xbf) {
+    const lengthOfLength = prefix - 0xb7
+    const offset_ = offset + 1
+    const length = bytesToNumber(bytes.slice(offset_, offset_ + lengthOfLength))
+
+    if (offset_ + lengthOfLength + length > bytes.length)
+      throw new DataLengthTooShortError({
+        length: lengthOfLength + length,
+        dataLength: bytes.length - lengthOfLength,
+      })
+
+    return [
+      bytes.slice(offset_ + lengthOfLength, offset_ + lengthOfLength + length),
+      1 + lengthOfLength + length,
+    ]
+  }
+
+  let lengthOfLength = 0
+  let length = prefix - 0xc0
+  if (prefix > 0xf7) {
+    lengthOfLength = prefix - 0xf7
+    length = bytesToNumber(bytes.slice(offset + 1, offset + 1 + lengthOfLength))
+  }
+
+  let nextOffset = offset + 1 + lengthOfLength
+  if (nextOffset > bytes.length)
+    throw new DataLengthTooShortError({
+      length: nextOffset,
+      dataLength: bytes.length,
+    })
+
+  let consumed = 1 + lengthOfLength + length
+  let result = []
+  while (nextOffset < offset + consumed) {
+    const decoded = rlpToBytes(bytes, nextOffset)
+    result.push(decoded[0])
+    nextOffset += decoded[1]
+    if (nextOffset > offset + consumed)
+      throw new OffsetOutOfBoundsError({
+        nextOffset: nextOffset,
+        offset: offset + consumed,
+      })
+  }
+
+  return [result, consumed]
+}

package/src/utils/encoding/encodeBytes.bench.ts

@@ -0,0 +1,29 @@
+import { arrayify, toUtf8Bytes } from 'ethers/lib/utils'
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { hexToBytes, stringToBytes } from './encodeBytes'
+
+describe('Hex to Bytes', () => {
+  bench('viem: `hexToBytes`', () => {
+    hexToBytes('0x48656c6c6f20576f726c6421')
+  })
+
+  bench('ethers: `arrayify`', () => {
+    arrayify('0x48656c6c6f20576f726c6421')
+  })
+
+  bench('web3.js: `hexToBytes`', () => {
+    Web3.utils.hexToBytes('0x48656c6c6f20576f726c6421')
+  })
+})
+
+describe('String to Bytes', () => {
+  bench('viem: `stringToBytes`', () => {
+    stringToBytes('Hello world')
+  })
+
+  bench('ethers: `toUtf8Bytes`', () => {
+    toUtf8Bytes('Hello world')
+  })
+})