essential-eth 0.9.1 → 0.9.2-beta.1

package/dist/esm/providers/BaseProvider.js

@@ -1,172 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { cleanBlock } from '../classes/utils/clean-block';
-import { cleanLog } from '../classes/utils/clean-log';
-import { cleanTransaction } from '../classes/utils/clean-transaction';
-import { cleanTransactionReceipt } from '../classes/utils/clean-transaction-receipt';
-import { buildRPCPostBody, post } from '../classes/utils/fetchers';
-import { hexToDecimal } from '../classes/utils/hex-to-decimal';
-import { prepareTransaction } from '../classes/utils/prepare-transaction';
-import { logger } from '../logger/logger';
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import chainsInfo from './utils/chains-info';
-function prepBlockTag(blockTag) {
-    return typeof blockTag === 'number'
-        ? tinyBig(blockTag).toHexString()
-        : blockTag;
-}
-export class BaseProvider {
-    constructor(rpcUrls) {
-        this._rpcUrls = [];
-        this._post = (body) => post(this.selectRpcUrl(), body);
-        this._rpcUrls = rpcUrls;
-    }
-    getNetwork() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hexChainId = (yield this.post(buildRPCPostBody('eth_chainId', [])));
-            const chainId = hexToDecimal(hexChainId);
-            const info = chainsInfo[chainId];
-            return {
-                chainId: Number(chainId),
-                name: info[0] || 'unknown',
-                ensAddress: info[1] || null,
-            };
-        });
-    }
-    getBlockNumber() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const currentBlockNumber = (yield this.post(buildRPCPostBody('eth_blockNumber', [])));
-            return Number(hexToDecimal(currentBlockNumber));
-        });
-    }
-    getTransaction(transactionHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [rpcTransaction, blockNumber] = yield Promise.all([
-                this.post(buildRPCPostBody('eth_getTransactionByHash', [transactionHash])),
-                this.getBlock('latest'),
-            ]);
-            const cleanedTransaction = cleanTransaction(rpcTransaction);
-            cleanedTransaction.confirmations =
-                blockNumber.number - cleanedTransaction.blockNumber + 1;
-            return cleanedTransaction;
-        });
-    }
-    getTransactionReceipt(transactionHash) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [rpcTransaction, blockNumber] = yield Promise.all([
-                this.post(buildRPCPostBody('eth_getTransactionReceipt', [transactionHash])),
-                this.getBlock('latest'),
-            ]);
-            const cleanedTransactionReceipt = cleanTransactionReceipt(rpcTransaction);
-            cleanedTransactionReceipt.confirmations =
-                blockNumber.number - cleanedTransactionReceipt.blockNumber + 1;
-            return cleanedTransactionReceipt;
-        });
-    }
-    getTransactionCount(address, blockTag = 'latest') {
-        return __awaiter(this, void 0, void 0, function* () {
-            blockTag = prepBlockTag(blockTag);
-            const transactionCount = (yield this.post(buildRPCPostBody('eth_getTransactionCount', [address, blockTag])));
-            return Number(hexToDecimal(transactionCount));
-        });
-    }
-    getBlock(timeFrame = 'latest', returnTransactionObjects = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let type = 'Number';
-            if (typeof timeFrame === 'string' && timeFrame.length === 66) {
-                type = 'Hash';
-            }
-            else {
-                timeFrame = prepBlockTag(timeFrame);
-            }
-            const rpcBlock = (yield this.post(buildRPCPostBody(`eth_getBlockBy${type}`, [
-                timeFrame,
-                returnTransactionObjects,
-            ])));
-            return cleanBlock(rpcBlock, returnTransactionObjects);
-        });
-    }
-    getGasPrice() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hexGasPrice = (yield this.post(buildRPCPostBody('eth_gasPrice', [])));
-            return tinyBig(hexToDecimal(hexGasPrice));
-        });
-    }
-    getBalance(address, blockTag = 'latest') {
-        return __awaiter(this, void 0, void 0, function* () {
-            blockTag = prepBlockTag(blockTag);
-            const hexBalance = (yield this.post(buildRPCPostBody('eth_getBalance', [address, blockTag])));
-            return tinyBig(hexToDecimal(hexBalance));
-        });
-    }
-    getCode(address, blockTag = 'latest') {
-        return __awaiter(this, void 0, void 0, function* () {
-            blockTag = prepBlockTag(blockTag);
-            const contractCode = (yield this.post(buildRPCPostBody('eth_getCode', [address, blockTag])));
-            return contractCode;
-        });
-    }
-    estimateGas(transaction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const rpcTransaction = prepareTransaction(transaction);
-            const gasUsed = (yield this.post(buildRPCPostBody('eth_estimateGas', [rpcTransaction])));
-            return tinyBig(hexToDecimal(gasUsed));
-        });
-    }
-    getFeeData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [block, gasPrice] = yield Promise.all([
-                this.getBlock('latest'),
-                this.getGasPrice(),
-            ]);
-            let lastBaseFeePerGas = null, maxFeePerGas = null, maxPriorityFeePerGas = null;
-            if (block && block.baseFeePerGas) {
-                lastBaseFeePerGas = block.baseFeePerGas;
-                maxPriorityFeePerGas = tinyBig('1500000000');
-                maxFeePerGas = tinyBig(block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas));
-            }
-            return { lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas, gasPrice };
-        });
-    }
-    getLogs(filter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const filterByRange = filter;
-            if (filterByRange.fromBlock)
-                filterByRange.fromBlock = prepBlockTag(filterByRange.fromBlock);
-            if (filterByRange.toBlock)
-                filterByRange.toBlock = prepBlockTag(filterByRange.toBlock);
-            const rpcLogs = (yield this.post(buildRPCPostBody('eth_getLogs', [filter])));
-            const logs = rpcLogs.map((log) => cleanLog(log, false));
-            return logs;
-        });
-    }
-    call(transaction, blockTag = 'latest') {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (transaction.gasPrice &&
-                (transaction.maxPriorityFeePerGas || transaction.maxFeePerGas)) {
-                logger.throwError('Cannot specify both "gasPrice" and ("maxPriorityFeePerGas" or "maxFeePerGas")', {
-                    gasPrice: transaction.gasPrice,
-                    maxFeePerGas: transaction.maxFeePerGas,
-                    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
-                });
-            }
-            if (transaction.maxFeePerGas && transaction.maxPriorityFeePerGas) {
-                logger.throwError('Cannot specify both "maxFeePerGas" and "maxPriorityFeePerGas"', {
-                    maxFeePerGas: transaction.maxFeePerGas,
-                    maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
-                });
-            }
-            blockTag = prepBlockTag(blockTag);
-            const rpcTransaction = prepareTransaction(transaction);
-            const transactionRes = (yield this.post(buildRPCPostBody('eth_call', [rpcTransaction, blockTag])));
-            return transactionRes;
-        });
-    }
-}

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

