essential-eth 0.9.2-beta.1 → 0.9.2-beta.3

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

@@ -0,0 +1,40 @@
+import type { TinyBig } from './../shared/tiny-big/tiny-big';
+import type { BlockTransactionResponse, RPCTransaction } from './Transaction.types';
+type Modify<T, R> = Omit<T, keyof R> & R;
+export 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 type BlockTag = 'latest' | 'earliest' | 'pending' | number | string;
+export {};

package/dist/esm/types/Block.types.js

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

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

@@ -0,0 +1,24 @@
+export 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 type ContractInterface = JSONABI;
+export 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 type JSONABI = JSONABIArgument[];

package/dist/esm/types/Contract.types.js

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

package/dist/esm/types/FeeData.types.d.ts

@@ -0,0 +1,7 @@
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+export interface FeeData {
+    gasPrice: TinyBig;
+    lastBaseFeePerGas: TinyBig | null;
+    maxFeePerGas: TinyBig | null;
+    maxPriorityFeePerGas: TinyBig | null;
+}

package/dist/esm/types/FeeData.types.js

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

package/dist/esm/types/Filter.types.d.ts

@@ -0,0 +1,12 @@
+import type { BlockTag } from './Block.types';
+export interface EventFilter {
+    address?: string;
+    topics?: Array<string | Array<string> | null>;
+}
+export interface Filter extends EventFilter {
+    fromBlock?: BlockTag;
+    toBlock?: BlockTag;
+}
+export interface FilterByBlockHash extends EventFilter {
+    blockHash?: string;
+}

package/dist/esm/types/Filter.types.js

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

package/dist/esm/types/Network.types.d.ts

@@ -0,0 +1,5 @@
+export interface Network {
+    chainId: number;
+    ensAddress: string | null;
+    name: string;
+}

package/dist/esm/types/Network.types.js

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

package/dist/esm/types/Transaction.types.d.ts

@@ -0,0 +1,113 @@
+import type Big from 'big.js';
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+import type { BytesLike } from './../utils/bytes';
+type Modify<T, R> = Omit<T, keyof R> & R;
+export interface RPCTransaction extends RPCBlockTransaction {
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+}
+export type TransactionResponse = Modify<RPCTransaction, {
+    blockNumber: number;
+    chainId: number;
+    gas: TinyBig;
+    gasLimit: TinyBig;
+    gasPrice: TinyBig;
+    nonce: TinyBig;
+    transactionIndex: number;
+    type: number;
+    v: number;
+    value: TinyBig;
+} & {
+    maxFeePerGas: TinyBig;
+    maxPriorityFeePerGas: TinyBig;
+    confirmations: number;
+}>;
+export type TransactionReceipt = Modify<RPCTransactionReceipt, {
+    blockNumber: number;
+    cumulativeGasUsed: TinyBig;
+    effectiveGasPrice: TinyBig;
+    gasUsed: TinyBig;
+    logs: Array<Log>;
+    status: number;
+    transactionIndex: number;
+    type: number;
+} & {
+    byzantium: boolean;
+    confirmations: number;
+}>;
+export interface RPCTransactionRequest {
+    from?: string;
+    to: string;
+    gas?: string;
+    gasPrice?: string;
+    value?: string;
+    data?: BytesLike;
+    nonce?: string;
+    maxPriorityFeePerGas?: string;
+    maxFeePerGas?: string;
+}
+export interface TransactionRequest {
+    to?: string;
+    from?: string;
+    nonce?: TinyBig | string | Big | number;
+    gas?: TinyBig | number | Big | string;
+    gasPrice?: TinyBig | Big | string | number;
+    data?: BytesLike;
+    value?: TinyBig | string | Big | number;
+    chainId?: number;
+    type?: number;
+    maxPriorityFeePerGas?: TinyBig | string | Big | number;
+    maxFeePerGas?: TinyBig | string | Big | number;
+}
+export type Log = Modify<RPCLog, {
+    blockNumber: number;
+    logIndex: number;
+    transactionIndex: number;
+}>;
+export type BlockTransactionResponse = Omit<TransactionResponse, 'maxFeePerGas' | 'maxPriorityFeePerGas'>;
+export interface RPCBlockTransaction {
+    blockHash: string;
+    blockNumber: string;
+    chainId: string;
+    from: string;
+    gas: string;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: string;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: string;
+    type: string;
+    v: string;
+    value: string;
+}
+export interface RPCTransactionReceipt {
+    blockHash: string;
+    blockNumber: string;
+    contractAddress: string;
+    cumulativeGasUsed: string;
+    effectiveGasPrice: string;
+    from: string;
+    gasUsed: string;
+    logs: Array<RPCLog>;
+    logsBloom: string;
+    status: string;
+    to: string;
+    transactionHash: string;
+    transactionIndex: string;
+    type: string;
+}
+export interface RPCLog {
+    address: string;
+    blockHash: string;
+    blockNumber: string;
+    data: string;
+    logIndex: string;
+    removed?: boolean;
+    topics: Array<string>;
+    transactionHash: string;
+    transactionIndex: string;
+}
+export {};

