essential-eth 0.10.3 → 0.10.4-beta.0

package/dist/esm/classes/utils/clean-block.js

@@ -1,35 +0,0 @@
-import { tinyBig } from '../../shared/tiny-big/tiny-big';
-import { toChecksumAddress } from '../../utils/to-checksum-address';
-import { cleanTransaction } from './clean-transaction';
-import { hexToDecimal } from './hex-to-decimal';
-export function cleanBlock(block, returnTransactionObjects) {
-    const cleanedBlock = { ...block };
-    Object.keys(block).forEach((key) => {
-        if (!block[key])
-            return;
-        switch (key) {
-            case 'difficulty':
-            case 'totalDifficulty':
-            case 'gasLimit':
-            case 'gasUsed':
-            case 'size':
-            case 'timestamp':
-            case 'baseFeePerGas':
-                cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
-                break;
-            case 'number':
-                cleanedBlock[key] = Number(hexToDecimal(block[key]));
-                break;
-            case 'miner':
-                cleanedBlock[key] = toChecksumAddress(block[key]);
-                break;
-        }
-    });
-    if (returnTransactionObjects) {
-        const txns = block.transactions;
-        txns.forEach((transaction, index) => {
-            cleanedBlock.transactions[index] = cleanTransaction(transaction);
-        });
-    }
-    return cleanedBlock;
-}

package/dist/esm/classes/utils/clean-log.d.ts

@@ -1,2 +0,0 @@
-import type { Log, RPCLog } from './../../types/Transaction.types';
-export declare function cleanLog(log: RPCLog, receiptLog: boolean): Log;

package/dist/esm/classes/utils/clean-log.js

@@ -1,28 +0,0 @@
-import { toChecksumAddress } from '../../utils/to-checksum-address';
-import { hexToDecimal } from './hex-to-decimal';
-export function cleanLog(log, receiptLog) {
-    const cleanedLog = {
-        ...log,
-    };
-    Object.keys(log).forEach((key) => {
-        switch (key) {
-            case 'address':
-                cleanedLog[key] = toChecksumAddress(log[key]);
-                break;
-            case 'blockNumber':
-            case 'logIndex':
-            case 'transactionIndex':
-                cleanedLog[key] = Number(hexToDecimal(log[key]));
-                break;
-            case 'removed':
-                if (receiptLog) {
-                    delete cleanedLog[key];
-                }
-                else if (log[key] == null) {
-                    cleanedLog[key] === false;
-                }
-                break;
-        }
-    });
-    return cleanedLog;
-}

package/dist/esm/classes/utils/clean-transaction-receipt.d.ts

@@ -1,2 +0,0 @@
-import type { RPCTransactionReceipt, TransactionReceipt } from '../../types/Transaction.types';
-export declare function cleanTransactionReceipt(transactionReceipt: RPCTransactionReceipt): TransactionReceipt;

package/dist/esm/classes/utils/clean-transaction-receipt.js

@@ -1,37 +0,0 @@
-import { tinyBig } from '../../shared/tiny-big/tiny-big';
-import { toChecksumAddress } from '../../utils/to-checksum-address';
-import { cleanLog } from './clean-log';
-import { cleanTransaction } from './clean-transaction';
-import { hexToDecimal } from './hex-to-decimal';
-export function cleanTransactionReceipt(transactionReceipt) {
-    const cleanedTransaction = cleanTransaction(transactionReceipt);
-    const cleanedTransactionReceipt = {
-        ...cleanedTransaction,
-    };
-    Object.keys(transactionReceipt).forEach((key) => {
-        if (!transactionReceipt[key])
-            return;
-        switch (key) {
-            case 'status':
-                cleanedTransactionReceipt[key] = Number(hexToDecimal(transactionReceipt[key]));
-                break;
-            case 'contractAddress':
-                if (transactionReceipt[key]) {
-                    cleanedTransactionReceipt[key] = toChecksumAddress(transactionReceipt[key]);
-                }
-                break;
-            case 'cumulativeGasUsed':
-            case 'effectiveGasPrice':
-            case 'gasUsed':
-                cleanedTransactionReceipt[key] = tinyBig(hexToDecimal(transactionReceipt[key]));
-                break;
-            case 'logs':
-                transactionReceipt[key].forEach((log, index) => {
-                    cleanedTransactionReceipt[key][index] = cleanLog(log, true);
-                });
-        }
-    });
-    cleanedTransactionReceipt.byzantium =
-        cleanedTransactionReceipt.blockNumber >= 4370000;
-    return cleanedTransactionReceipt;
-}