@@ -1,11 +0,0 @@
-import { BaseProvider } from './BaseProvider';
-export interface ConstructorOptions {
-    timeoutDuration?: number;
-}
-export declare class FallthroughProvider extends BaseProvider {
-    private rpcUrlCounter;
-    private readonly timeoutDuration;
-    selectRpcUrl(): string;
-    constructor(rpcUrls: string[], options?: ConstructorOptions);
-    post: (body: Record<string, unknown>) => Promise<any>;
-}

package/dist/esm/providers/FallthroughProvider.js

@@ -1,49 +0,0 @@
-import { logger } from '../logger/logger';
-import { BaseProvider } from './BaseProvider';
-const promiseTimeout = (prom, time) => new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error('Promise timed out')), time);
-    prom
-        .then((result) => {
-        clearTimeout(timeout);
-        resolve(result);
-    })
-        .catch((error) => {
-        clearTimeout(timeout);
-        reject(error);
-    });
-});
-const DEFAULT_TIMEOUT_DURATION = 8000;
-export class FallthroughProvider extends BaseProvider {
-    selectRpcUrl() {
-        return this._rpcUrls[this.rpcUrlCounter];
-    }
-    constructor(rpcUrls, options = {}) {
-        if (!Array.isArray(rpcUrls)) {
-            logger.throwError('Array required', { rpcUrls });
-        }
-        if (rpcUrls.length <= 1) {
-            logger.throwError('More than one rpcUrl is required', { rpcUrls });
-        }
-        super(rpcUrls);
-        this.rpcUrlCounter = 0;
-        this.post = (body) => {
-            const genesisCount = this.rpcUrlCounter;
-            const recursivePostRetry = () => {
-                const genesisRpcUrl = this.selectRpcUrl();
-                const res = promiseTimeout(this._post(body), this.timeoutDuration).catch((e) => {
-                    if (genesisRpcUrl === this.selectRpcUrl()) {
-                        this.rpcUrlCounter =
-                            (this.rpcUrlCounter + 1) % this._rpcUrls.length;
-                    }
-                    if (this.rpcUrlCounter === genesisCount) {
-                        throw e;
-                    }
-                    return recursivePostRetry();
-                });
-                return res;
-            };
-            return recursivePostRetry();
-        };
-        this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
-    }
-}

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

