etherjs-util 7.1.5

package/src/bytes.ts

@@ -0,0 +1,334 @@
+import { BN } from './externals'
+import { stripHexPrefix, padToEven, isHexString, isHexPrefixed } from './internal'
+import {
+  PrefixedHexString,
+  TransformableToArray,
+  TransformableToBuffer,
+  NestedBufferArray,
+  NestedUint8Array,
+} from './types'
+import { assertIsBuffer, assertIsArray, assertIsHexString } from './helpers'
+
+/**
+ * Converts a `Number` into a hex `String`
+ * @param {Number} i
+ * @return {String}
+ */
+export const intToHex = function (i: number) {
+  if (!Number.isSafeInteger(i) || i < 0) {
+    throw new Error(`Received an invalid integer type: ${i}`)
+  }
+  return `0x${i.toString(16)}`
+}
+
+/**
+ * Converts an `Number` to a `Buffer`
+ * @param {Number} i
+ * @return {Buffer}
+ */
+export const intToBuffer = function (i: number) {
+  const hex = intToHex(i)
+  return Buffer.from(padToEven(hex.slice(2)), 'hex')
+}
+
+/**
+ * Returns a buffer filled with 0s.
+ * @param bytes the number of bytes the buffer should be
+ */
+export const zeros = function (bytes: number): Buffer {
+  return Buffer.allocUnsafe(bytes).fill(0)
+}
+
+/**
+ * Pads a `Buffer` with zeros till it has `length` bytes.
+ * Truncates the beginning or end of input if its length exceeds `length`.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @param right whether to start padding form the left or right
+ * @return (Buffer)
+ */
+const setLength = function (msg: Buffer, length: number, right: boolean) {
+  const buf = zeros(length)
+  if (right) {
+    if (msg.length < length) {
+      msg.copy(buf)
+      return buf
+    }
+    return msg.slice(0, length)
+  } else {
+    if (msg.length < length) {
+      msg.copy(buf, length - msg.length)
+      return buf
+    }
+    return msg.slice(-length)
+  }
+}
+
+/**
+ * Left Pads a `Buffer` with leading zeros till it has `length` bytes.
+ * Or it truncates the beginning if it exceeds.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @return (Buffer)
+ */
+export const setLengthLeft = function (msg: Buffer, length: number) {
+  assertIsBuffer(msg)
+  return setLength(msg, length, false)
+}
+
+/**
+ * Right Pads a `Buffer` with trailing zeros till it has `length` bytes.
+ * it truncates the end if it exceeds.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @return (Buffer)
+ */
+export const setLengthRight = function (msg: Buffer, length: number) {
+  assertIsBuffer(msg)
+  return setLength(msg, length, true)
+}
+
+/**
+ * Trims leading zeros from a `Buffer`, `String` or `Number[]`.
+ * @param a (Buffer|Array|String)
+ * @return (Buffer|Array|String)
+ */
+const stripZeros = function (a: any): Buffer | number[] | string {
+  let first = a[0]
+  while (a.length > 0 && first.toString() === '0') {
+    a = a.slice(1)
+    first = a[0]
+  }
+  return a
+}
+
+/**
+ * Trims leading zeros from a `Buffer`.
+ * @param a (Buffer)
+ * @return (Buffer)
+ */
+export const unpadBuffer = function (a: Buffer): Buffer {
+  assertIsBuffer(a)
+  return stripZeros(a) as Buffer
+}
+
+/**
+ * Trims leading zeros from an `Array` (of numbers).
+ * @param a (number[])
+ * @return (number[])
+ */
+export const unpadArray = function (a: number[]): number[] {
+  assertIsArray(a)
+  return stripZeros(a) as number[]
+}
+
+/**
+ * Trims leading zeros from a hex-prefixed `String`.
+ * @param a (String)
+ * @return (String)
+ */
+export const unpadHexString = function (a: string): string {
+  assertIsHexString(a)
+  a = stripHexPrefix(a)
+  return stripZeros(a) as string
+}
+
+export type ToBufferInputTypes =
+  | PrefixedHexString
+  | number
+  | BN
+  | Buffer
+  | Uint8Array
+  | number[]
+  | TransformableToArray
+  | TransformableToBuffer
+  | null
+  | undefined
+
+/**
+ * Attempts to turn a value into a `Buffer`.
+ * Inputs supported: `Buffer`, `String` (hex-prefixed), `Number`, null/undefined, `BN` and other objects
+ * with a `toArray()` or `toBuffer()` method.
+ * @param v the value
+ */
+export const toBuffer = function (v: ToBufferInputTypes): Buffer {
+  if (v === null || v === undefined) {
+    return Buffer.allocUnsafe(0)
+  }
+
+  if (Buffer.isBuffer(v)) {
+    return Buffer.from(v)
+  }
+
+  if (Array.isArray(v) || v instanceof Uint8Array) {
+    return Buffer.from(v as Uint8Array)
+  }
+
+  if (typeof v === 'string') {
+    if (!isHexString(v)) {
+      throw new Error(
+        `Cannot convert string to buffer. toBuffer only supports 0x-prefixed hex strings and this string was given: ${v}`
+      )
+    }
+    return Buffer.from(padToEven(stripHexPrefix(v)), 'hex')
+  }
+
+  if (typeof v === 'number') {
+    return intToBuffer(v)
+  }
+
+  if (BN.isBN(v)) {
+    if (v.isNeg()) {
+      throw new Error(`Cannot convert negative BN to buffer. Given: ${v}`)
+    }
+    return v.toArrayLike(Buffer)
+  }
+
+  if (v.toArray) {
+    // converts a BN to a Buffer
+    return Buffer.from(v.toArray())
+  }
+
+  if (v.toBuffer) {
+    return Buffer.from(v.toBuffer())
+  }
+
+  throw new Error('invalid type')
+}
+
+/**
+ * Converts a `Buffer` to a `Number`.
+ * @param buf `Buffer` object to convert
+ * @throws If the input number exceeds 53 bits.
+ */
+export const bufferToInt = function (buf: Buffer): number {
+  return new BN(toBuffer(buf)).toNumber()
+}
+
+/**
+ * Converts a `Buffer` into a `0x`-prefixed hex `String`.
+ * @param buf `Buffer` object to convert
+ */
+export const bufferToHex = function (buf: Buffer): string {
+  buf = toBuffer(buf)
+  return '0x' + buf.toString('hex')
+}
+
+/**
+ * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.
+ * @param num Signed integer value
+ */
+export const fromSigned = function (num: Buffer): BN {
+  return new BN(num).fromTwos(256)
+}
+
+/**
+ * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.
+ * @param num
+ */
+export const toUnsigned = function (num: BN): Buffer {
+  return Buffer.from(num.toTwos(256).toArray())
+}
+
+/**
+ * Adds "0x" to a given `String` if it does not already start with "0x".
+ */
+export const addHexPrefix = function (str: string): string {
+  if (typeof str !== 'string') {
+    return str
+  }
+
+  return isHexPrefixed(str) ? str : '0x' + str
+}
+
+/**
+ * Returns the utf8 string representation from a hex string.
+ *
+ * Examples:
+ *
+ * Input 1: '657468657265756d000000000000000000000000000000000000000000000000'
+ * Input 2: '657468657265756d'
+ * Input 3: '000000000000000000000000000000000000000000000000657468657265756d'
+ *
+ * Output (all 3 input variants): 'ethereum'
+ *
+ * Note that this method is not intended to be used with hex strings
+ * representing quantities in both big endian or little endian notation.
+ *
+ * @param string Hex string, should be `0x` prefixed
+ * @return Utf8 string
+ */
+export const toUtf8 = function (hex: string): string {
+  const zerosRegexp = /^(00)+|(00)+$/g
+  hex = stripHexPrefix(hex)
+  if (hex.length % 2 !== 0) {
+    throw new Error('Invalid non-even hex string input for toUtf8() provided')
+  }
+  const bufferVal = Buffer.from(hex.replace(zerosRegexp, ''), 'hex')
+
+  return bufferVal.toString('utf8')
+}
+
+/**
+ * Converts a `Buffer` or `Array` to JSON.
+ * @param ba (Buffer|Array)
+ * @return (Array|String|null)
+ */
+export const baToJSON = function (ba: any): any {
+  if (Buffer.isBuffer(ba)) {
+    return `0x${ba.toString('hex')}`
+  } else if (ba instanceof Array) {
+    const array = []
+    for (let i = 0; i < ba.length; i++) {
+      array.push(baToJSON(ba[i]))
+    }
+    return array
+  }
+}
+
+/**
+ * Checks provided Buffers for leading zeroes and throws if found.
+ *
+ * Examples:
+ *
+ * Valid values: 0x1, 0x, 0x01, 0x1234
+ * Invalid values: 0x0, 0x00, 0x001, 0x0001
+ *
+ * Note: This method is useful for validating that RLP encoded integers comply with the rule that all
+ * integer values encoded to RLP must be in the most compact form and contain no leading zero bytes
+ * @param values An object containing string keys and Buffer values
+ * @throws if any provided value is found to have leading zero bytes
+ */
+export const validateNoLeadingZeroes = function (values: { [key: string]: Buffer | undefined }) {
+  for (const [k, v] of Object.entries(values)) {
+    if (v !== undefined && v.length > 0 && v[0] === 0) {
+      throw new Error(`${k} cannot have leading zeroes, received: ${v.toString('hex')}`)
+    }
+  }
+}
+
+/**
+ * Converts a {@link Uint8Array} or {@link NestedUint8Array} to {@link Buffer} or {@link NestedBufferArray}
+ */
+export function arrToBufArr(arr: Uint8Array): Buffer
+export function arrToBufArr(arr: NestedUint8Array): NestedBufferArray
+export function arrToBufArr(arr: Uint8Array | NestedUint8Array): Buffer | NestedBufferArray
+export function arrToBufArr(arr: Uint8Array | NestedUint8Array): Buffer | NestedBufferArray {
+  if (!Array.isArray(arr)) {
+    return Buffer.from(arr)
+  }
+  return arr.map((a) => arrToBufArr(a))
+}
+
+/**
+ * Converts a {@link Buffer} or {@link NestedBufferArray} to {@link Uint8Array} or {@link NestedUint8Array}
+ */
+export function bufArrToArr(arr: Buffer): Uint8Array
+export function bufArrToArr(arr: NestedBufferArray): NestedUint8Array
+export function bufArrToArr(arr: Buffer | NestedBufferArray): Uint8Array | NestedUint8Array
+export function bufArrToArr(arr: Buffer | NestedBufferArray): Uint8Array | NestedUint8Array {
+  if (!Array.isArray(arr)) {
+    return Uint8Array.from(arr ?? [])
+  }
+  return arr.map((a) => bufArrToArr(a))
+}