package/dist/esm/classes/utils/clean-transaction.d.ts

@@ -1,2 +0,0 @@
-import type { RPCTransaction, TransactionResponse } from '../../types/Transaction.types';
-export declare function cleanTransaction(transaction: RPCTransaction): TransactionResponse;

package/dist/esm/classes/utils/clean-transaction.js

@@ -1,36 +0,0 @@
-import { tinyBig } from '../../shared/tiny-big/tiny-big';
-import { toChecksumAddress } from '../../utils/to-checksum-address';
-import { hexToDecimal } from './hex-to-decimal';
-export function cleanTransaction(transaction) {
-    const cleanedTransaction = {
-        ...transaction,
-    };
-    Object.keys(transaction).forEach((key) => {
-        if (!transaction[key])
-            return;
-        switch (key) {
-            case 'blockNumber':
-            case 'chainId':
-            case 'transactionIndex':
-            case 'type':
-            case 'v':
-                cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
-                break;
-            case 'from':
-            case 'to':
-                if (transaction[key]) {
-                    cleanedTransaction[key] = toChecksumAddress(transaction[key]);
-                }
-                break;
-            case 'value':
-            case 'gas':
-            case 'gasPrice':
-            case 'maxFeePerGas':
-            case 'maxPriorityFeePerGas':
-            case 'nonce':
-                cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
-                break;
-        }
-    });
-    return cleanedTransaction;
-}

package/dist/esm/classes/utils/encode-decode-transaction.d.ts

@@ -1,4 +0,0 @@
-import type { JSONABIArgument } from '../../types/Contract.types';
-export declare const hexFalse: string;
-export declare function encodeData(jsonABIArgument: JSONABIArgument, args: any[]): string;
-export declare function decodeRPCResponse(jsonABIArgument: JSONABIArgument, nodeResponse: string): string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig | (string | number | boolean | import("../../shared/tiny-big/tiny-big").TinyBig)[];

package/dist/esm/classes/utils/encode-decode-transaction.js