@@ -1,7 +0,0 @@
-import { BaseProvider } from './BaseProvider';
-export declare class JsonRpcProvider extends BaseProvider {
-    selectRpcUrl(): string;
-    post(body: Record<string, unknown>): Promise<any>;
-    constructor(rpcUrl?: string);
-}
-export declare function jsonRpcProvider(rpcUrl?: string): JsonRpcProvider;

package/dist/esm/providers/JsonRpcProvider.js

@@ -1,15 +0,0 @@
-import { BaseProvider } from './BaseProvider';
-export class JsonRpcProvider extends BaseProvider {
-    selectRpcUrl() {
-        return this._rpcUrls[0];
-    }
-    post(body) {
-        return this._post(body);
-    }
-    constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
-        super([rpcUrl]);
-    }
-}
-export function jsonRpcProvider(rpcUrl) {
-    return new JsonRpcProvider(rpcUrl);
-}

package/dist/esm/providers/test/json-rpc-provider/get-logs/mocks.d.ts

@@ -1,14 +0,0 @@
-import type { Filter } from '../../../../types/Filter.types';
-import type { RPCLog } from '../../../../types/Transaction.types';
-export declare const STRONGBLOCK_ADDRESS = "0xfbddadd80fe7bda00b901fbaf73803f2238ae655";
-export declare const filterAddressFromTo: Filter;
-export declare const RARELAND_ADDRESS = "0x596a0f276ee432d8a28441e55737ff55cf30d0f7";
-export declare const filterAddressTopics: Filter;
-export declare const WETH_ADDRESS = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
-export declare const filterAll: Filter;
-export declare const mockfilterAddressFromToLogs: RPCLog[];
-export declare const mockfilterAddressTopicsLogs: RPCLog[];
-export declare const mockfilterAllLogs: RPCLog[];
-export declare const mockRpcAddressFromToResponse: string;
-export declare const mockRpcAddressTopicsResponse: string;
-export declare const mockRpcAllResponse: string;

package/dist/esm/providers/test/json-rpc-provider/get-logs/mocks.js