package/src/constants.ts

@@ -0,0 +1,54 @@
+import { Buffer } from 'buffer'
+import { BN } from './externals'
+
+/**
+ * 2^64-1
+ */
+export const MAX_UINT64 = new BN('ffffffffffffffff', 16)
+
+/**
+ * The max integer that the evm can handle (2^256-1)
+ */
+export const MAX_INTEGER = new BN(
+  'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
+  16
+)
+
+/**
+ * 2^256
+ */
+export const TWO_POW256 = new BN(
+  '10000000000000000000000000000000000000000000000000000000000000000',
+  16
+)
+
+/**
+ * Keccak-256 hash of null
+ */
+export const KECCAK256_NULL_S = 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
+
+/**
+ * Keccak-256 hash of null
+ */
+export const KECCAK256_NULL = Buffer.from(KECCAK256_NULL_S, 'hex')
+
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+export const KECCAK256_RLP_ARRAY_S =
+  '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347'
+
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+export const KECCAK256_RLP_ARRAY = Buffer.from(KECCAK256_RLP_ARRAY_S, 'hex')
+
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+export const KECCAK256_RLP_S = '56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421'
+
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+export const KECCAK256_RLP = Buffer.from(KECCAK256_RLP_S, 'hex')

package/src/externals.ts

@@ -0,0 +1,18 @@
+/**
+ * Re-exports commonly used modules:
+ * * Exports [`BN`](https://github.com/indutny/bn.js), [`rlp`](https://github.com/ethereumjs/rlp).
+ * @packageDocumentation
+ */
+
+import BN from 'bn.js'
+import * as rlp from 'rlp'
+
+/**
+ * [`BN`](https://github.com/indutny/bn.js)
+ */
+export { BN }
+
+/**
+ * [`rlp`](https://github.com/ethereumjs/rlp)
+ */
+export { rlp }