@@ -1,143 +0,0 @@
-import { Keccak } from 'sha3';
-import { tinyBig } from '../../shared/tiny-big/tiny-big';
-import { toChecksumAddress } from '../../utils/to-checksum-address';
-import { hexToDecimal } from './hex-to-decimal';
-export const hexFalse = '0'.repeat(64);
-const hexTrue = '0'.repeat(63) + '1';
-function hexToUtf8(hex) {
-    let str = '';
-    let i = 0;
-    const l = hex.length;
-    if (hex.substring(0, 2) === '0x') {
-        i = 2;
-    }
-    for (; i < l; i += 2) {
-        const code = parseInt(hex.substr(i, 2), 16);
-        if (code === 0)
-            continue;
-        str += String.fromCharCode(code);
-    }
-    try {
-        return decodeURIComponent(escape(str));
-    }
-    catch (e) {
-        return str;
-    }
-}
-function expandType(type) {
-    if (type === 'uint[]') {
-        return 'uint256[]';
-    }
-    if (type === 'int[]') {
-        return 'int256[]';
-    }
-    return type;
-}
-export function encodeData(jsonABIArgument, args) {
-    const hash = new Keccak(256);
-    const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map((input) => expandType(input.type))})`;
-    const functionHash = hash.update(functionString).digest('hex');
-    const jsonABIInputsLength = jsonABIArgument.inputs.length;
-    let shouldValidateInputLength = true;
-    if (jsonABIArgument.inputs.find((input) => input.type.includes('['))) {
-        shouldValidateInputLength = false;
-    }
-    if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
-        throw new Error(`args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`);
-    }
-    const argsWithTypes = (jsonABIArgument.inputs || []).reduce((acc, input, i) => {
-        if (input.type.includes('[')) {
-            const basicType = /([^[]*)\[.*$/g.exec(input.type)?.[1];
-            args.forEach((arg) => {
-                acc = acc.concat([[arg, basicType]]);
-            });
-            return acc;
-        }
-        else {
-            return acc.concat([[args[i], input.type]]);
-        }
-    }, []);
-    const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
-        let rawArg = arg;
-        switch (inputType) {
-            case 'bool':
-                return arg ? hexTrue : hexFalse;
-            case 'address':
-                rawArg = arg.replace(/^0x/g, '').toLowerCase();
-                break;
-            default:
-                if (inputType.startsWith('bytes')) {
-                    if (Array.isArray(arg)) {
-                        throw new Error(`essential-eth does not yet support "${inputType}[]" inputs. Make a PR today!"`);
-                    }
-                    const argEncoded = BigInt(arg).toString(16);
-                    const paddedEncodedArg = argEncoded.padStart(64, '0');
-                    return paddedEncodedArg;
-                }
-                else if (inputType === 'uint256') {
-                    const argEncoded = BigInt(arg).toString(16);
-                    const paddedEncodedArg = argEncoded.padStart(64, '0');
-                    return paddedEncodedArg;
-                }
-                else if (inputType.startsWith('uint')) {
-                    break;
-                }
-                else {
-                    throw new Error(`essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`);
-                }
-        }
-        const argEncoded = rawArg.toString(16);
-        const paddedEncodedArg = argEncoded.padStart(64, '0');
-        return paddedEncodedArg;
-    });
-    const functionEncoded = functionHash.slice(0, 8);
-    const data = `0x${functionEncoded}${encodedArgs.join('')}`;
-    return data;
-}
-export function decodeRPCResponse(jsonABIArgument, nodeResponse) {
-    const rawOutputs = jsonABIArgument.outputs || [];
-    const slicedResponse = nodeResponse.slice(2);
-    if (rawOutputs.length === 1 && rawOutputs[0].type === 'string') {
-        const [hexOffset, responseData] = [
-            slicedResponse.slice(0, 64),
-            slicedResponse.slice(64),
-        ];
-        const decimalOffset = Number(hexToDecimal(`0x${hexOffset}`));
-        const hexLength = responseData.slice(0, decimalOffset * 2);
-        const decimalLength = Number(hexToDecimal(`0x${hexLength}`));
-        const hexToDecode = responseData.slice(decimalOffset * 2, decimalOffset * 2 + decimalLength * 2);
-        return hexToUtf8(hexToDecode);
-    }
-    const encodedOutputs = slicedResponse.match(/.{1,64}/g) || [];
-    if (rawOutputs.length === 1 && rawOutputs[0].type === 'address[]') {
-        const unformattedAddresses = encodedOutputs.slice(2);
-        return unformattedAddresses.map((unformattedAddress) => {
-            return toChecksumAddress(`0x${unformattedAddress.slice(24)}`);
-        });
-    }
-    if (rawOutputs?.length === 1 && rawOutputs[0].type === 'uint256[]') {
-        const outputs = encodedOutputs.slice(2);
-        return outputs.map((output) => {
-            return tinyBig(hexToDecimal(`0x${output}`));
-        });
-    }
-    const outputs = encodedOutputs.map((output, i) => {
-        const outputType = rawOutputs[i].type;
-        switch (outputType) {
-            case 'bool':
-                return output === hexTrue;
-            case 'address':
-                return toChecksumAddress(`0x${output.slice(24)}`);
-            case 'uint256':
-            case 'uint120':
-                return tinyBig(hexToDecimal(`0x${output}`));
-            case 'bytes32':
-                return `0x${output}`;
-            case 'uint8':
-                return Number(hexToDecimal(`0x${output}`));
-            default:
-                throw new Error(`essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`);
-        }
-    });
-    return outputs.length === 1 ? outputs[0] : outputs;
-}