@@ -1,142 +0,0 @@
-export const STRONGBLOCK_ADDRESS = '0xfbddadd80fe7bda00b901fbaf73803f2238ae655';
-export const filterAddressFromTo = {
-    address: STRONGBLOCK_ADDRESS,
-    fromBlock: '0xE1F8F1',
-    toBlock: '0xE1F8F1',
-};
-export const RARELAND_ADDRESS = '0x596a0f276ee432d8a28441e55737ff55cf30d0f7';
-export const filterAddressTopics = {
-    address: RARELAND_ADDRESS,
-    topics: [
-        '0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925',
-    ],
-};
-export const WETH_ADDRESS = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
-export const filterAll = {
-    address: WETH_ADDRESS,
-    topics: [
-        '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-        '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
-    ],
-    fromBlock: 14825027,
-    toBlock: 14825039,
-};
-export const mockfilterAddressFromToLogs = [
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
-            '0x00000000000000000000000028c2e3e17f8c61a9b7515f7bb1e1347846588b82',
-        ],
-        data: '0x0000000000000000000000000000000000000000000000001dbaed81bf64db6d',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0x5dec3a55b87edac0af5c4a9afdd015bb04303fdf86525dd1cc4e7aa7653b6301',
-        transactionIndex: '0x29',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0x88',
-        removed: false,
-    },
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
-            '0x000000000000000000000000c3b80d78bb52fd734c4f730dad5e190ba4ecb830',
-        ],
-        data: '0x0000000000000000000000000000000000000000000000001c277de315af8924',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0xae04b63efd57852e34bdc84e257bb413f9f942288f63a131d4b7071c8ee0b896',
-        transactionIndex: '0x2f',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0x95',
-        removed: false,
-    },
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
-            '0x000000000000000000000000f1a192063f0a2b2be0cbcb2978b13e95e7f35f6b',
-        ],
-        data: '0x00000000000000000000000000000000000000000000000018ecfa70ea275b6d',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0xbdba7260507b4ca24757809ac9a23e5225e80a491475ccf89a04c1894a693c77',
-        transactionIndex: '0x30',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0x97',
-        removed: false,
-    },
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
-            '0x000000000000000000000000c78dc12c9b04858d57a108ae948020344895e910',
-        ],
-        data: '0x0000000000000000000000000000000000000000000000000da5142efe16e492',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0xdcf29bd8a44ec89a3b53488dd60b76bd7f1c532db76f88e166f3de1ab216537e',
-        transactionIndex: '0x31',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0x99',
-        removed: false,
-    },
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a',
-            '0x000000000000000000000000aaf5c3760f4a77bdf23974f98d69f9ccfd778aea',
-        ],
-        data: '0x0000000000000000000000000000000000000000000000001086ed3d87034000',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0x56130c6e8fdafd0e08411b21ce984eeb56dc61d99a91f03efc7edde748d7ad81',
-        transactionIndex: '0x35',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0xac',
-        removed: false,
-    },
-    {
-        address: '0xfbddadd80fe7bda00b901fbaf73803f2238ae655',
-        topics: [
-            '0x39b0a0620bb668047ab7248973ddfd93d53dff1d4952bd2d56bbf5934edc1fd0',
-            '0x0000000000000000000000001753de22132990dd5ab35f13a5951431c8ba08ea',
-        ],
-        data: '0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000e3203b',
-        blockNumber: '0xe1f8f1',
-        transactionHash: '0xf5a77d85296cc670d577d3c9a76b1fa18be77239a4cb4c05493530866d60c36f',
-        transactionIndex: '0x3a',
-        blockHash: '0x343ead2d84a53b054bc191fe00807d59b40094bb0cbc49b3ba550169b046d4b8',
-        logIndex: '0xb5',
-        removed: false,
-    },
-];
-export const mockfilterAddressTopicsLogs = [];
-export const mockfilterAllLogs = [
-    {
-        address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
-        topics: [
-            '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
-            '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
-            '0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45',
-        ],
-        data: '0x000000000000000000000000000000000000000000000000005f862ee352a38a',
-        blockNumber: '0xe23645',
-        transactionHash: '0xbd49031be16f8fd1775f4e0fe79b408ffd8ae9c65b2827ee47e3238e3f51f4c0',
-        transactionIndex: '0xe2',
-        blockHash: '0x8e0dfac2f704851960f866c8708b3bef2f66c0fee0329cf25ff0261b264ca6bc',
-        logIndex: '0x180',
-        removed: false,
-    },
-];
-export const mockRpcAddressFromToResponse = JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    result: mockfilterAddressFromToLogs,
-});
-export const mockRpcAddressTopicsResponse = JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    result: mockfilterAddressTopicsLogs,
-});
-export const mockRpcAllResponse = JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    result: mockfilterAllLogs,
-});

package/dist/esm/providers/test/mock-of.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="jest" />
-export declare const mockOf: <FunctionParameters extends unknown[], FunctionReturnType>(fn: (...args: FunctionParameters) => FunctionReturnType) => jest.Mock<FunctionReturnType, FunctionParameters>;

package/dist/esm/providers/test/mock-of.js

@@ -1 +0,0 @@
-export const mockOf = (fn) => fn;

