essential-eth 0.9.1-next.1 → 0.9.2-beta.0

package/dist/esm/utils/solidity-keccak256.js

@@ -1,85 +0,0 @@
-import { Buffer } from 'buffer';
-import { hexFalse } from '../classes/utils/encode-decode-transaction';
-import { logger } from '../logger/logger';
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { arrayify, concat, hexlify, zeroPad } from './bytes';
-import { keccak256 } from './keccak256';
-const regexBytes = new RegExp('^bytes([0-9]+)$');
-const regexNumber = new RegExp('^(u?int)([0-9]*)$');
-const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
-function _pack(type, value, isArray) {
-    switch (type) {
-        case 'address':
-            if (isArray) {
-                return zeroPad(value, 32);
-            }
-            return arrayify(value);
-        case 'string':
-            return Buffer.from(value);
-        case 'bytes':
-            return arrayify(value);
-        case 'bool':
-            value = value ? '0x01' : '0x00';
-            if (isArray) {
-                return zeroPad(value, 32);
-            }
-            return arrayify(value);
-    }
-    let match = type.match(regexNumber);
-    if (match) {
-        let size = parseInt(match[2] || '256');
-        if ((match[2] && String(size) !== match[2]) ||
-            size % 8 !== 0 ||
-            size === 0 ||
-            size > 256) {
-            logger.throwArgumentError('invalid number type', 'type', type);
-        }
-        if (isArray) {
-            size = 256;
-        }
-        value = tinyBig(value).toTwos(size).toNumber();
-        const hexValue = hexlify(value);
-        return zeroPad(hexValue, size / 8);
-    }
-    match = type.match(regexBytes);
-    if (match) {
-        const size = parseInt(match[1]);
-        if (String(size) !== match[1] || size === 0 || size > 32) {
-            logger.throwArgumentError('invalid bytes type', 'type', type);
-        }
-        if (arrayify(value).byteLength !== size) {
-            logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
-        }
-        if (isArray) {
-            return arrayify((value + hexFalse).substring(0, 66));
-        }
-        return value;
-    }
-    match = type.match(regexArray);
-    if (match && Array.isArray(value)) {
-        const baseType = match[1];
-        const count = parseInt(match[2] || String(value.length));
-        if (count != value.length) {
-            logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
-        }
-        const result = [];
-        value.forEach(function (value) {
-            result.push(_pack(baseType, value, true));
-        });
-        return concat(result);
-    }
-    return logger.throwArgumentError('invalid type', 'type', type);
-}
-export function pack(types, values) {
-    if (types.length != values.length) {
-        logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
-    }
-    const tight = [];
-    types.forEach(function (type, index) {
-        tight.push(_pack(type, values[index]));
-    });
-    return hexlify(concat(tight));
-}
-export function solidityKeccak256(types, values) {
-    return keccak256(pack(types, values));
-}

package/dist/esm/utils/split-signature.d.ts

@@ -1,2 +0,0 @@
-import type { Signature, SignatureLike } from './bytes';
-export declare function splitSignature(signature: SignatureLike): Signature;

package/dist/esm/utils/split-signature.js

