ethereumjsutility 7.1.5

package/src/internal.ts

@@ -0,0 +1,209 @@
+/*
+The MIT License
+
+Copyright (c) 2016 Nick Dodson. nickdodson.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE
+ */
+
+/**
+ * Returns a `Boolean` on whether or not the a `String` starts with '0x'
+ * @param str the string input value
+ * @return a boolean if it is or is not hex prefixed
+ * @throws if the str input is not a string
+ */
+export function isHexPrefixed(str: string): boolean {
+  if (typeof str !== 'string') {
+    throw new Error(`[isHexPrefixed] input must be type 'string', received type ${typeof str}`)
+  }
+
+  return str[0] === '0' && str[1] === 'x'
+}
+
+/**
+ * Removes '0x' from a given `String` if present
+ * @param str the string value
+ * @returns the string without 0x prefix
+ */
+export const stripHexPrefix = (str: string): string => {
+  if (typeof str !== 'string')
+    throw new Error(`[stripHexPrefix] input must be type 'string', received ${typeof str}`)
+
+  return isHexPrefixed(str) ? str.slice(2) : str
+}
+
+/**
+ * Pads a `String` to have an even length
+ * @param value
+ * @return output
+ */
+export function padToEven(value: string): string {
+  let a = value
+
+  if (typeof a !== 'string') {
+    throw new Error(`[padToEven] value must be type 'string', received ${typeof a}`)
+  }
+
+  if (a.length % 2) a = `0${a}`
+
+  return a
+}
+
+/**
+ * Get the binary size of a string
+ * @param str
+ * @returns the number of bytes contained within the string
+ */
+export function getBinarySize(str: string) {
+  if (typeof str !== 'string') {
+    throw new Error(`[getBinarySize] method requires input type 'string', recieved ${typeof str}`)
+  }
+
+  return Buffer.byteLength(str, 'utf8')
+}
+
+/**
+ * Returns TRUE if the first specified array contains all elements
+ * from the second one. FALSE otherwise.
+ *
+ * @param superset
+ * @param subset
+ *
+ */
+export function arrayContainsArray(
+  superset: unknown[],
+  subset: unknown[],
+  some?: boolean
+): boolean {
+  if (Array.isArray(superset) !== true) {
+    throw new Error(
+      `[arrayContainsArray] method requires input 'superset' to be an array, got type '${typeof superset}'`
+    )
+  }
+  if (Array.isArray(subset) !== true) {
+    throw new Error(
+      `[arrayContainsArray] method requires input 'subset' to be an array, got type '${typeof subset}'`
+    )
+  }
+
+  return subset[some ? 'some' : 'every']((value) => superset.indexOf(value) >= 0)
+}
+
+/**
+ * Should be called to get ascii from its hex representation
+ *
+ * @param string in hex
+ * @returns ascii string representation of hex value
+ */
+export function toAscii(hex: string): string {
+  let str = ''
+  let i = 0
+  const l = hex.length
+
+  if (hex.substring(0, 2) === '0x') i = 2
+
+  for (; i < l; i += 2) {
+    const code = parseInt(hex.substr(i, 2), 16)
+    str += String.fromCharCode(code)
+  }
+
+  return str
+}
+
+/**
+ * Should be called to get hex representation (prefixed by 0x) of utf8 string
+ *
+ * @param string
+ * @param optional padding
+ * @returns hex representation of input string
+ */
+export function fromUtf8(stringValue: string) {
+  const str = Buffer.from(stringValue, 'utf8')
+
+  return `0x${padToEven(str.toString('hex')).replace(/^0+|0+$/g, '')}`
+}
+
+/**
+ * Should be called to get hex representation (prefixed by 0x) of ascii string
+ *
+ * @param  string
+ * @param  optional padding
+ * @returns  hex representation of input string
+ */
+export function fromAscii(stringValue: string) {
+  let hex = ''
+  for (let i = 0; i < stringValue.length; i++) {
+    const code = stringValue.charCodeAt(i)
+    const n = code.toString(16)
+    hex += n.length < 2 ? `0${n}` : n
+  }
+
+  return `0x${hex}`
+}
+
+/**
+ * Returns the keys from an array of objects.
+ * @example
+ * ```js
+ * getKeys([{a: '1', b: '2'}, {a: '3', b: '4'}], 'a') => ['1', '3']
+ *````
+ * @param  params
+ * @param  key
+ * @param  allowEmpty
+ * @returns output just a simple array of output keys
+ */
+export function getKeys(params: Record<string, string>[], key: string, allowEmpty?: boolean) {
+  if (!Array.isArray(params)) {
+    throw new Error(`[getKeys] method expects input 'params' to be an array, got ${typeof params}`)
+  }
+  if (typeof key !== 'string') {
+    throw new Error(
+      `[getKeys] method expects input 'key' to be type 'string', got ${typeof params}`
+    )
+  }
+
+  const result = []
+
+  for (let i = 0; i < params.length; i++) {
+    let value = params[i][key]
+    if (allowEmpty && !value) {
+      value = ''
+    } else if (typeof value !== 'string') {
+      throw new Error(`invalid abi - expected type 'string', received ${typeof value}`)
+    }
+    result.push(value)
+  }
+
+  return result
+}
+
+/**
+ * Is the string a hex string.
+ *
+ * @param  value
+ * @param  length
+ * @returns  output the string is a hex string
+ */
+export function isHexString(value: string, length?: number): boolean {
+  if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) return false
+
+  if (length && value.length !== 2 + 2 * length) return false
+
+  return true
+}