package/src/hash.ts

@@ -0,0 +1,159 @@
+import { keccak224, keccak384, keccak256 as k256, keccak512 } from 'ethereum-cryptography/keccak'
+const createHash = require('create-hash')
+import { rlp } from './externals'
+import { toBuffer, setLengthLeft } from './bytes'
+import { assertIsString, assertIsBuffer, assertIsArray, assertIsHexString } from './helpers'
+
+/**
+ * Creates Keccak hash of a Buffer input
+ * @param a The input data (Buffer)
+ * @param bits (number = 256) The Keccak width
+ */
+export const keccak = function (a: Buffer, bits: number = 256): Buffer {
+  assertIsBuffer(a)
+  switch (bits) {
+    case 224: {
+      return keccak224(a)
+    }
+    case 256: {
+      return k256(a)
+    }
+    case 384: {
+      return keccak384(a)
+    }
+    case 512: {
+      return keccak512(a)
+    }
+    default: {
+      throw new Error(`Invald algorithm: keccak${bits}`)
+    }
+  }
+}
+
+/**
+ * Creates Keccak-256 hash of the input, alias for keccak(a, 256).
+ * @param a The input data (Buffer)
+ */
+export const keccak256 = function (a: Buffer): Buffer {
+  return keccak(a)
+}
+
+/**
+ * Creates Keccak hash of a utf-8 string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+export const keccakFromString = function (a: string, bits: number = 256) {
+  assertIsString(a)
+  const buf = Buffer.from(a, 'utf8')
+  return keccak(buf, bits)
+}
+
+/**
+ * Creates Keccak hash of an 0x-prefixed string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+export const keccakFromHexString = function (a: string, bits: number = 256) {
+  assertIsHexString(a)
+  return keccak(toBuffer(a), bits)
+}
+
+/**
+ * Creates Keccak hash of a number array input
+ * @param a The input data (number[])
+ * @param bits (number = 256) The Keccak width
+ */
+export const keccakFromArray = function (a: number[], bits: number = 256) {
+  assertIsArray(a)
+  return keccak(toBuffer(a), bits)
+}
+
+/**
+ * Creates SHA256 hash of an input.
+ * @param  a The input data (Buffer|Array|String)
+ */
+const _sha256 = function (a: any): Buffer {
+  a = toBuffer(a)
+  return createHash('sha256').update(a).digest()
+}
+
+/**
+ * Creates SHA256 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ */
+export const sha256 = function (a: Buffer): Buffer {
+  assertIsBuffer(a)
+  return _sha256(a)
+}
+
+/**
+ * Creates SHA256 hash of a string input.
+ * @param a The input data (string)
+ */
+export const sha256FromString = function (a: string): Buffer {
+  assertIsString(a)
+  return _sha256(a)
+}
+
+/**
+ * Creates SHA256 hash of a number[] input.
+ * @param a The input data (number[])
+ */
+export const sha256FromArray = function (a: number[]): Buffer {
+  assertIsArray(a)
+  return _sha256(a)
+}
+
+/**
+ * Creates RIPEMD160 hash of the input.
+ * @param a The input data (Buffer|Array|String|Number)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+const _ripemd160 = function (a: any, padded: boolean): Buffer {
+  a = toBuffer(a)
+  const hash = createHash('rmd160').update(a).digest()
+  if (padded === true) {
+    return setLengthLeft(hash, 32)
+  } else {
+    return hash
+  }
+}
+
+/**
+ * Creates RIPEMD160 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export const ripemd160 = function (a: Buffer, padded: boolean): Buffer {
+  assertIsBuffer(a)
+  return _ripemd160(a, padded)
+}
+
+/**
+ * Creates RIPEMD160 hash of a string input.
+ * @param a The input data (String)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export const ripemd160FromString = function (a: string, padded: boolean): Buffer {
+  assertIsString(a)
+  return _ripemd160(a, padded)
+}
+
+/**
+ * Creates RIPEMD160 hash of a number[] input.
+ * @param a The input data (number[])
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export const ripemd160FromArray = function (a: number[], padded: boolean): Buffer {
+  assertIsArray(a)
+  return _ripemd160(a, padded)
+}
+
+/**
+ * Creates SHA-3 hash of the RLP encoded version of the input.
+ * @param a The input data
+ */
+export const rlphash = function (a: rlp.Input): Buffer {
+  return keccak(rlp.encode(a))
+}

