viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/utils/encoding/decodeRlp.ts

@@ -1,121 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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')
-  })
-})