essential-eth 0.5.9 → 0.5.10-next.0

package/lib/esm/shared/tiny-big/helpers.js

@@ -1,58 +0,0 @@
-function stripTrailingZeroes(numberString) {
-    const isNegative = numberString.startsWith('-');
-    numberString = numberString.replace('-', '');
-    numberString = numberString.replace(/\.0*$/g, '');
-    numberString = numberString.replace(/^0+/, '');
-    if (numberString.includes('.')) {
-        numberString = numberString.replace(/0+$/, '');
-    }
-    if (numberString.startsWith('.')) {
-        numberString = `0${numberString}`;
-    }
-    return `${isNegative ? '-' : ''}${numberString}`;
-}
-export function scientificStrToDecimalStr(scientificString) {
-    if (!scientificString.match(/e/i)) {
-        return stripTrailingZeroes(scientificString);
-    }
-    let [base, power] = scientificString.split(/e/i);
-    const isNegative = Number(base) < 0;
-    base = base.replace('-', '');
-    base = stripTrailingZeroes(base);
-    const [wholeNumber, fraction = ''] = base.split('.');
-    if (Number(power) === 0) {
-        return `${isNegative ? '-' : ''}${stripTrailingZeroes(base)}`;
-    }
-    else {
-        const includesDecimal = base.includes('.');
-        if (!includesDecimal) {
-            base = `${base}.`;
-        }
-        base = base.replace('.', '');
-        const baseLength = base.length;
-        let splitPaddedNumber;
-        if (Number(power) < 0) {
-            if (wholeNumber.length < Math.abs(Number(power))) {
-                base = base.padStart(baseLength + Math.abs(Number(power)) - wholeNumber.length, '0');
-            }
-            splitPaddedNumber = base.split('');
-            if (wholeNumber.length < Math.abs(Number(power))) {
-                splitPaddedNumber = ['.', ...splitPaddedNumber];
-            }
-            else {
-                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
-            }
-        }
-        else {
-            if (fraction.length < Math.abs(Number(power))) {
-                base = base.padEnd(baseLength + Math.abs(Number(power)) - fraction.length, '0');
-            }
-            splitPaddedNumber = base.split('');
-            if (fraction.length > Math.abs(Number(power))) {
-                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
-            }
-        }
-        const toReturn = stripTrailingZeroes(splitPaddedNumber.join(''));
-        return `${isNegative ? '-' : ''}${toReturn}`;
-    }
-}

package/lib/esm/shared/tiny-big/tiny-big.js

@@ -1,45 +0,0 @@
-import Big from 'big.js';
-import { hexToDecimal } from '../../classes/utils/hex-to-decimal';
-import { scientificStrToDecimalStr } from './helpers';
-export class TinyBig extends Big {
-    constructor(value) {
-        if (typeof value === 'string' && value.startsWith('0x')) {
-            value = hexToDecimal(value);
-        }
-        super(value);
-        this.padAndChop = (str, padChar, length) => {
-            return (Array(length).fill(padChar).join('') + str).slice(length * -1);
-        };
-    }
-    toHexString() {
-        return `0x${BigInt(this.toString()).toString(16)}`;
-    }
-    toNumber() {
-        return Number(scientificStrToDecimalStr(super.toString()));
-    }
-    toString() {
-        if (this.toNumber() === 0) {
-            return '0';
-        }
-        return scientificStrToDecimalStr(super.toString());
-    }
-    toTwos(bitCount) {
-        let binaryStr;
-        if (this.gte(0)) {
-            const twosComp = this.toNumber().toString(2);
-            binaryStr = this.padAndChop(twosComp, '0', bitCount || twosComp.length);
-        }
-        else {
-            binaryStr = this.plus(Math.pow(2, bitCount)).toNumber().toString(2);
-            if (Number(binaryStr) < 0) {
-                throw new Error('Cannot calculate twos complement');
-            }
-        }
-        const binary = `0b${binaryStr}`;
-        const decimal = Number(binary);
-        return tinyBig(decimal);
-    }
-}
-export function tinyBig(value) {
-    return new TinyBig(value);
-}

package/lib/esm/shared/validate-type.d.ts

@@ -1,3 +0,0 @@
-declare type JSPrimitiveTypes = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
-export declare const validateType: (value: unknown, allowedTypes: JSPrimitiveTypes[]) => void;
-export {};

package/lib/esm/shared/validate-type.js

@@ -1,5 +0,0 @@
-export const validateType = (value, allowedTypes) => {
-    if (!allowedTypes.includes(typeof value)) {
-        throw new Error(`${allowedTypes.join(' or ')} required. Received ${typeof value}`);
-    }
-};