package/dist/esm/providers/test/rpc-urls.d.ts

@@ -1,12 +0,0 @@
-export declare const fakeUrls: {
-    readonly notRPCButRealHttp: "https://httpstat.us/200";
-};
-export declare const rpcUrls: {
-    mainnet: string;
-    oeth: string;
-    matic: string;
-    gno: string;
-    bnb: string;
-    arb1: string;
-    gor: string;
-};

package/dist/esm/providers/test/rpc-urls.js

@@ -1,19 +0,0 @@
-import z from 'zod';
-export const fakeUrls = {
-    notRPCButRealHttp: 'https://httpstat.us/200',
-};
-const RPC_ORIGIN = 'https://free-eth-node.com';
-z.string({
-    required_error: '"RPC_ORIGIN" required but not found',
-})
-    .url('Expected url for "RPC_ORIGIN"')
-    .parse(RPC_ORIGIN);
-export const rpcUrls = {
-    mainnet: `${RPC_ORIGIN}/api/eth`,
-    oeth: `${RPC_ORIGIN}/api/oeth`,
-    matic: `${RPC_ORIGIN}/api/MATIC`,
-    gno: `${RPC_ORIGIN}/api/gno`,
-    bnb: `${RPC_ORIGIN}/api/bnb`,
-    arb1: `${RPC_ORIGIN}/api/arb1`,
-    gor: `${RPC_ORIGIN}/api/gor`,
-};

package/dist/esm/providers/utils/chains-info.d.ts

@@ -1,24 +0,0 @@
-declare const _default: {
-    "1": string[];
-    "5": string[];
-    "10": string[];
-    "50": string[];
-    "56": string[];
-    "100": string[];
-    "137": string[];
-    "250": string[];
-    "324": string[];
-    "1101": string[];
-    "1337": string[];
-    "7700": string[];
-    "9001": string[];
-    "42161": string[];
-    "42220": string[];
-    "43114": string[];
-    "59140": string[];
-    "80001": string[];
-    "421613": string[];
-    "534352": string[];
-    "11155111": string[];
-};
-export default _default;

package/dist/esm/providers/utils/chains-info.js

@@ -1,67 +0,0 @@
-export default {
-    "1": [
-        "eth",
-        "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
-    ],
-    "5": [
-        "gor",
-        "0x112234455c3a32fd11230c42e7bccd4a84e02010"
-    ],
-    "10": [
-        "oeth"
-    ],
-    "50": [
-        "xdc"
-    ],
-    "56": [
-        "bnb"
-    ],
-    "100": [
-        "gno"
-    ],
-    "137": [
-        "matic"
-    ],
-    "250": [
-        "ftm"
-    ],
-    "324": [
-        "zksync"
-    ],
-    "1101": [
-        "zkevm"
-    ],
-    "1337": [
-        "geth"
-    ],
-    "7700": [
-        "canto"
-    ],
-    "9001": [
-        "evmos"
-    ],
-    "42161": [
-        "arb1"
-    ],
-    "42220": [
-        "celo"
-    ],
-    "43114": [
-        "avax"
-    ],
-    "59140": [
-        "linea-testnet"
-    ],
-    "80001": [
-        "maticmum"
-    ],
-    "421613": [
-        "arb-goerli"
-    ],
-    "534352": [
-        "scr"
-    ],
-    "11155111": [
-        "sep"
-    ]
-};

package/dist/esm/shared/tiny-big/helpers.d.ts

@@ -1 +0,0 @@
-export declare function scientificStrToDecimalStr(scientificString: string): string;

package/dist/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/dist/esm/shared/tiny-big/tiny-big.d.ts

@@ -1,10 +0,0 @@
-import Big from 'big.js';
-export declare class TinyBig extends Big {
-    constructor(value: string | number | TinyBig | Big);
-    toHexString(): string;
-    toNumber(): number;
-    toString(): string;
-    private padAndChop;
-    toTwos(bitCount: number): Big;
-}
-export declare function tinyBig(value: string | number | TinyBig | Big): TinyBig;

package/dist/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/dist/esm/shared/validate-type.d.ts

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