ethereumjs / rlp / 249

pending completion

Build # 249

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #72 from simon-jentzsch/master

added Error when dealing with negativ integers for

Run Details

17 of 20 branches covered (85.0%)

1 of 1 new or added line in 1 file covered. (100.0%)

71 of 81 relevant lines covered (87.65%)

30.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.13

/src/index.ts

import BN = require('bn.js')

import { Decoded, Dictionary, Input, List } from './types'

// Types exported outside of this package
export { Decoded, Dictionary, Input, List }

/**
 * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP
 * This function takes in a data, convert it to buffer if not, and a length for recursion
 * @param input - will be converted to buffer
 * @returns returns buffer of encoded data
 **/
export function encode(input: Input): Buffer {
  if (Array.isArray(input)) {
    const output: Buffer[] = []
    for (let i = 0; i < input.length; i++) {
      output.push(encode(input[i]))
    }
    const buf = Buffer.concat(output)
    return Buffer.concat([encodeLength(buf.length, 192), buf])
  } else {
    const inputBuf = toBuffer(input)
    return inputBuf.length === 1 && inputBuf[0] < 128
      ? inputBuf
      : Buffer.concat([encodeLength(inputBuf.length, 128), inputBuf])
  }
}

/**
 * Parse integers. Check if there is no leading zeros
 * @param v The value to parse
 * @param base The base to parse the integer into
 */
function safeParseInt(v: string, base: number): number {
  if (v.slice(0, 2) === '00') {
    throw new Error('invalid RLP: extra zeros')
  }

  return parseInt(v, base)
}

function encodeLength(len: number, offset: number): Buffer {
  if (len < 56) {
    return Buffer.from([len + offset])
  } else {
    const hexLength = intToHex(len)
    const lLength = hexLength.length / 2
    const firstByte = intToHex(offset + 55 + lLength)
    return Buffer.from(firstByte + hexLength, 'hex')
  }
}

/**
 * RLP Decoding based on: {@link https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP|RLP}
 * @param input - will be converted to buffer
 * @param stream - Is the input a stream (false by default)
 * @returns - returns decode Array of Buffers containg the original message
 **/
export function decode(input: Buffer, stream?: boolean): Buffer
export function decode(input: Buffer[], stream?: boolean): Buffer[]
export function decode(input: Input, stream?: boolean): Buffer[] | Buffer | Decoded
export function decode(input: Input, stream: boolean = false): Buffer[] | Buffer | Decoded {
  if (!input || (<any>input).length === 0) {
    return Buffer.from([])
  }

  const inputBuffer = toBuffer(input)
  const decoded = _decode(inputBuffer)

  if (stream) {
    return decoded
  }
  if (decoded.remainder.length !== 0) {
    throw new Error('invalid remainder')
  }

  return decoded.data
}

/**
 * Get the length of the RLP input
 * @param input
 * @returns The length of the input or an empty Buffer if no input
 */
export function getLength(input: Input): Buffer | number {
  if (!input || (<any>input).length === 0) {
    return Buffer.from([])
  }

  const inputBuffer = toBuffer(input)
  const firstByte = inputBuffer[0]

  if (firstByte <= 0x7f) {
    return inputBuffer.length
  } else if (firstByte <= 0xb7) {
    return firstByte - 0x7f
  } else if (firstByte <= 0xbf) {
    return firstByte - 0xb6
  } else if (firstByte <= 0xf7) {
    // a list between  0-55 bytes long
    return firstByte - 0xbf
  } else {
    // a list  over 55 bytes long
    const llength = firstByte - 0xf6
    const length = safeParseInt(inputBuffer.slice(1, llength).toString('hex'), 16)
    return llength + length
  }
}

