bytes.ts

import * as errors from './abierrors';

const HexCharacters: string = '0123456789abcdef';

export type Arrayish = string | ArrayLike<number> | null;
export interface Hexable {
  toHexString(): string;
}

export function isArrayish(value: any): value is Arrayish {
  if (
    !value ||
    parseInt(String(value.length)) != value.length ||
    typeof value === 'string'
  ) {
    return false;
  }

  for (var i = 0; i < value.length; i++) {
    var v = value[i];
    if (v < 0 || v >= 256 || parseInt(String(v)) != v) {
      return false;
    }
  }

  return true;
}

export function isHexable(value: any): value is Hexable {
  return !!value.toHexString;
}

export function hexlify(value: Arrayish | Hexable | number): string {
  if (isHexable(value)) {
    return value.toHexString();
  }

  if (typeof value === 'number') {
    if (value < 0) {
      errors.throwError(
        'cannot hexlify negative value',
        errors.INVALID_ARGUMENT,
        { arg: 'value', value: value },
      );
    }

    // @TODO: Roll this into the above error as a numeric fault (overflow); next version, not backward compatible
    // We can about (value == MAX_INT) to as well, since that may indicate we underflowed already
    if (value >= 9007199254740991) {
      errors.throwError('out-of-range', errors.NUMERIC_FAULT, {
        operartion: 'hexlify',
        fault: 'out-of-safe-range',
      });
    }

    var hex = '';
    while (value) {
      hex = HexCharacters[value & 0x0f] + hex;
      value = Math.floor(value / 16);
    }

    if (hex.length) {
      if (hex.length % 2) {
        hex = '0' + hex;
      }
      return '0x' + hex;
    }

    return '0x00';
  }

  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 },
      );
    }

    if (value.length % 2) {
      value = '0x0' + value.substring(2);
    }
    return value;
  }

  if (isArrayish(value)) {
    var result: string[] = [];
    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('');
  }

  errors.throwError('invalid hexlify value', null, {
    arg: 'value',
    value: value,
  });
  return 'never';
}

function addSlice(array: Uint8Array): Uint8Array {
  array.slice = function() {
    var args = Array.prototype.slice.call(arguments);
    return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
  };

  return array;
}

export function padZeros(
  value: Arrayish,
  length: number,
): Uint8Array | undefined {
  value = arrayify(value);
  if (value) {
    if (length < value.length) {
      throw new Error('cannot pad');
    }

    var result = new Uint8Array(length);
    result.set(value, length - value.length);
    return addSlice(result);
  }
}

export function concat(objects: Array<Arrayish>): Uint8Array {
  var arrays: Uint8Array[] = [];
  var length = 0;
  for (var i = 0; i < objects.length; i++) {
    var object = arrayify(objects[i]);
    if (object) {
      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);
}

export function isHexString(value: any, 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;
}

export function arrayify(value: Arrayish | Hexable): Uint8Array | null {
  if (value == null) {
    errors.throwError(
      'cannot convert null value to array',
      errors.INVALID_ARGUMENT,
      { arg: 'value', value: value },
    );
  }

  if (isHexable(value)) {
    value = value.toHexString();
  }

  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 },
      );
    }

    value = value.substring(2);
    if (value.length % 2) {
      value = '0' + value;
    }

    var result: number[] = [];
    for (var i = 0; i < value.length; i += 2) {
      result.push(parseInt(value.substr(i, 2), 16));
    }

    return addSlice(new Uint8Array(result));
  }

  if (isArrayish(value)) {
    return addSlice(new Uint8Array(value));
  }

  errors.throwError('invalid arrayify value', null, {
    arg: 'value',
    value: value,
    type: typeof value,
  });
  return null;
}