package/lib/esm/types/Block.types.d.ts

@@ -1,40 +0,0 @@
-import { TinyBig } from './../shared/tiny-big/tiny-big';
-import { BlockTransactionResponse, RPCTransaction } from './Transaction.types';
-declare type Modify<T, R> = Omit<T, keyof R> & R;
-export declare type BlockResponse = Modify<RPCBlock, {
-    baseFeePerGas: TinyBig;
-    difficulty: TinyBig;
-    gasLimit: TinyBig;
-    gasUsed: TinyBig;
-    nonce: TinyBig;
-    number: number;
-    size: TinyBig;
-    timestamp: TinyBig;
-    totalDifficulty: TinyBig;
-    transactions: Array<string | BlockTransactionResponse>;
-}>;
-export interface RPCBlock {
-    baseFeePerGas: string;
-    difficulty: string;
-    extraData: string;
-    gasLimit: string;
-    gasUsed: string;
-    hash: string;
-    logsBloom: string;
-    miner: string;
-    mixHash: string;
-    nonce: string;
-    number: string;
-    parentHash: string;
-    receiptsRoot: string;
-    sha3Uncles: string;
-    size: string;
-    stateRoot: string;
-    timestamp: string;
-    totalDifficulty: string;
-    transactions: Array<string | RPCTransaction>;
-    transactionsRoot: string;
-    uncles: Array<string>;
-}
-export declare type BlockTag = 'latest' | 'earliest' | 'pending' | number | string;
-export {};

package/lib/esm/types/Block.types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/types/Contract.types.d.ts

@@ -1,24 +0,0 @@
-export declare type ContractTypes = 'bool' | 'bytes1' | 'bytes2' | 'bytes3' | 'bytes4' | 'bytes5' | 'bytes6' | 'bytes7' | 'bytes8' | 'bytes9' | 'bytes10' | 'bytes11' | 'bytes12' | 'bytes13' | 'bytes14' | 'bytes15' | 'bytes16' | 'bytes17' | 'bytes18' | 'bytes19' | 'bytes20' | 'bytes21' | 'bytes22' | 'bytes23' | 'bytes24' | 'bytes25' | 'bytes26' | 'bytes27' | 'bytes28' | 'bytes29' | 'bytes30' | 'bytes31' | 'bytes32' | 'bytes32[]' | 'address' | 'address payable' | 'address[4]' | 'address[100]' | 'uint256' | 'uint256[100]' | 'uint8' | 'uint32' | string;
-export declare type ContractInterface = JSONABI;
-export declare type ContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
-export interface JSONABIArgument {
-    anonymous?: false;
-    inputs: {
-        internalType?: ContractTypes | string;
-        name: string;
-        type: ContractTypes;
-        indexed?: boolean;
-    }[];
-    name?: string;
-    outputs?: {
-        internalType?: ContractTypes | string;
-        name: string;
-        type: ContractTypes;
-    }[];
-    stateMutability?: 'view' | 'nonpayable' | string;
-    type: 'function' | 'event' | 'constructor' | 'error' | 'fallback';
-    gas?: number;
-    constant?: boolean;
-    payable?: boolean;
-}
-export declare type JSONABI = JSONABIArgument[];

package/lib/esm/types/Contract.types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/types/Filter.types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/types/Network.types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/types/Transaction.types.js

@@ -1 +0,0 @@
-export {};

package/lib/esm/utils/bytes.js