@@ -1,126 +0,0 @@
-import { logger } from './../logger/logger';
-import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad, } from './bytes';
-export function splitSignature(signature) {
-    const result = {
-        r: '0x',
-        s: '0x',
-        _vs: '0x',
-        recoveryParam: 0,
-        v: 0,
-        yParityAndS: '0x',
-        compact: '0x',
-    };
-    if (isBytesLike(signature)) {
-        const bytes = arrayify(signature);
-        if (bytes.length === 64) {
-            result.v = 27 + (bytes[32] >> 7);
-            bytes[32] &= 0x7f;
-            result.r = hexlify(bytes.slice(0, 32));
-            result.s = hexlify(bytes.slice(32, 64));
-        }
-        else if (bytes.length === 65) {
-            result.r = hexlify(bytes.slice(0, 32));
-            result.s = hexlify(bytes.slice(32, 64));
-            result.v = bytes[64];
-        }
-        else {
-            logger.throwArgumentError('invalid signature string', 'signature', signature);
-        }
-        if (result.v < 27) {
-            if (result.v === 0 || result.v === 1) {
-                result.v += 27;
-            }
-            else {
-                logger.throwArgumentError('signature invalid v byte', 'signature', signature);
-            }
-        }
-        result.recoveryParam = 1 - (result.v % 2);
-        if (result.recoveryParam) {
-            bytes[32] |= 0x80;
-        }
-        result._vs = hexlify(bytes.slice(32, 64));
-    }
-    else {
-        result.r = signature.r;
-        result.s = signature.s;
-        result.v = signature.v;
-        result.recoveryParam = signature.recoveryParam;
-        result._vs = signature._vs;
-        if (result._vs != null) {
-            const vs_1 = zeroPad(arrayify(result._vs), 32);
-            result._vs = hexlify(vs_1);
-            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
-            if (result.recoveryParam == null) {
-                result.recoveryParam = recoveryParam;
-            }
-            else if (result.recoveryParam !== recoveryParam) {
-                logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
-            }
-            vs_1[0] &= 0x7f;
-            const s = hexlify(vs_1);
-            if (result.s == null) {
-                result.s = s;
-            }
-            else if (result.s !== s) {
-                logger.throwArgumentError('signature v mismatch _vs', 'signature', signature);
-            }
-        }
-        if (result.recoveryParam == null) {
-            if (result.v == null) {
-                logger.throwArgumentError('signature missing v and recoveryParam', 'signature', signature);
-            }
-            else if (result.v === 0 || result.v === 1) {
-                result.recoveryParam = result.v;
-            }
-            else {
-                result.recoveryParam = 1 - (result.v % 2);
-            }
-        }
-        else {
-            if (result.v == null) {
-                result.v = 27 + result.recoveryParam;
-            }
-            else {
-                const recId = result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
-                if (result.recoveryParam !== recId) {
-                    logger.throwArgumentError('signature recoveryParam mismatch v', 'signature', signature);
-                }
-            }
-        }
-        if (result.r == null || !isHexString(result.r)) {
-            logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
-        }
-        else {
-            result.r = hexZeroPad(result.r, 32);
-        }
-        if (result.s == null || !isHexString(result.s)) {
-            logger.throwArgumentError('signature missing or invalid s', 'signature', signature);
-        }
-        else {
-            result.s = hexZeroPad(result.s, 32);
-        }
-        const vs = arrayify(result.s);
-        if (vs[0] >= 128) {
-            logger.throwArgumentError('signature s out of range', 'signature', signature);
-        }
-        if (result.recoveryParam) {
-            vs[0] |= 0x80;
-        }
-        const _vs = hexlify(vs);
-        if (result._vs) {
-            if (!isHexString(result._vs)) {
-                logger.throwArgumentError('signature invalid _vs', 'signature', signature);
-            }
-            result._vs = hexZeroPad(result._vs, 32);
-        }
-        if (result._vs == null) {
-            result._vs = _vs;
-        }
-        else if (result._vs !== _vs) {
-            logger.throwArgumentError('signature _vs mismatch v and s', 'signature', signature);
-        }
-    }
-    result.yParityAndS = result._vs;
-    result.compact = result.r + result.yParityAndS.substring(2);
-    return result;
-}

package/dist/esm/utils/to-checksum-address.d.ts

@@ -1 +0,0 @@
-export declare function toChecksumAddress(address: string): string;

package/dist/esm/utils/to-checksum-address.js

@@ -1,25 +0,0 @@
-import { Keccak } from 'sha3';
-import { validateType } from '../shared/validate-type';
-export function toChecksumAddress(address) {
-    validateType(address, ['string']);
-    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-        throw new Error(`Invalid Ethereum address "${address}"`);
-    }
-    const _address = address.toLowerCase().replace(/^0x/i, '');
-    const keccak = new Keccak(256);
-    const addressHash = keccak.update(_address).digest('hex').replace(/^0x/i, '');
-    let checksumAddress = '0x';
-    for (let i = 0; i < _address.length; i++) {
-        if (parseInt(addressHash[i], 16) > 7) {
-            checksumAddress += _address[i].toUpperCase();
-        }
-        else {
-            checksumAddress += _address[i];
-        }
-    }
-    if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) &&
-        checksumAddress !== address) {
-        throw new Error(`Invalid Checksum address for "${address}"`);
-    }
-    return checksumAddress;
-}

package/dist/esm/utils/to-utf8-bytes.d.ts

@@ -1 +0,0 @@
-export declare function toUtf8Bytes(data: string): Uint8Array;

package/dist/esm/utils/to-utf8-bytes.js

@@ -1,3 +0,0 @@
-export function toUtf8Bytes(data) {
-    return new Uint8Array(Buffer.from(data));
-}

package/dist/esm/utils/wei-to-ether.d.ts

@@ -1,3 +0,0 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

package/dist/esm/utils/wei-to-ether.js

@@ -1,16 +0,0 @@
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
-export function weiToEther(weiQuantity) {
-    validateType(weiQuantity, ['string', 'number', 'object']);
-    try {
-        let _weiQuantity = weiQuantity;
-        if (typeof weiQuantity === 'string' && weiQuantity.slice(0, 2) === '0x') {
-            _weiQuantity = BigInt(weiQuantity).toString();
-        }
-        const result = tinyBig(_weiQuantity).div('1000000000000000000');
-        return tinyBig(result);
-    }
-    catch (error) {
-        throw error;
-    }
-}