package/src/object.ts

@@ -0,0 +1,117 @@
+import assert from 'assert'
+import { stripHexPrefix } from './internal'
+import { rlp } from './externals'
+import { toBuffer, baToJSON, unpadBuffer } from './bytes'
+
+/**
+ * Defines properties on a `Object`. It make the assumption that underlying data is binary.
+ * @param self the `Object` to define properties on
+ * @param fields an array fields to define. Fields can contain:
+ * * `name` - the name of the properties
+ * * `length` - the number of bytes the field can have
+ * * `allowLess` - if the field can be less than the length
+ * * `allowEmpty`
+ * @param data data to be validated against the definitions
+ * @deprecated
+ */
+export const defineProperties = function (self: any, fields: any, data?: any) {
+  self.raw = []
+  self._fields = []
+
+  // attach the `toJSON`
+  self.toJSON = function (label: boolean = false) {
+    if (label) {
+      type Dict = { [key: string]: string }
+      const obj: Dict = {}
+      self._fields.forEach((field: string) => {
+        obj[field] = `0x${self[field].toString('hex')}`
+      })
+      return obj
+    }
+    return baToJSON(self.raw)
+  }
+
+  self.serialize = function serialize() {
+    return rlp.encode(self.raw)
+  }
+
+  fields.forEach((field: any, i: number) => {
+    self._fields.push(field.name)
+    function getter() {
+      return self.raw[i]
+    }
+    function setter(v: any) {
+      v = toBuffer(v)
+
+      if (v.toString('hex') === '00' && !field.allowZero) {
+        v = Buffer.allocUnsafe(0)
+      }
+
+      if (field.allowLess && field.length) {
+        v = unpadBuffer(v)
+        assert(
+          field.length >= v.length,
+          `The field ${field.name} must not have more ${field.length} bytes`
+        )
+      } else if (!(field.allowZero && v.length === 0) && field.length) {
+        assert(
+          field.length === v.length,
+          `The field ${field.name} must have byte length of ${field.length}`
+        )
+      }
+
+      self.raw[i] = v
+    }
+
+    Object.defineProperty(self, field.name, {
+      enumerable: true,
+      configurable: true,
+      get: getter,
+      set: setter,
+    })
+
+    if (field.default) {
+      self[field.name] = field.default
+    }
+
+    // attach alias
+    if (field.alias) {
+      Object.defineProperty(self, field.alias, {
+        enumerable: false,
+        configurable: true,
+        set: setter,
+        get: getter,
+      })
+    }
+  })
+
+  // if the constuctor is passed data
+  if (data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(stripHexPrefix(data), 'hex')
+    }
+
+    if (Buffer.isBuffer(data)) {
+      data = rlp.decode(data)
+    }
+
+    if (Array.isArray(data)) {
+      if (data.length > self._fields.length) {
+        throw new Error('wrong number of fields in data')
+      }
+
+      // make sure all the items are buffers
+      data.forEach((d, i) => {
+        self[self._fields[i]] = toBuffer(d)
+      })
+    } else if (typeof data === 'object') {
+      const keys = Object.keys(data)
+      fields.forEach((field: any) => {
+        if (keys.indexOf(field.name) !== -1) self[field.name] = data[field.name]
+        if (keys.indexOf(field.alias) !== -1) self[field.alias] = data[field.alias]
+      })
+    } else {
+      throw new Error('invalid data')
+    }
+  }
+}