@@ -1,245 +0,0 @@
-import { logger } from '../logger/logger';
-function isHexable(value) {
-    return !!value.toHexString;
-}
-export function isBytesLike(value) {
-    return (isHexString(value) && !(value.length % 2)) || isBytes(value);
-}
-function isInteger(value) {
-    return typeof value === 'number' && value == value && value % 1 === 0;
-}
-export function isBytes(value) {
-    if (value == null) {
-        return false;
-    }
-    if (value.constructor === Uint8Array) {
-        return true;
-    }
-    if (typeof value === 'string') {
-        return false;
-    }
-    if (!isInteger(value.length) || value.length < 0) {
-        return false;
-    }
-    for (let i = 0; i < value.length; i++) {
-        const v = value[i];
-        if (!isInteger(v) || v < 0 || v >= 256) {
-            return false;
-        }
-    }
-    return true;
-}
-export function arrayify(value, options) {
-    if (!options) {
-        options = {};
-    }
-    if (typeof value === 'number') {
-        logger.checkSafeUint53(value, 'invalid arrayify value');
-        const result = [];
-        while (value) {
-            result.unshift(value & 0xff);
-            value = parseInt(String(value / 256));
-        }
-        if (result.length === 0) {
-            result.push(0);
-        }
-        return new Uint8Array(result);
-    }
-    if (options.allowMissingPrefix &&
-        typeof value === 'string' &&
-        value.substring(0, 2) !== '0x') {
-        value = '0x' + value;
-    }
-    if (isHexable(value)) {
-        value = value.toHexString();
-    }
-    if (isHexString(value)) {
-        let hex = value.substring(2);
-        if (hex.length % 2) {
-            if (options.hexPad === 'left') {
-                hex = '0' + hex;
-            }
-            else if (options.hexPad === 'right') {
-                hex += '0';
-            }
-            else {
-                logger.throwArgumentError('hex data is odd-length', 'value', value);
-            }
-        }
-        const result = [];
-        for (let i = 0; i < hex.length; i += 2) {
-            result.push(parseInt(hex.substring(i, i + 2), 16));
-        }
-        return new Uint8Array(result);
-    }
-    if (isBytes(value)) {
-        return new Uint8Array(value);
-    }
-    return logger.throwArgumentError('invalid arrayify value', 'value', value);
-}
-export function concat(arrayOfBytesLike) {
-    const objects = arrayOfBytesLike.map((item) => arrayify(item));
-    const length = objects.reduce((accum, item) => accum + item.length, 0);
-    const result = new Uint8Array(length);
-    objects.reduce((offset, object) => {
-        result.set(object, offset);
-        return offset + object.length;
-    }, 0);
-    return result;
-}
-export function stripZeros(value) {
-    let result = arrayify(value);
-    if (result.length === 0) {
-        return result;
-    }
-    let start = 0;
-    while (start < result.length && result[start] === 0) {
-        start++;
-    }
-    if (start) {
-        result = result.slice(start);
-    }
-    return result;
-}
-export function zeroPad(value, length) {
-    value = arrayify(value);
-    if (value.length > length) {
-        logger.throwArgumentError('value out of range', 'value', value);
-    }
-    const result = new Uint8Array(length);
-    result.set(value, length - value.length);
-    return result;
-}
-export function isHexString(value, length) {
-    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-        return false;
-    }
-    if (length && value.length !== 2 + 2 * length) {
-        return false;
-    }
-    return true;
-}
-const HexCharacters = '0123456789abcdef';
-export function hexlify(value, options) {
-    if (!options) {
-        options = {};
-    }
-    if (typeof value === 'number') {
-        logger.checkSafeUint53(value, 'invalid hexlify value');
-        let hex = '';
-        while (value) {
-            hex = HexCharacters[value & 0xf] + hex;
-            value = Math.floor(value / 16);
-        }
-        if (hex.length) {
-            if (hex.length % 2) {
-                hex = '0' + hex;
-            }
-            return '0x' + hex;
-        }
-        return '0x00';
-    }
-    if (typeof value === 'bigint') {
-        value = value.toString(16);
-        if (value.length % 2) {
-            return '0x0' + value;
-        }
-        return '0x' + value;
-    }
-    if (options.allowMissingPrefix &&
-        typeof value === 'string' &&
-        value.substring(0, 2) !== '0x') {
-        value = '0x' + value;
-    }
-    if (isHexable(value)) {
-        return value.toHexString();
-    }
-    if (isHexString(value)) {
-        if (value.length % 2) {
-            if (options.hexPad === 'left') {
-                value = '0x0' + value.substring(2);
-            }
-            else if (options.hexPad === 'right') {
-                value += '0';
-            }
-            else {
-                logger.throwArgumentError('hex data is odd-length', 'value', value);
-            }
-        }
-        return value.toLowerCase();
-    }
-    if (isBytes(value)) {
-        let result = '0x';
-        for (let i = 0; i < value.length; i++) {
-            const v = value[i];
-            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
-        }
-        return result;
-    }
-    return logger.throwArgumentError('invalid hexlify value', 'value', value);
-}
-export function hexDataLength(data) {
-    if (typeof data !== 'string') {
-        data = hexlify(data);
-    }
-    else if (!isHexString(data) || data.length % 2) {
-        return null;
-    }
-    return (data.length - 2) / 2;
-}
-export function hexDataSlice(data, offset, endOffset) {
-    if (typeof data !== 'string') {
-        data = hexlify(data);
-    }
-    else if (!isHexString(data) || data.length % 2) {
-        logger.throwArgumentError('invalid hexData', 'value', data);
-    }
-    offset = 2 + 2 * offset;
-    if (endOffset != null) {
-        return '0x' + data.substring(offset, 2 + 2 * endOffset);
-    }
-    return '0x' + data.substring(offset);
-}
-export function hexConcat(items) {
-    let result = '0x';
-    items.forEach((item) => {
-        result += hexlify(item).substring(2);
-    });
-    return result;
-}
-export function hexValue(value) {
-    const trimmed = hexStripZeros(hexlify(value, { hexPad: 'left' }));
-    if (trimmed === '0x') {
-        return '0x0';
-    }
-    return trimmed;
-}
-export function hexStripZeros(value) {
-    if (typeof value !== 'string') {
-        value = hexlify(value);
-    }
-    if (!isHexString(value)) {
-        logger.throwArgumentError('invalid hex string', 'value', value);
-    }
-    value = value.substring(2);
-    let offset = 0;
-    while (offset < value.length && value[offset] === '0') {
-        offset++;
-    }
-    return '0x' + value.substring(offset);
-}
-export function hexZeroPad(value, length) {
-    if (typeof value !== 'string') {
-        value = hexlify(value);
-    }
-    else if (!isHexString(value)) {
-        logger.throwArgumentError('invalid hex string', 'value', value);
-    }
-    if (value.length > 2 * length + 2) {
-        logger.throwError('value out of range', { value, length });
-    }
-    while (value.length < 2 * length + 2) {
-        value = '0x0' + value.substring(2);
-    }
-    return value;
-}