package/dist/esm/classes/utils/fetchers.d.ts

@@ -1,15 +0,0 @@
-export declare function buildFetchInit<T>(body: T): {
-    method: string;
-    headers: {
-        'Content-Type': string;
-    };
-    body: string;
-};
-export declare function post(url: string, body: Record<string, unknown>): Promise<any>;
-export type RPCMethodName = 'eth_getBlockByNumber' | 'eth_getBlockByHash' | 'eth_call' | 'eth_chainId' | 'eth_gasPrice' | 'eth_getBalance' | 'eth_getTransactionByHash' | 'eth_getTransactionReceipt' | 'eth_getTransactionCount' | 'eth_getCode' | 'eth_blockNumber' | 'eth_estimateGas' | 'eth_getLogs';
-export declare function buildRPCPostBody(method: RPCMethodName, params: unknown[]): {
-    jsonrpc: string;
-    id: number;
-    method: RPCMethodName;
-    params: unknown[];
-};

package/dist/esm/classes/utils/fetchers.js

@@ -1,37 +0,0 @@
-import unfetch from 'isomorphic-unfetch';
-export function buildFetchInit(body) {
-    return {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(body),
-    };
-}
-export function post(url, body) {
-    return unfetch(url, buildFetchInit(body))
-        .then(async (r) => {
-        const t = await r.text();
-        try {
-            return JSON.parse(t);
-        }
-        catch {
-            throw new Error(`Invalid JSON RPC response: "${t}"`);
-        }
-    })
-        .then((response) => {
-        const result = response?.result;
-        if (!result) {
-            throw new Error(`Invalid JSON RPC response: ${JSON.stringify(response)}`);
-        }
-        return response.result;
-    });
-}
-export function buildRPCPostBody(method, params) {
-    return {
-        jsonrpc: '2.0',
-        id: 1,
-        method,
-        params,
-    };
-}

package/dist/esm/classes/utils/hex-to-decimal.d.ts

@@ -1 +0,0 @@
-export declare function hexToDecimal(hex: string): string;

package/dist/esm/classes/utils/hex-to-decimal.js

@@ -1,3 +0,0 @@
-export function hexToDecimal(hex) {
-    return BigInt(hex).toString();
-}

package/dist/esm/classes/utils/prepare-transaction.d.ts

@@ -1,2 +0,0 @@
-import type { RPCTransactionRequest, TransactionRequest } from './../../types/Transaction.types';
-export declare function prepareTransaction(transaction: TransactionRequest): RPCTransactionRequest;

package/dist/esm/classes/utils/prepare-transaction.js

@@ -1,36 +0,0 @@
-import Big from 'big.js';
-import { TinyBig } from '../../shared/tiny-big/tiny-big';
-import { hexlify } from '../../utils/bytes';
-export function prepareTransaction(transaction) {
-    const preparedTransaction = {
-        ...transaction,
-    };
-    Object.keys(transaction).forEach((key) => {
-        switch (key) {
-            case 'gas':
-            case 'gasPrice':
-            case 'nonce':
-            case 'maxFeePerGas':
-            case 'maxPriorityFeePerGas':
-            case 'value': {
-                const value = transaction[key];
-                if (value instanceof TinyBig) {
-                    preparedTransaction[key] = value.toHexString();
-                }
-                else if (value instanceof Big) {
-                    preparedTransaction[key] = `0x${BigInt(value.toString()).toString(16)}`;
-                }
-                else if (typeof transaction[key] === 'number')
-                    preparedTransaction[key] =
-                        '0x' + transaction[key].toString(16);
-                else
-                    preparedTransaction[key] = transaction[key].toString();
-                break;
-            }
-            case 'data':
-                preparedTransaction[key] = hexlify(transaction[key]);
-                break;
-        }
-    });
-    return preparedTransaction;
-}