package/src/helpers.ts

@@ -0,0 +1,45 @@
+import { isHexString } from './internal'
+
+/**
+ * Throws if a string is not hex prefixed
+ * @param {string} input string to check hex prefix of
+ */
+export const assertIsHexString = function (input: string): void {
+  if (!isHexString(input)) {
+    const msg = `This method only supports 0x-prefixed hex strings but input was: ${input}`
+    throw new Error(msg)
+  }
+}
+
+/**
+ * Throws if input is not a buffer
+ * @param {Buffer} input value to check
+ */
+export const assertIsBuffer = function (input: Buffer): void {
+  if (!Buffer.isBuffer(input)) {
+    const msg = `This method only supports Buffer but input was: ${input}`
+    throw new Error(msg)
+  }
+}
+
+/**
+ * Throws if input is not an array
+ * @param {number[]} input value to check
+ */
+export const assertIsArray = function (input: number[]): void {
+  if (!Array.isArray(input)) {
+    const msg = `This method only supports number arrays but input was: ${input}`
+    throw new Error(msg)
+  }
+}
+
+/**
+ * Throws if input is not a string
+ * @param {string} input value to check
+ */
+export const assertIsString = function (input: string): void {
+  if (typeof input !== 'string') {
+    const msg = `This method only supports strings but input was: ${input}`
+    throw new Error(msg)
+  }
+}

package/src/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Constants
+ */
+export * from './constants'
+
+/**
+ * Account class and helper functions
+ */
+export * from './account'
+
+/**
+ * Address type
+ */
+export * from './address'
+
+/**
+ * Hash functions
+ */
+export * from './hash'
+
+/**
+ * ECDSA signature
+ */
+export * from './signature'
+
+/**
+ * Utilities for manipulating Buffers, byte arrays, etc.
+ */
+export * from './bytes'
+
+/**
+ * Function for definining properties on an object
+ */
+export * from './object'
+
+/**
+ * External exports (BN, rlp)
+ */
+export * from './externals'
+
+/**
+ * Helpful TypeScript types
+ */
+export * from './types'
+
+/**
+ * Export ethjs-util methods
+ */
+export {
+  isHexPrefixed,
+  stripHexPrefix,
+  padToEven,
+  getBinarySize,
+  arrayContainsArray,
+  toAscii,
+  fromUtf8,
+  fromAscii,
+  getKeys,
+  isHexString,
+} from './internal'