package/lib/esm/utils/compute-address.js

@@ -1,11 +0,0 @@
-import { computePublicKey, toChecksumAddress } from '..';
-import { hexDataSlice } from './bytes';
-import { keccak256 } from './keccak256';
-export function computeAddress(key) {
-    if (!key.startsWith('0x04') &&
-        !key.startsWith('0x03') &&
-        !key.startsWith('0x02')) {
-        key = computePublicKey(key);
-    }
-    return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
-}

package/lib/esm/utils/compute-public-key.js

@@ -1,6 +0,0 @@
-import { Point } from '@noble/secp256k1';
-import { hexlify } from './bytes';
-export function computePublicKey(privKey) {
-    privKey = hexlify(privKey).slice(2);
-    return '0x' + Point.fromPrivateKey(privKey).toHex();
-}

package/lib/esm/utils/ether-to-gwei.js

@@ -1,7 +0,0 @@
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
-export function etherToGwei(etherQuantity) {
-    validateType(etherQuantity, ['string', 'number', 'object']);
-    const result = tinyBig(etherQuantity).times('1000000000');
-    return tinyBig(result);
-}

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

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

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

@@ -1,7 +0,0 @@
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
-export function etherToWei(etherQuantity) {
-    validateType(etherQuantity, ['string', 'number', 'object']);
-    const result = tinyBig(etherQuantity).times('1000000000000000000');
-    return tinyBig(result);
-}

package/lib/esm/utils/gwei-to-ether.d.ts

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

package/lib/esm/utils/gwei-to-ether.js

@@ -1,7 +0,0 @@
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
-export function gweiToEther(gweiQuantity) {
-    validateType(gweiQuantity, ['string', 'number', 'object']);
-    const result = tinyBig(gweiQuantity).div('1000000000');
-    return tinyBig(result);
-}

package/lib/esm/utils/hash-message.js

@@ -1,12 +0,0 @@
-import { concat, keccak256, toUtf8Bytes } from '../index';
-const messagePrefix = '\x19Ethereum Signed Message:\n';
-export function hashMessage(message) {
-    if (typeof message === 'string') {
-        message = toUtf8Bytes(message);
-    }
-    return keccak256(concat([
-        toUtf8Bytes(messagePrefix),
-        toUtf8Bytes(String(message.length)),
-        message,
-    ]));
-}

package/lib/esm/utils/is-address.js

@@ -1,12 +0,0 @@
-import { toChecksumAddress } from '..';
-import { validateType } from '../shared/validate-type';
-export function isAddress(address) {
-    validateType(address, ['string']);
-    try {
-        toChecksumAddress(address);
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}

package/lib/esm/utils/keccak256.js

@@ -1,13 +0,0 @@
-import { Keccak } from 'sha3';
-export function keccak256(data) {
-    let bufferableData;
-    if (typeof data === 'string') {
-        bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
-    }
-    else {
-        bufferableData = Buffer.from(data);
-    }
-    const keccak = new Keccak(256);
-    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
-    return addressHash;
-}

package/lib/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));
-}