package/dist/esm/index.d.ts

@@ -1,24 +0,0 @@
-export { BaseContract, Contract } from './classes/Contract';
-export { AlchemyProvider } from './providers/AlchemyProvider';
-export { ConstructorOptions, FallthroughProvider, } from './providers/FallthroughProvider';
-export { jsonRpcProvider, JsonRpcProvider } from './providers/JsonRpcProvider';
-export { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-export { BlockResponse, BlockTag, RPCBlock } from './types/Block.types';
-export { ContractTypes, JSONABI, JSONABIArgument, } from './types/Contract.types';
-export { Filter, FilterByBlockHash } from './types/Filter.types';
-export { Network } from './types/Network.types';
-export { BlockTransactionResponse, Log, RPCLog, RPCTransaction, RPCTransactionReceipt, RPCTransactionRequest, TransactionReceipt, TransactionRequest, TransactionResponse, } from './types/Transaction.types';
-export { arrayify, Bytes, BytesLike, BytesLikeWithNumber, concat, DataOptions, Hexable, hexConcat, hexDataLength, hexDataSlice, hexlify, hexStripZeros, hexValue, hexZeroPad, isBytes, isBytesLike, isHexString, Signature, SignatureLike, stripZeros, zeroPad, } from './utils/bytes';
-export { computeAddress } from './utils/compute-address';
-export { computePublicKey } from './utils/compute-public-key';
-export { etherToGwei } from './utils/ether-to-gwei';
-export { etherToWei } from './utils/ether-to-wei';
-export { gweiToEther } from './utils/gwei-to-ether';
-export { hashMessage } from './utils/hash-message';
-export { isAddress } from './utils/is-address';
-export { keccak256 } from './utils/keccak256';
-export { pack, solidityKeccak256 } from './utils/solidity-keccak256';
-export { splitSignature } from './utils/split-signature';
-export { toChecksumAddress } from './utils/to-checksum-address';
-export { toUtf8Bytes } from './utils/to-utf8-bytes';
-export { weiToEther } from './utils/wei-to-ether';

package/dist/esm/index.js

@@ -1,19 +0,0 @@
-export { BaseContract, Contract } from './classes/Contract';
-export { AlchemyProvider } from './providers/AlchemyProvider';
-export { FallthroughProvider, } from './providers/FallthroughProvider';
-export { jsonRpcProvider, JsonRpcProvider } from './providers/JsonRpcProvider';
-export { tinyBig, TinyBig } from './shared/tiny-big/tiny-big';
-export { arrayify, concat, hexConcat, hexDataLength, hexDataSlice, hexlify, hexStripZeros, hexValue, hexZeroPad, isBytes, isBytesLike, isHexString, stripZeros, zeroPad, } from './utils/bytes';
-export { computeAddress } from './utils/compute-address';
-export { computePublicKey } from './utils/compute-public-key';
-export { etherToGwei } from './utils/ether-to-gwei';
-export { etherToWei } from './utils/ether-to-wei';
-export { gweiToEther } from './utils/gwei-to-ether';
-export { hashMessage } from './utils/hash-message';
-export { isAddress } from './utils/is-address';
-export { keccak256 } from './utils/keccak256';
-export { pack, solidityKeccak256 } from './utils/solidity-keccak256';
-export { splitSignature } from './utils/split-signature';
-export { toChecksumAddress } from './utils/to-checksum-address';
-export { toUtf8Bytes } from './utils/to-utf8-bytes';
-export { weiToEther } from './utils/wei-to-ether';

package/dist/esm/logger/logger.d.ts

@@ -1,11 +0,0 @@
-declare class Logger {
-    private packageVersion;
-    constructor();
-    throwError(message: string, args: {
-        [key: string]: any;
-    }): never;
-    throwArgumentError(message: string, arg: string, value: any): never;
-    checkSafeUint53(value: number, message?: string): void;
-}
-export declare const logger: Logger;
-export {};

package/dist/esm/logger/logger.js

@@ -1,34 +0,0 @@
-import { version } from './package-version';
-class Logger {
-    packageVersion;
-    constructor() {
-        this.packageVersion = version;
-    }
-    throwError(message, args) {
-        const argsLength = Object.keys(args).length;
-        throw new Error(`${message} (${Object.entries(args).map(([key, value], index) => `${key}=${value}${index < argsLength - 1 && ', '}`)}, version=essential-eth@${this.packageVersion})`);
-    }
-    throwArgumentError(message, arg, value) {
-        throw new Error(`${message} (argument="${arg}" value=${value}, version=essential-eth@${this.packageVersion})`);
-    }
-    checkSafeUint53(value, message = 'value not safe') {
-        if (typeof value !== 'number') {
-            return;
-        }
-        if (value < 0 || value >= 0x1fffffffffffff) {
-            this.throwError(message, {
-                operation: 'checkSafeInteger',
-                fault: 'out-of-safe-range',
-                value: value,
-            });
-        }
-        if (value % 1) {
-            this.throwError(message, {
-                operation: 'checkSafeInteger',
-                fault: 'non-integer',
-                value: value,
-            });
-        }
-    }
-}
-export const logger = new Logger();

package/dist/esm/logger/package-version.d.ts

@@ -1 +0,0 @@
-export declare const version = "0.10.3";

package/dist/esm/logger/package-version.js

@@ -1 +0,0 @@
-export const version = '0.10.3';

package/dist/esm/providers/AlchemyProvider.d.ts

@@ -1,4 +0,0 @@
-import { JsonRpcProvider } from './JsonRpcProvider';
-export declare class AlchemyProvider extends JsonRpcProvider {
-    constructor(apiKey: string, network?: string);
-}

package/dist/esm/providers/AlchemyProvider.js

@@ -1,7 +0,0 @@
-import { JsonRpcProvider } from './JsonRpcProvider';
-export class AlchemyProvider extends JsonRpcProvider {
-    constructor(apiKey, network = 'mainnet') {
-        const alchemyUrl = `https://eth-${network}.alchemyapi.io/v2/${apiKey}`;
-        super(alchemyUrl);
-    }
-}

package/dist/esm/providers/BaseProvider.d.ts

@@ -1,26 +0,0 @@
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-import type { BlockResponse, BlockTag } from '../types/Block.types';
-import type { FeeData } from '../types/FeeData.types';
-import type { Filter, FilterByBlockHash } from '../types/Filter.types';
-import type { Network } from '../types/Network.types';
-import type { Log, TransactionReceipt, TransactionRequest, TransactionResponse } from '../types/Transaction.types';
-export declare abstract class BaseProvider {
-    abstract selectRpcUrl(): string;
-    abstract post(body: Record<string, unknown>): Promise<any>;
-    readonly _rpcUrls: string[];
-    protected _post: (body: Record<string, unknown>) => Promise<any>;
-    constructor(rpcUrls: string[]);
-    getNetwork(): Promise<Network>;
-    getBlockNumber(): Promise<number>;
-    getTransaction(transactionHash: string): Promise<TransactionResponse>;
-    getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
-    getTransactionCount(address: string, blockTag?: BlockTag): Promise<number>;
-    getBlock(timeFrame?: BlockTag, returnTransactionObjects?: boolean): Promise<BlockResponse>;
-    getGasPrice(): Promise<TinyBig>;
-    getBalance(address: string, blockTag?: BlockTag): Promise<TinyBig>;
-    getCode(address: string, blockTag?: BlockTag): Promise<string>;
-    estimateGas(transaction: TransactionRequest): Promise<TinyBig>;
-    getFeeData(): Promise<FeeData>;
-    getLogs(filter: Filter | FilterByBlockHash): Promise<Array<Log>>;
-    call(transaction: TransactionRequest, blockTag?: BlockTag): Promise<string>;
-}