package/src/signature.ts

@@ -0,0 +1,209 @@
+import { ecdsaSign, ecdsaRecover, publicKeyConvert } from 'ethereum-cryptography/secp256k1'
+import { BN } from './externals'
+import { toBuffer, setLengthLeft, bufferToHex, bufferToInt } from './bytes'
+import { keccak } from './hash'
+import { assertIsBuffer } from './helpers'
+import { BNLike, toType, TypeOutput } from './types'
+
+export interface ECDSASignature {
+  v: number
+  r: Buffer
+  s: Buffer
+}
+
+export interface ECDSASignatureBuffer {
+  v: Buffer
+  r: Buffer
+  s: Buffer
+}
+
+/**
+ * Returns the ECDSA signature of a message hash.
+ */
+export function ecsign(msgHash: Buffer, privateKey: Buffer, chainId?: number): ECDSASignature
+export function ecsign(msgHash: Buffer, privateKey: Buffer, chainId: BNLike): ECDSASignatureBuffer
+export function ecsign(msgHash: Buffer, privateKey: Buffer, chainId: any): any {
+  const { signature, recid: recovery } = ecdsaSign(msgHash, privateKey)
+
+  const r = Buffer.from(signature.slice(0, 32))
+  const s = Buffer.from(signature.slice(32, 64))
+
+  if (!chainId || typeof chainId === 'number') {
+    // return legacy type ECDSASignature (deprecated in favor of ECDSASignatureBuffer to handle large chainIds)
+    if (chainId && !Number.isSafeInteger(chainId)) {
+      throw new Error(
+        'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)'
+      )
+    }
+    const v = chainId ? recovery + (chainId * 2 + 35) : recovery + 27
+    return { r, s, v }
+  }
+
+  const chainIdBN = toType(chainId as BNLike, TypeOutput.BN)
+  const v = chainIdBN.muln(2).addn(35).addn(recovery).toArrayLike(Buffer)
+  return { r, s, v }
+}
+
+function calculateSigRecovery(v: BNLike, chainId?: BNLike): BN {
+  const vBN = toType(v, TypeOutput.BN)
+
+  if (vBN.eqn(0) || vBN.eqn(1)) return toType(v, TypeOutput.BN)
+
+  if (!chainId) {
+    return vBN.subn(27)
+  }
+  const chainIdBN = toType(chainId, TypeOutput.BN)
+  return vBN.sub(chainIdBN.muln(2).addn(35))
+}
+
+function isValidSigRecovery(recovery: number | BN): boolean {
+  const rec = new BN(recovery)
+  return rec.eqn(0) || rec.eqn(1)
+}
+
+/**
+ * ECDSA public key recovery from signature.
+ * NOTE: Accepts `v == 0 | v == 1` for EIP1559 transactions
+ * @returns Recovered public key
+ */
+export const ecrecover = function (
+  msgHash: Buffer,
+  v: BNLike,
+  r: Buffer,
+  s: Buffer,
+  chainId?: BNLike
+): Buffer {
+  const signature = Buffer.concat([setLengthLeft(r, 32), setLengthLeft(s, 32)], 64)
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw new Error('Invalid signature v value')
+  }
+  const senderPubKey = ecdsaRecover(signature, recovery.toNumber(), msgHash)
+  return Buffer.from(publicKeyConvert(senderPubKey, false).slice(1))
+}
+
+/**
+ * Convert signature parameters into the format of `eth_sign` RPC method.
+ * NOTE: Accepts `v == 0 | v == 1` for EIP1559 transactions
+ * @returns Signature
+ */
+export const toRpcSig = function (v: BNLike, r: Buffer, s: Buffer, chainId?: BNLike): string {
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw new Error('Invalid signature v value')
+  }
+
+  // geth (and the RPC eth_sign method) uses the 65 byte format used by Bitcoin
+  return bufferToHex(Buffer.concat([setLengthLeft(r, 32), setLengthLeft(s, 32), toBuffer(v)]))
+}
+
+/**
+ * Convert signature parameters into the format of Compact Signature Representation (EIP-2098).
+ * NOTE: Accepts `v == 0 | v == 1` for EIP1559 transactions
+ * @returns Signature
+ */
+export const toCompactSig = function (v: BNLike, r: Buffer, s: Buffer, chainId?: BNLike): string {
+  const recovery = calculateSigRecovery(v, chainId)
+  if (!isValidSigRecovery(recovery)) {
+    throw new Error('Invalid signature v value')
+  }
+
+  const vn = toType(v, TypeOutput.Number)
+  let ss = s
+  if ((vn > 28 && vn % 2 === 1) || vn === 1 || vn === 28) {
+    ss = Buffer.from(s)
+    ss[0] |= 0x80
+  }
+
+  return bufferToHex(Buffer.concat([setLengthLeft(r, 32), setLengthLeft(ss, 32)]))
+}
+
+/**
+ * Convert signature format of the `eth_sign` RPC method to signature parameters
+ * NOTE: all because of a bug in geth: https://github.com/ethereum/go-ethereum/issues/2053
+ * NOTE: After EIP1559, `v` could be `0` or `1` but this function assumes
+ * it's a signed message (EIP-191 or EIP-712) adding `27` at the end. Remove if needed.
+ */
+export const fromRpcSig = function (sig: string): ECDSASignature {
+  const buf: Buffer = toBuffer(sig)
+
+  let r: Buffer
+  let s: Buffer
+  let v: number
+  if (buf.length >= 65) {
+    r = buf.slice(0, 32)
+    s = buf.slice(32, 64)
+    v = bufferToInt(buf.slice(64))
+  } else if (buf.length === 64) {
+    // Compact Signature Representation (https://eips.ethereum.org/EIPS/eip-2098)
+    r = buf.slice(0, 32)
+    s = buf.slice(32, 64)
+    v = bufferToInt(buf.slice(32, 33)) >> 7
+    s[0] &= 0x7f
+  } else {
+    throw new Error('Invalid signature length')
+  }
+
+  // support both versions of `eth_sign` responses
+  if (v < 27) {
+    v += 27
+  }
+
+  return {
+    v,
+    r,
+    s,
+  }
+}
+
+/**
+ * Validate a ECDSA signature.
+ * NOTE: Accepts `v == 0 | v == 1` for EIP1559 transactions
+ * @param homesteadOrLater Indicates whether this is being used on either the homestead hardfork or a later one
+ */
+export const isValidSignature = function (
+  v: BNLike,
+  r: Buffer,
+  s: Buffer,
+  homesteadOrLater: boolean = true,
+  chainId?: BNLike
+): boolean {
+  const SECP256K1_N_DIV_2 = new BN(
+    '7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0',
+    16
+  )
+  const SECP256K1_N = new BN('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 16)
+
+  if (r.length !== 32 || s.length !== 32) {
+    return false
+  }
+
+  if (!isValidSigRecovery(calculateSigRecovery(v, chainId))) {
+    return false
+  }
+
+  const rBN = new BN(r)
+  const sBN = new BN(s)
+
+  if (rBN.isZero() || rBN.gt(SECP256K1_N) || sBN.isZero() || sBN.gt(SECP256K1_N)) {
+    return false
+  }
+
+  if (homesteadOrLater && sBN.cmp(SECP256K1_N_DIV_2) === 1) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * Returns the keccak-256 hash of `message`, prefixed with the header used by the `eth_sign` RPC call.
+ * The output of this function can be fed into `ecsign` to produce the same signature as the `eth_sign`
+ * call for a given `message`, or fed to `ecrecover` along with a signature to recover the public key
+ * used to produce the signature.
+ */
+export const hashPersonalMessage = function (message: Buffer): Buffer {
+  assertIsBuffer(message)
+  const prefix = Buffer.from(`\u0019Ethereum Signed Message:\n${message.length}`, 'utf-8')
+  return keccak(Buffer.concat([prefix, message]))
+}

package/src/types.ts

@@ -0,0 +1,146 @@
+import { BN } from './externals'
+import { isHexString } from './internal'
+import { Address } from './address'
+import { unpadBuffer, toBuffer, ToBufferInputTypes } from './bytes'
+
+/*
+ * A type that represents a BNLike input that can be converted to a BN.
+ */
+export type BNLike = BN | PrefixedHexString | number | Buffer
+
+/*
+ * A type that represents a BufferLike input that can be converted to a Buffer.
+ */
+export type BufferLike =
+  | Buffer
+  | Uint8Array
+  | number[]
+  | number
+  | BN
+  | TransformableToBuffer
+  | PrefixedHexString
+
+/*
+ * A type that represents a `0x`-prefixed hex string.
+ */
+export type PrefixedHexString = string
+
+/**
+ * A type that represents an Address-like value.
+ * To convert to address, use `new Address(toBuffer(value))`
+ */
+export type AddressLike = Address | Buffer | PrefixedHexString
+
+/*
+ * A type that represents an object that has a `toArray()` method.
+ */
+export interface TransformableToArray {
+  toArray(): Uint8Array
+  toBuffer?(): Buffer
+}
+
+/*
+ * A type that represents an object that has a `toBuffer()` method.
+ */
+export interface TransformableToBuffer {
+  toBuffer(): Buffer
+  toArray?(): Uint8Array
+}
+
+export type NestedUint8Array = Array<Uint8Array | NestedUint8Array>
+export type NestedBufferArray = Array<Buffer | NestedBufferArray>
+
+/**
+ * Convert BN to 0x-prefixed hex string.
+ */
+export function bnToHex(value: BN): PrefixedHexString {
+  return `0x${value.toString(16)}`
+}
+
+/**
+ * Convert value from BN to an unpadded Buffer
+ * (useful for RLP transport)
+ * @param value value to convert
+ */
+export function bnToUnpaddedBuffer(value: BN): Buffer {
+  // Using `bn.toArrayLike(Buffer)` instead of `bn.toBuffer()`
+  // for compatibility with browserify and similar tools
+  return unpadBuffer(value.toArrayLike(Buffer))
+}
+
+/**
+ * Deprecated alias for {@link bnToUnpaddedBuffer}
+ * @deprecated
+ */
+export function bnToRlp(value: BN): Buffer {
+  return bnToUnpaddedBuffer(value)
+}
+
+/**
+ * Type output options
+ */
+export enum TypeOutput {
+  Number,
+  BN,
+  Buffer,
+  PrefixedHexString,
+}
+
+export type TypeOutputReturnType = {
+  [TypeOutput.Number]: number
+  [TypeOutput.BN]: BN
+  [TypeOutput.Buffer]: Buffer
+  [TypeOutput.PrefixedHexString]: PrefixedHexString
+}
+
+/**
+ * Convert an input to a specified type.
+ * Input of null/undefined returns null/undefined regardless of the output type.
+ * @param input value to convert
+ * @param outputType type to output
+ */
+export function toType<T extends TypeOutput>(input: null, outputType: T): null
+export function toType<T extends TypeOutput>(input: undefined, outputType: T): undefined
+export function toType<T extends TypeOutput>(
+  input: ToBufferInputTypes,
+  outputType: T
+): TypeOutputReturnType[T]
+export function toType<T extends TypeOutput>(
+  input: ToBufferInputTypes,
+  outputType: T
+): TypeOutputReturnType[T] | undefined | null {
+  if (input === null) {
+    return null
+  }
+  if (input === undefined) {
+    return undefined
+  }
+
+  if (typeof input === 'string' && !isHexString(input)) {
+    throw new Error(`A string must be provided with a 0x-prefix, given: ${input}`)
+  } else if (typeof input === 'number' && !Number.isSafeInteger(input)) {
+    throw new Error(
+      'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative input type)'
+    )
+  }
+
+  const output = toBuffer(input)
+
+  if (outputType === TypeOutput.Buffer) {
+    return output as TypeOutputReturnType[T]
+  } else if (outputType === TypeOutput.BN) {
+    return new BN(output) as TypeOutputReturnType[T]
+  } else if (outputType === TypeOutput.Number) {
+    const bn = new BN(output)
+    const max = new BN(Number.MAX_SAFE_INTEGER.toString())
+    if (bn.gt(max)) {
+      throw new Error(
+        'The provided number is greater than MAX_SAFE_INTEGER (please use an alternative output type)'
+      )
+    }
+    return bn.toNumber() as TypeOutputReturnType[T]
+  } else {
+    // outputType === TypeOutput.PrefixedHexString
+    return `0x${output.toString('hex')}` as TypeOutputReturnType[T]
+  }
+}