/** Decode an input with RLP */
function _decode(input: Buffer): Decoded {
  let length, llength, data, innerRemainder, d
  const decoded = []
  const firstByte = input[0]

  if (firstByte <= 0x7f) {
    // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
    return {
      data: input.slice(0, 1),
      remainder: input.slice(1),
    }
  } else if (firstByte <= 0xb7) {
    // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
    // The range of the first byte is [0x80, 0xb7]
    length = firstByte - 0x7f

    // set 0x80 null to 0
    if (firstByte === 0x80) {
      data = Buffer.from([])
    } else {
      data = input.slice(1, length)
    }

    if (length === 2 && data[0] < 0x80) {
      throw new Error('invalid rlp encoding: byte must be less 0x80')
    }

    return {
      data: data,
      remainder: input.slice(length),
    }
  } else if (firstByte <= 0xbf) {
    llength = firstByte - 0xb6
    length = safeParseInt(input.slice(1, llength).toString('hex'), 16)
    data = input.slice(llength, length + llength)
    if (data.length < length) {
      throw new Error('invalid RLP')
    }

    return {
      data: data,
      remainder: input.slice(length + llength),
    }
  } else if (firstByte <= 0xf7) {
    // a list between  0-55 bytes long
    length = firstByte - 0xbf
    innerRemainder = input.slice(1, length)
    while (innerRemainder.length) {
      d = _decode(innerRemainder)
      decoded.push(d.data as Buffer)
      innerRemainder = d.remainder
    }

    return {
      data: decoded,
      remainder: input.slice(length),
    }
  } else {
    // a list  over 55 bytes long
    llength = firstByte - 0xf6
    length = safeParseInt(input.slice(1, llength).toString('hex'), 16)
    const totalLength = llength + length
    if (totalLength > input.length) {
      throw new Error('invalid rlp: total length is larger than the data')
    }

    innerRemainder = input.slice(llength, totalLength)
    if (innerRemainder.length === 0) {
      throw new Error('invalid rlp, List has a invalid length')
    }

    while (innerRemainder.length) {
      d = _decode(innerRemainder)
      decoded.push(d.data as Buffer)
      innerRemainder = d.remainder
    }
    return {
      data: decoded,
      remainder: input.slice(totalLength),
    }
  }
}

/** Check if a string is prefixed by 0x */
function isHexPrefixed(str: string): boolean {
  return str.slice(0, 2) === '0x'
}

/** Removes 0x from a given String */
function stripHexPrefix(str: string): string {
  if (typeof str !== 'string') {
    return str
  }
  return isHexPrefixed(str) ? str.slice(2) : str
}

/** Transform an integer into its hexadecimal value */
function intToHex(integer: number): string {
  if (integer < 0) {
    throw new Error('Invalid integer as argument, must be unsigned!')
  }
  const hex = integer.toString(16)
  return hex.length % 2 ? `0${hex}` : hex
}

/** Pad a string to be even */
function padToEven(a: string): string {
  return a.length % 2 ? `0${a}` : a
}

/** Transform an integer into a Buffer */
function intToBuffer(integer: number): Buffer {
  const hex = intToHex(integer)
  return Buffer.from(hex, 'hex')
}

/** Transform anything into a Buffer */
function toBuffer(v: Input): Buffer {
  if (!Buffer.isBuffer(v)) {
    if (typeof v === 'string') {
      if (isHexPrefixed(v)) {
        return Buffer.from(padToEven(stripHexPrefix(v)), 'hex')
      } else {
        return Buffer.from(v)
      }
    } else if (typeof v === 'number') {
      if (!v) {
        return Buffer.from([])
      } else {
        return intToBuffer(v)
      }
    } else if (v === null || v === undefined) {
      return Buffer.from([])
    } else if (v instanceof Uint8Array) {
      return Buffer.from(v as any)
    } else if (BN.isBN(v)) {
      // converts a BN to a Buffer
      return Buffer.from(v.toArray())
    } else {
      throw new Error('invalid type')
    }
  }
  return v
}

