ethers.js/src.ts/utils/bytes.ts

295 lines
7.8 KiB
TypeScript
Raw Normal View History

2017-02-24 22:57:46 +03:00
/**
* Conversion Utilities
*
*/
import { Arrayish, BigNumber, Signature } from './types';
2018-06-13 22:39:39 +03:00
import errors = require('./errors');
2017-02-24 22:57:46 +03:00
2018-07-12 09:42:46 +03:00
export const AddressZero = '0x0000000000000000000000000000000000000000';
export const HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
2018-06-13 22:39:39 +03:00
function isBigNumber(value: any): value is BigNumber {
return !!value._bn;
}
function addSlice(array: Uint8Array): Uint8Array {
if (array.slice) { return array; }
array.slice = function() {
var args = Array.prototype.slice.call(arguments);
return new Uint8Array(Array.prototype.slice.apply(array, args));
}
return array;
}
2018-06-13 22:39:39 +03:00
export function isArrayish(value: any): boolean {
if (!value || parseInt(String(value.length)) != value.length || typeof(value) === 'string') {
2017-02-24 22:57:46 +03:00
return false;
}
for (var i = 0; i < value.length; i++) {
var v = value[i];
if (v < 0 || v >= 256 || parseInt(String(v)) != v) {
2017-02-24 22:57:46 +03:00
return false;
}
}
return true;
}
2018-06-13 22:39:39 +03:00
export function arrayify(value: Arrayish | BigNumber): Uint8Array {
if (value == null) {
errors.throwError('cannot convert null value to array', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
2017-02-24 22:57:46 +03:00
2018-06-13 22:39:39 +03:00
if (isBigNumber(value)) {
2017-02-24 22:57:46 +03:00
value = value.toHexString();
}
2018-06-13 22:39:39 +03:00
if (typeof(value) === 'string') {
let match = value.match(/^(0x)?[0-9a-fA-F]*$/);
if (!match) {
errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
if (match[1] !== '0x') {
errors.throwError('hex string must have 0x prefix', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
2017-02-24 22:57:46 +03:00
value = value.substring(2);
if (value.length % 2) { value = '0' + value; }
var result = [];
for (var i = 0; i < value.length; i += 2) {
result.push(parseInt(value.substr(i, 2), 16));
}
return addSlice(new Uint8Array(result));
} else if (typeof(value) === 'string') {
2017-02-24 22:57:46 +03:00
}
if (isArrayish(value)) {
return addSlice(new Uint8Array(value));
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
errors.throwError('invalid arrayify value', null, { arg: 'value', value: value, type: typeof(value) });
return null;
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
export function concat(objects: Array<Arrayish>): Uint8Array {
2017-02-24 22:57:46 +03:00
var arrays = [];
var length = 0;
for (var i = 0; i < objects.length; i++) {
var object = arrayify(objects[i])
arrays.push(object);
length += object.length;
}
var result = new Uint8Array(length);
var offset = 0;
for (var i = 0; i < arrays.length; i++) {
result.set(arrays[i], offset);
offset += arrays[i].length;
}
return addSlice(result);
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
export function stripZeros(value: Arrayish): Uint8Array {
let result: Uint8Array = arrayify(value);
if (result.length === 0) { return result; }
2017-02-24 22:57:46 +03:00
// Find the first non-zero entry
var start = 0;
2018-06-13 22:39:39 +03:00
while (result[start] === 0) { start++ }
2017-02-24 22:57:46 +03:00
// If we started with zeros, strip them
if (start) {
2018-06-13 22:39:39 +03:00
result = result.slice(start);
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
return result;
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
export function padZeros(value: Arrayish, length: number): Uint8Array {
value = arrayify(value);
2017-02-24 22:57:46 +03:00
if (length < value.length) { throw new Error('cannot pad'); }
2017-02-24 22:57:46 +03:00
var result = new Uint8Array(length);
result.set(value, length - value.length);
return addSlice(result);
2017-02-24 22:57:46 +03:00
}
2018-06-13 22:39:39 +03:00
export function isHexString(value: any, length?: number): boolean {
2017-02-24 22:57:46 +03:00
if (typeof(value) !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
return false
}
if (length && value.length !== 2 + 2 * length) { return false; }
return true;
}
2018-06-13 22:39:39 +03:00
const HexCharacters: string = '0123456789abcdef';
2017-02-24 22:57:46 +03:00
2018-06-13 22:39:39 +03:00
export function hexlify(value: Arrayish | BigNumber | number): string {
2017-02-24 22:57:46 +03:00
2018-06-13 22:39:39 +03:00
if (isBigNumber(value)) {
2017-02-24 22:57:46 +03:00
return value.toHexString();
}
if (typeof(value) === 'number') {
if (value < 0) {
2018-06-13 22:39:39 +03:00
errors.throwError('cannot hexlify negative value', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
2017-02-24 22:57:46 +03:00
}
var hex = '';
while (value) {
hex = HexCharacters[value & 0x0f] + hex;
value = Math.floor(value / 16);
2017-02-24 22:57:46 +03:00
}
if (hex.length) {
if (hex.length % 2) { hex = '0' + hex; }
return '0x' + hex;
}
return '0x00';
}
2018-06-13 22:39:39 +03:00
if (typeof(value) === 'string') {
let match = value.match(/^(0x)?[0-9a-fA-F]*$/);
if (!match) {
errors.throwError('invalid hexidecimal string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
if (match[1] !== '0x') {
errors.throwError('hex string must have 0x prefix', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
2017-02-24 22:57:46 +03:00
if (value.length % 2) {
value = '0x0' + value.substring(2);
}
return value;
}
if (isArrayish(value)) {
var result = [];
for (var i = 0; i < value.length; i++) {
var v = value[i];
result.push(HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f]);
}
return '0x' + result.join('');
}
2018-06-13 22:39:39 +03:00
errors.throwError('invalid hexlify value', null, { arg: 'value', value: value });
return 'never';
2017-02-24 22:57:46 +03:00
}
export function hexDataLength(data: string) {
if (!isHexString(data) || (data.length % 2) !== 0) {
return null;
}
return (data.length - 2) / 2;
}
export function hexDataSlice(data: string, offset: number, length?: number): string {
if (!isHexString(data)) {
errors.throwError('invalid hex data', errors.INVALID_ARGUMENT, { arg: 'value', value: data });
}
if ((data.length % 2) !== 0) {
errors.throwError('hex data length must be even', errors.INVALID_ARGUMENT, { arg: 'value', value: data });
}
offset = 2 + 2 * offset;
if (length != null) {
return '0x' + data.substring(offset, offset + 2 * length);
}
return '0x' + data.substring(offset);
}
2018-06-13 22:39:39 +03:00
export function hexStripZeros(value: string): string {
if (!isHexString(value)) {
errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
while (value.length > 3 && value.substring(0, 3) === '0x0') {
value = '0x' + value.substring(3);
}
return value;
}
2018-06-13 22:39:39 +03:00
export function hexZeroPad(value: string, length: number): string {
if (!isHexString(value)) {
errors.throwError('invalid hex string', errors.INVALID_ARGUMENT, { arg: 'value', value: value });
}
while (value.length < 2 * length + 2) {
value = '0x0' + value.substring(2);
}
return value;
}
2017-02-24 22:57:46 +03:00
2018-07-12 09:42:46 +03:00
function isSignature(value: any): value is Signature {
return (value && value.r != null && value.s != null);
}
export function splitSignature(signature: Arrayish | Signature): Signature {
let v = 0;
let r = '0x', s = '0x';
if (isSignature(signature)) {
r = hexZeroPad(signature.r, 32);
s = hexZeroPad(signature.s, 32);
v = signature.v;
if (typeof(v) === 'string') { v = parseInt(v, 16); }
2018-07-12 09:42:46 +03:00
let recoveryParam = signature.recoveryParam;
if (recoveryParam == null && signature.v != null) {
recoveryParam = 1 - (v % 2);
2018-07-12 09:42:46 +03:00
}
v = 27 + recoveryParam;
} else {
let bytes: Uint8Array = arrayify(signature);
if (bytes.length !== 65) {
throw new Error('invalid signature');
}
r = hexlify(bytes.slice(0, 32));
s = hexlify(bytes.slice(32, 64));
2018-07-12 09:42:46 +03:00
v = bytes[64];
if (v !== 27 && v !== 28) {
v = 27 + (v % 2);
}
}
return {
2018-07-12 09:42:46 +03:00
r: r,
s: s,
recoveryParam: (v - 27),
v: v
}
}
2018-06-18 12:42:41 +03:00
export function joinSignature(signature: Signature): string {
2018-07-12 09:42:46 +03:00
signature = splitSignature(signature);
2018-06-18 12:42:41 +03:00
return hexlify(concat([
2018-07-12 09:42:46 +03:00
signature.r,
signature.s,
2018-06-18 12:42:41 +03:00
(signature.recoveryParam ? '0x1c': '0x1b')
]));
}