package/dist/esm/types/Transaction.types.js

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

package/dist/esm/utils/bytes.d.ts

@@ -0,0 +1,40 @@
+export type Bytes = ArrayLike<number>;
+export type BytesLike = Bytes | string;
+export type BytesLikeWithNumber = BytesLike | number;
+export interface DataOptions {
+    allowMissingPrefix?: boolean;
+    hexPad?: 'left' | 'right' | null;
+}
+export interface Hexable {
+    toHexString(): string;
+}
+export type SignatureLike = {
+    r: string;
+    s?: string;
+    _vs?: string;
+    recoveryParam?: number;
+    v?: number;
+} | BytesLike;
+export interface Signature {
+    r: string;
+    s: string;
+    _vs: string;
+    recoveryParam: number;
+    v: number;
+    yParityAndS: string;
+    compact: string;
+}
+export declare function isBytesLike(value: any): value is BytesLike;
+export declare function isBytes(value: any): value is Bytes;
+export declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
+export declare function concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
+export declare function stripZeros(value: BytesLike): Uint8Array;
+export declare function zeroPad(value: BytesLike, length: number): Uint8Array;
+export declare function isHexString(value: any, length?: number): boolean;
+export declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
+export declare function hexDataLength(data: BytesLike): number | null;
+export declare function hexDataSlice(data: BytesLikeWithNumber, offset: number, endOffset?: number): string;
+export declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
+export declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
+export declare function hexStripZeros(value: BytesLike): string;
+export declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;

package/dist/esm/utils/bytes.js

@@ -0,0 +1,245 @@
+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/dist/esm/utils/compute-address.d.ts

@@ -0,0 +1 @@
+export declare function computeAddress(key: string): string;

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

@@ -0,0 +1,12 @@
+import { hexDataSlice } from './bytes';
+import { computePublicKey } from './compute-public-key';
+import { keccak256 } from './keccak256';
+import { toChecksumAddress } from './to-checksum-address';
+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/dist/esm/utils/compute-public-key.d.ts

@@ -0,0 +1,2 @@
+import type { BytesLike } from './bytes';
+export declare function computePublicKey(privKey: BytesLike): string;

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

@@ -0,0 +1,6 @@
+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/dist/esm/utils/ether-to-gwei.d.ts

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

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

@@ -0,0 +1,7 @@
+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/dist/esm/utils/ether-to-wei.d.ts

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

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

@@ -0,0 +1,7 @@
+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/dist/esm/utils/gwei-to-ether.d.ts

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

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

@@ -0,0 +1,7 @@
+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/dist/esm/utils/hash-message.d.ts

@@ -0,0 +1,2 @@
+import type { Bytes } from './bytes';
+export declare function hashMessage(message: Bytes | string): string;

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

@@ -0,0 +1,14 @@
+import { concat } from './bytes';
+import { keccak256 } from './keccak256';
+import { toUtf8Bytes } from './to-utf8-bytes';
+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/dist/esm/utils/is-address.d.ts

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

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

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

package/dist/esm/utils/keccak256.d.ts

@@ -0,0 +1,2 @@
+import type { BytesLike } from './bytes';
+export declare function keccak256(data: BytesLike): string;

package/dist/esm/utils/keccak256.js

@@ -0,0 +1,13 @@
+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/dist/esm/utils/solidity-keccak256.d.ts

@@ -0,0 +1,2 @@
+export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+export declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;