1	import BN = require('bn.js')	1✔
2
3	import { Decoded, Dictionary, Input, List } from './types'
4
5	// Types exported outside of this package
6	export { Decoded, Dictionary, Input, List }
7
8	/**
9	* RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP
10	* This function takes in a data, convert it to buffer if not, and a length for recursion
11	* @param input - will be converted to buffer
12	* @returns returns buffer of encoded data
13	**/
14	export function encode(input: Input): Buffer {	1✔
15	if (Array.isArray(input)) {
16	const output: Buffer[] = []	85✔
17	for (let i = 0; i < input.length; i++) {	85✔
18	output.push(encode(input[i]))	247✔
19	}
20	const buf = Buffer.concat(output)	85✔
21	return Buffer.concat([encodeLength(buf.length, 192), buf])	85✔
22	} else {
23	const inputBuf = toBuffer(input)	208✔
24	return inputBuf.length === 1 && inputBuf[0] < 128	208✔
25	? inputBuf	208✔
26	: Buffer.concat([encodeLength(inputBuf.length, 128), inputBuf])
27	}
28	}
29
30	/**
31	* Parse integers. Check if there is no leading zeros
32	* @param v The value to parse
33	* @param base The base to parse the integer into
34	*/
35	function safeParseInt(v: string, base: number): number {
36	if (v.slice(0, 2) === '00') {
37	throw new Error('invalid RLP: extra zeros')	1✔
38	}
39
40	return parseInt(v, base)	11✔
41	}
42
43	function encodeLength(len: number, offset: number): Buffer {
44	if (len < 56) {
45	return Buffer.from([len + offset])	263✔
46	} else {
47	const hexLength = intToHex(len)	7✔
48	const lLength = hexLength.length / 2	7✔
49	const firstByte = intToHex(offset + 55 + lLength)	7✔
50	return Buffer.from(firstByte + hexLength, 'hex')	7✔
51	}
52	}
53
54	/**
55	* RLP Decoding based on: {@link https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\|RLP}
56	* @param input - will be converted to buffer
57	* @param stream - Is the input a stream (false by default)
58	* @returns - returns decode Array of Buffers containg the original message
59	**/
60	export function decode(input: Buffer, stream?: boolean): Buffer
61	export function decode(input: Buffer[], stream?: boolean): Buffer[]
62	export function decode(input: Input, stream?: boolean): Buffer[] \| Buffer \| Decoded
63	export function decode(input: Input, stream: boolean = false): Buffer[] \| Buffer \| Decoded {	34!
64	if (!input \|\| (<any>input).length === 0) {	34✔
65	return Buffer.from([])	1✔
66	}
67
68	const inputBuffer = toBuffer(input)	16✔
69	const decoded = _decode(inputBuffer)	16✔
70
71	if (stream) {
72	return decoded	×
73	}
74	if (decoded.remainder.length !== 0) {
75	throw new Error('invalid remainder')	1✔
76	}
77
78	return decoded.data	10✔
79	}
80
81	/**
82	* Get the length of the RLP input
83	* @param input
84	* @returns The length of the input or an empty Buffer if no input
85	*/
86	export function getLength(input: Input): Buffer \| number {	1✔
87	if (!input \|\| (<any>input).length === 0) {	6✔
88	return Buffer.from([])	×
89	}
90
91	const inputBuffer = toBuffer(input)	3✔
92	const firstByte = inputBuffer[0]	3✔
93
94	if (firstByte <= 0x7f) {
95	return inputBuffer.length	1✔
96	} else if (firstByte <= 0xb7) {
97	return firstByte - 0x7f	1✔
98	} else if (firstByte <= 0xbf) {
99	return firstByte - 0xb6	1✔
100	} else if (firstByte <= 0xf7) {
101	// a list between 0-55 bytes long
102	return firstByte - 0xbf	×
103	} else {
104	// a list over 55 bytes long
105	const llength = firstByte - 0xf6	×
106	const length = safeParseInt(inputBuffer.slice(1, llength).toString('hex'), 16)	×
107	return llength + length	×
108	}
109	}
110
111	/** Decode an input with RLP */
112	function _decode(input: Buffer): Decoded {
113	let length, llength, data, innerRemainder, d
114	const decoded = []	82✔
115	const firstByte = input[0]	82✔
116
117	if (firstByte <= 0x7f) {
118	// a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.
119	return {	9✔
120	data: input.slice(0, 1),
121	remainder: input.slice(1),
122	}
123	} else if (firstByte <= 0xb7) {
124	// string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string
125	// The range of the first byte is [0x80, 0xb7]
126	length = firstByte - 0x7f	50✔
127
128	// set 0x80 null to 0
129	if (firstByte === 0x80) {
130	data = Buffer.from([])	4✔
131	} else {
132	data = input.slice(1, length)	46✔
133	}
134
135	if (length === 2 && data[0] < 0x80) {	51✔
136	throw new Error('invalid rlp encoding: byte must be less 0x80')	1✔
137	}
138
139	return {	49✔
140	data: data,
141	remainder: input.slice(length),
142	}
143	} else if (firstByte <= 0xbf) {
144	llength = firstByte - 0xb6	3✔
145	length = safeParseInt(input.slice(1, llength).toString('hex'), 16)	3✔
146	data = input.slice(llength, length + llength)	3✔
147	if (data.length < length) {
148	throw new Error('invalid RLP')	1✔
149	}
150
151	return {	2✔
152	data: data,
153	remainder: input.slice(length + llength),
154	}
155	} else if (firstByte <= 0xf7) {
156	// a list between 0-55 bytes long
157	length = firstByte - 0xbf	11✔
158	innerRemainder = input.slice(1, length)	11✔
159	while (innerRemainder.length) {
160	d = _decode(innerRemainder)	11✔
161	decoded.push(d.data as Buffer)	10✔
162	innerRemainder = d.remainder	10✔
163	}
164
165	return {	10✔
166	data: decoded,
167	remainder: input.slice(length),
168	}
169	} else {
170	// a list over 55 bytes long
171	llength = firstByte - 0xf6	9✔
172	length = safeParseInt(input.slice(1, llength).toString('hex'), 16)	9✔
173	const totalLength = llength + length	8✔
174	if (totalLength > input.length) {
175	throw new Error('invalid rlp: total length is larger than the data')	2✔
176	}
177
178	innerRemainder = input.slice(llength, totalLength)	6✔
179	if (innerRemainder.length === 0) {
180	throw new Error('invalid rlp, List has a invalid length')	×
181	}
182
183	while (innerRemainder.length) {
184	d = _decode(innerRemainder)	55✔
185	decoded.push(d.data as Buffer)	54✔
186	innerRemainder = d.remainder	54✔
187	}
188	return {	5✔
189	data: decoded,
190	remainder: input.slice(totalLength),
191	}
192	}
193	}
194
195	/** Check if a string is prefixed by 0x */
196	function isHexPrefixed(str: string): boolean {
197	return str.slice(0, 2) === '0x'	174✔
198	}
199
200	/** Removes 0x from a given String */
201	function stripHexPrefix(str: string): string {
202	if (typeof str !== 'string') {
203	return str	×
204	}
205	return isHexPrefixed(str) ? str.slice(2) : str	1!
206	}
207
208	/** Transform an integer into its hexadecimal value */
209	function intToHex(integer: number): string {
210	if (integer < 0) {
211	throw new Error('Invalid integer as argument, must be unsigned!')	×
212	}
213	const hex = integer.toString(16)	31✔
214	return hex.length % 2 ? `0${hex}` : hex	31✔
215	}
216
217	/** Pad a string to be even */
218	function padToEven(a: string): string {
219	return a.length % 2 ? `0${a}` : a	1!
220	}
221
222	/** Transform an integer into a Buffer */
223	function intToBuffer(integer: number): Buffer {
224	const hex = intToHex(integer)	17✔
225	return Buffer.from(hex, 'hex')	17✔
226	}
227
228	/** Transform anything into a Buffer */
229	function toBuffer(v: Input): Buffer {
230	if (!Buffer.isBuffer(v)) {
231	if (typeof v === 'string') {
232	if (isHexPrefixed(v)) {
233	return Buffer.from(padToEven(stripHexPrefix(v)), 'hex')	1✔
234	} else {
235	return Buffer.from(v)	172✔
236	}
237	} else if (typeof v === 'number') {
238	if (!v) {
239	return Buffer.from([])	3✔
240	} else {
241	return intToBuffer(v)	17✔
242	}
243	} else if (v === null \|\| v === undefined) {	9✔
244	return Buffer.from([])	1✔
245	} else if (v instanceof Uint8Array) {
246	return Buffer.from(v as any)	3✔
247	} else if (BN.isBN(v)) {
248	// converts a BN to a Buffer
249	return Buffer.from(v.toArray())	1✔
250	} else {
251	throw new Error('invalid type')	×
252	}
253	}
254	return v	29✔
255	}

ethereumjs / rlp / 249

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous