dequanto 0.1.23 → 0.1.25

package/lib/esm/utils/$abiUtils.d.ts

@@ -1,42 +0,0 @@
-import type { TAbiItem, TAbiInput } from '../types/TAbi';
-import { ParamType } from '../abi/fragments';
-import { TEth } from '../models/TEth';
-export declare namespace $abiUtils {
-    function encodePacked(types: string[], values: any[]): TEth.Hex;
-    function encodePacked(typeValues: [string, any][]): TEth.Hex;
-    function encodePacked(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): TEth.Hex;
-    function encodePacked(...typeValues: {
-        type: string;
-        value: any;
-    }[]): TEth.Hex;
-    function encodePacked(...typeValues: [string, any][]): TEth.Hex;
-    function encode(typeValues: [string, any][]): TEth.Hex;
-    function encode(types: ReadonlyArray<string | TAbiInput>, values: any[]): TEth.Hex;
-    function decode(types: (string | ParamType | TAbiInput)[], data: string): {
-        args: any[];
-        params: {
-            [key: string]: any;
-        };
-    };
-    function decodePacked<T = any>(types: string | string[] | ParamType[] | TAbiInput | TAbiInput[] | ParamType, data: string): T;
-    /** Returns complete method/event hash */
-    function getMethodHash(mix: string | TAbiItem): `0x${string}`;
-    function getMethodSignature(mix: string | TAbiItem): string;
-    function serializeMethodCallData(abi: string | TAbiItem, params?: any[]): TEth.Hex;
-    function parseMethodCallData(mixAbi: string | TAbiItem | TAbiItem[], mixInput: TEth.BufferLike | Pick<TEth.TxLike, 'data' | 'input' | 'value'>): {
-        name: string;
-        args: any[];
-        params: {
-            [key: string]: any;
-        };
-        value: string | number | bigint;
-    };
-    function getTopicSignature(abi: TAbiItem): `0x${string}`;
-    function checkInterfaceOf(abi: TAbiItem[], iface: TAbiItem[]): {
-        ok: boolean;
-        missing?: string;
-    };
-    function isDynamicType(type: string): boolean;
-    function isReadMethod(abi: TAbiItem): boolean;
-    function fromAliasIfAny(type: string): string;
-}

package/lib/esm/utils/$account.d.ts

@@ -1,6 +0,0 @@
-import { EoAccount, Erc4337Account, SafeAccount, TAccount } from "../models/TAccount";
-export declare namespace $account {
-    function getSender(account: TAccount): EoAccount;
-    function isSafe(account: TAccount): account is SafeAccount;
-    function isErc4337(account: TAccount): account is Erc4337Account;
-}

package/lib/esm/utils/$address.d.ts

@@ -1,13 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $address {
-    const ZERO: TEth.Address;
-    function eq(a1: string, a2: string): boolean;
-    function find<T>(arr: T[], getter: (x: T) => TEth.Address, address: TEth.Address): T;
-    function isValid(address: any): address is TEth.Address;
-    function isEmpty(address: TEth.Address): boolean;
-    function expectValid(address: TEth.Address, message: string): `0x${string}`;
-    function toBytes32(address: TEth.Address): string;
-    function fromBytes32(hex: string): TEth.Address;
-    /** Supports https://eips.ethereum.org/EIPS/eip-1191 */
-    function toChecksum(address_: TEth.Address, chainId?: number): TEth.Address;
-}

package/lib/esm/utils/$array.d.ts

@@ -1,12 +0,0 @@
-export declare namespace $array {
-    function upsert<T>(arr: T[], x: T, matcher: (x: T) => boolean, opts?: {
-        patch: boolean;
-    }): T[];
-    function equal<T>(a: T[], b: T[]): boolean;
-    function remove<T>(arr: T[], matcher: (x: T) => boolean): T[];
-    function remove<T>(arr: T[], item: T): T[];
-    function replace<T>(arr: T[], item: T, matcher: (x: T, item: T, i: number) => boolean): void;
-    function shuffle<T>(arr: T[]): T[];
-    function trimEnd<T>(arr: T[]): T[];
-    function findIndex<T>(array: T[], matcher: (item: T, i?: number) => boolean, fromIdx?: number): number;
-}

package/lib/esm/utils/$base.d.ts

@@ -1,13 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $base {
-    class Base {
-        alphabet: string;
-        private BASE;
-        private MAP;
-        constructor(alphabet: string);
-        encode(hex: TEth.Hex): string;
-        decode(baseX: string): TEth.Hex;
-    }
-    export const $58: Base;
-    export {};
-}

package/lib/esm/utils/$bigfloat.d.ts

@@ -1,67 +0,0 @@
-type TNumeric = BigFloat | string | number | bigint;
-export declare class BigFloat {
-    value: bigint;
-    mantissa: bigint;
-    constructor(value: bigint, mantissa?: bigint);
-    toNumber(): number;
-    toString(): string;
-    toBigInt(): bigint;
-    toJSON(): string;
-    valueOf(): string;
-    toFormat(locales?: string | string[], options?: Intl.NumberFormatOptions): string;
-    minus(mix: TNumeric): BigFloat;
-    sub(mix: TNumeric): BigFloat;
-    plus(mix: TNumeric): BigFloat;
-    add(mix: TNumeric): BigFloat;
-    multipliedBy(mix: TNumeric): BigFloat;
-    times(mix: TNumeric): BigFloat;
-    mul(mix: TNumeric): BigFloat;
-    dividedBy(mix: TNumeric): BigFloat;
-    div(mix: TNumeric): BigFloat;
-    isLessThan(mix: TNumeric): boolean;
-    lt(mix: TNumeric): boolean;
-    isLessThanOrEqual(mix: TNumeric): boolean;
-    lte(mix: TNumeric): boolean;
-    isGreaterThan(mix: TNumeric): boolean;
-    gt(mix: TNumeric): boolean;
-    isGreaterThanOrEqualTo(mix: TNumeric): boolean;
-    gte(mix: TNumeric): boolean;
-    modulo(mix: TNumeric): BigFloat;
-    mod(mix: TNumeric): BigFloat;
-    pow(exponent: number | bigint): any;
-    squareRoot(): BigFloat;
-    sqrt(): BigFloat;
-    root(nth: bigint): BigFloat;
-    absoluteValue(): BigFloat;
-    abs(): BigFloat;
-    /**
-     * Math.ceil = ROUNDING_MODE.ROUND_UP
-     * Math.floor = ROUNDING_MODE.ROUND_DOWN
-     * Math.round = ROUNDING_MODE.ROUND_HALF_CEIL
-     */
-    dp(dp: number, rm?: ROUNDING_MODE): BigFloat;
-    decimalPlaces(dp: number, rm?: ROUNDING_MODE): BigFloat;
-    compact(): BigFloat;
-    static from(mix: TNumeric): BigFloat;
-}
-export declare enum ROUNDING_MODE {
-    ROUND_UP = 0,
-    ROUND_DOWN = 1,
-    ROUND_CEIL = 2,
-    ROUND_FLOOR = 3,
-    ROUND_HALF_UP = 4,
-    ROUND_HALF_DOWN = 5,
-    ROUND_HALF_EVEN = 6,
-    ROUND_HALF_CEIL = 7,
-    ROUND_HALF_FLOOR = 8
-}
-export declare namespace $bigfloat {
-    function from(mix: TNumeric): BigFloat;
-    function config(cfg: {
-        DECIMAL_PLACES?: number;
-        ROUNDING_MODE?: number;
-        EXPONENTIAL_AT?: [number, number];
-        RANGE?: number;
-    }): void;
-}
-export {};

package/lib/esm/utils/$bigint.d.ts

@@ -1,30 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $bigint {
-    const ETHER_DECIMALS = 18;
-    const GWEI_DECIMALS = 9;
-    const MAX_UINT256 = 115792089237316195423570985008687907853269984665640564039457584007913129639935n;
-    function max(...args: bigint[]): bigint;
-    function min(...args: bigint[]): bigint;
-    function toBigInt(amount: string | number | bigint | Uint8Array): bigint;
-    /**
-     * @param amount e.g "2.4 ether", "10 gwei", "1.7^18", "123456"
-     */
-    function parse(amount: string): bigint;
-    function ensureWei(amount: number | bigint, decimals: number): bigint;
-    function toWei(amount: string | number | bigint, decimals?: number | string): bigint;
-    function toWeiFromGwei(amount: string | number | bigint): bigint;
-    function toEther(amount: string | number | bigint, decimals?: number | string, round?: bigint): number;
-    function toEtherSafe(amount: string | number | bigint, decimals?: number | string, round?: bigint): number | bigint;
-    function toHex(num: string | bigint | number): TEth.Hex;
-    function toTwos(value: bigint, bits: number): bigint;
-    function fromTwos(value: bigint, bits: number): bigint;
-    function mask(value: bigint, _bits: number): bigint;
-    function toGweiFromWei(val: bigint): number;
-    function toGweiFromEther(val: number): bigint;
-    function multWithFloat(bigInt: bigint, float: number): bigint;
-    function divToFloat(a: bigint, b: bigint, precision?: bigint): number;
-    function pow(basis: bigint | number, exponent: number | bigint): bigint;
-    function sign(value: bigint): 0n | 1n | -1n;
-    function abs(value: bigint): bigint;
-    function sqrt(value: bigint): bigint;
-}

package/lib/esm/utils/$block.d.ts

@@ -1,7 +0,0 @@
-import type { Web3Client } from '../clients/Web3Client';
-export declare namespace $block {
-    function getDate(block: {
-        timestamp: string | number;
-    }): Date;
-    function ensureNumber(mix: number | Date, client: Web3Client): Promise<number>;
-}

package/lib/esm/utils/$bloom.d.ts

@@ -1,3 +0,0 @@
-export declare namespace $bloom {
-    function check(bloomHex: string, hex: string): boolean;
-}

package/lib/esm/utils/$buffer.d.ts

@@ -1,14 +0,0 @@
-import { TEth } from '../models/TEth';
-interface IBufferUtils {
-    fromHex(hex: string | TEth.Hex): Uint8Array;
-    toHex(buffer: Uint8Array): TEth.Hex;
-    fromString(string: string, encoding?: BufferEncoding): Uint8Array;
-    toString(buffer: Uint8Array, encoding?: BufferEncoding): string;
-    fromBigInt(value: bigint): Uint8Array;
-    toBigInt(buffer: Uint8Array): bigint;
-    concat(buffers: Uint8Array[]): Uint8Array;
-    ensure(mix: string | boolean | bigint | number | Uint8Array): Uint8Array;
-}
-export type TBytes = Uint8Array;
-export declare const $buffer: IBufferUtils;
-export {};

package/lib/esm/utils/$cache.d.ts

@@ -1,3 +0,0 @@
-export declare namespace $cache {
-    function file(filename: string): any;
-}

package/lib/esm/utils/$class.d.ts

@@ -1,3 +0,0 @@
-export declare namespace $class {
-    function curry<T, TMix>(entity: T, extend: TMix): T & TMix;
-}

package/lib/esm/utils/$cli.d.ts

@@ -1,3 +0,0 @@
-export declare namespace $cli {
-    function getParamValue<T = any>(flag: string, parameters?: Record<string, T>): T | null;
-}

package/lib/esm/utils/$color.d.ts

@@ -1,4 +0,0 @@
-export declare function $color(str: string): string;
-export declare function $color_options(opts: {
-    type: 'none' | 'ascii';
-}): void;

package/lib/esm/utils/$config.d.ts

@@ -1,10 +0,0 @@
-export declare namespace $config {
-    function get<T = any>(path: string, $default?: T): T;
-    function set<T = any>(path: string, value: T): void;
-    /**
-     * Reloads dequanto env config from cli ARGUMENTS and DQ_SETTINGS__** environment
-     */
-    function reloadEnv(argv?: string[], env?: {
-        [key: string]: string;
-    }): any;
-}

package/lib/esm/utils/$const.d.ts

@@ -1 +0,0 @@
-export declare const is_BROWSER: boolean;

package/lib/esm/utils/$contract.d.ts

@@ -1,42 +0,0 @@
-import type { TAbiItem } from '../types/TAbi';
-import { ITxLogItem } from '../txs/receipt/ITxLogItem';
-import { TBufferLike } from '../models/TBufferLike';
-import { TEth } from '../models/TEth';
-export declare namespace $contract {
-    function keccak256(str: string | TBufferLike, output: 'buffer'): Uint8Array;
-    function keccak256(str: string | TBufferLike, output?: 'hex'): TEth.Hex;
-    function normalizeArgs(args: any[]): any;
-    function extractLogsForAbi(tx: TEth.TxReceipt, abiItem: string | TAbiItem): ITxLogItem[];
-    function parseInputData(inputHex: string, abis: TAbiItem[]): {
-        method: string;
-        params: any;
-    };
-    function decodeDeploymentArguments(input: TEth.Hex, ctorAbi: TAbiItem): {
-        args: any[];
-        params: {
-            [key: string]: any;
-        };
-        encoded: `0x${string}`;
-    };
-    function parseDeploymentBytecode(input: TEth.Hex): {
-        bytecode: string;
-        arguments: string;
-    };
-    function decodeCustomError(errorDataHex: string | {
-        type: any;
-        params: any;
-    } | any, abiArr: TAbiItem[]): any;
-    function parseLogWithAbi(log: TEth.Log, mix: TAbiItem[] | TAbiItem | string): ITxLogItem;
-    function formatCall(call: {
-        method?: any;
-        type?: any;
-        params?: any;
-    }): string;
-    function formatCallFromAbi(abi: TAbiItem, params: any[]): string;
-    namespace store {
-        function getFlattened(): TAbiItem[];
-        function register(contract: {
-            abi: TAbiItem[];
-        }): void;
-    }
-}

package/lib/esm/utils/$crypto.d.ts

@@ -1,91 +0,0 @@
-import { TEth } from '../models/TEth';
-interface ICrypto {
-    randomBytes(size: number): Uint8Array;
-    randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
-    createECDH(curve: string): any;
-    sha256(mix: string | TEth.Hex | Uint8Array): Promise<Uint8Array>;
-    encrypt(buffer: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding?: undefined | 'binary';
-    }): Promise<Uint8Array>;
-    encrypt(buffer: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'hex';
-    }): Promise<TEth.Hex>;
-    encrypt(buffer: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'utf8';
-    }): Promise<string>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding?: undefined | 'binary';
-    }): Promise<Uint8Array>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'hex';
-    }): Promise<TEth.Hex>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'utf8';
-    }): Promise<string>;
-}
-interface IEncryptionParams {
-    secret: string | Uint8Array;
-    encoding?: 'binary' | 'hex' | 'utf8';
-}
-declare abstract class CryptoBase implements ICrypto {
-    abstract randomBytes(size: number): Uint8Array;
-    abstract randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
-    abstract createECDH(curve: string): any;
-    sha256(mix: string | TEth.Hex | Uint8Array, opts?: {
-        encoding?: undefined | 'binary';
-    }): Promise<Uint8Array>;
-    sha256(mix: string | TEth.Hex | Uint8Array, opts?: {
-        encoding: 'hex';
-    }): Promise<TEth.Hex>;
-    encrypt(mix: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding?: undefined | 'binary';
-    }): Promise<Uint8Array>;
-    encrypt(mix: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'hex';
-    }): Promise<TEth.Hex>;
-    encrypt(mix: string | TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'utf8';
-    }): Promise<string>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding?: undefined | 'binary';
-    }): Promise<Uint8Array>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'hex';
-    }): Promise<TEth.Hex>;
-    decrypt(buffer: TEth.Hex | Uint8Array, opts: IEncryptionParams & {
-        encoding: 'utf8';
-    }): Promise<string>;
-    protected abstract encryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-    protected abstract decryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-    protected abstract sha256Inner(buffer: Uint8Array): Promise<Uint8Array>;
-    private prepareSecret;
-}
-declare namespace WebCryptoImpl {
-    class CryptoWeb extends CryptoBase {
-        crypto: Crypto;
-        randomBytes(size: number): Uint8Array;
-        randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
-        createECDH(curve: string): void;
-        encryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-        decryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-        private _getEncryptionKey;
-        protected sha256Inner(buffer: Uint8Array): Promise<Uint8Array>;
-    }
-}
-declare namespace NodeCryptoImpl {
-    class CryptoNode extends CryptoBase {
-        crypto: typeof import('crypto');
-        randomBytes(size: number): Buffer;
-        randomUUID(): `${string}-${string}-${string}-${string}-${string}`;
-        createECDH(curve: string): import("crypto").ECDH;
-        protected encryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-        protected decryptInner(buffer: Uint8Array, secret: Uint8Array): Promise<Uint8Array>;
-        protected sha256Inner(buffer: Uint8Array): Promise<Uint8Array>;
-    }
-}
-export declare const $crypto: ICrypto;
-export declare const $cryptoImpl: {
-    Web: typeof WebCryptoImpl.CryptoWeb;
-    Node: typeof NodeCryptoImpl.CryptoNode;
-};
-export {};

package/lib/esm/utils/$csv.d.ts

@@ -1,10 +0,0 @@
-export declare namespace $csv {
-    function stringify(data: {
-        header?: string[];
-        rows: (any[])[];
-    }): void;
-    function parseToObjects<T = any>(csv: string, columns: string[], opts?: {
-        hasHeader: boolean;
-    }): T[];
-    function parseToRows(csv: string): string[][];
-}

package/lib/esm/utils/$date.d.ts

@@ -1,88 +0,0 @@
-export declare class DateTool {
-    date: Date;
-    protected constructor(date?: Date);
-    /**
-     * - DD-MM-YYYYY (HH:mm)?
-     * - DD.MM.YYYYY (HH:mm)?
-     * - ISODate
-     * - Ticks
-     */
-    static with(mix: string | number | Date): DateTool;
-    static withNow(): DateTool;
-    clone(): DateTool;
-    add(x: string | number): this;
-    dayStart(): this;
-    dayEnd(): this;
-    weekStart(): this;
-    weekEnd(): this;
-    monthStart(): this;
-    monthEnd(): this;
-    daysBetween(b: Date): number;
-    /** e.g. yyyy-MM-dd HH:mm */
-    format(format: string): string;
-    setMilliseconds(v: number): this;
-    setSeconds(v: number): this;
-    setMinutes(v: number): this;
-    setHours(h: number, min?: number, sec?: number, ms?: number): this;
-    /** Sets the numeric day-of-the-month value of the Date object using local time. */
-    setDate(v: number): this;
-    setMonth(v: number): this;
-    setFullYear(v: number): this;
-    nextDay(h?: number, min?: number, s?: number, ms?: number): this;
-    toUnixTimestamp(): number;
-}
-declare class Timer {
-    private name?;
-    private paused;
-    private from;
-    private pausedAt;
-    constructor(name?: string);
-    log(msg?: string): this;
-    pause(): this;
-    resume(): this;
-    restart(name?: string): this;
-}
-export declare namespace $date {
-    function tool(dateStr: string): DateTool;
-    function tool(date: Date): DateTool;
-    function tool(): DateTool;
-    function timer(name?: string): Timer;
-    /** e.g. yyyy-MM-dd HH:mm */
-    function format(date: number | string | Date, format: string): string;
-    function formatTimespan(ms: number): string;
-    function dayStart(date?: Date): Date;
-    function hourStart(date?: Date): Date;
-    function dayEnd(date?: Date): Date;
-    function weekStart(date?: Date): Date;
-    function weekEnd(date?: Date): Date;
-    function monthStart(date?: Date): Date;
-    function monthEnd(date?: Date): Date;
-    /** date1 + X === date2 */
-    function daysBetween(a: Date, b: Date, abs?: boolean): number;
-    /** hour1 + X === hour2 */
-    function hoursBetween(a: Date, b: Date, abs?: boolean): number;
-    function minsBetween(a: Date | string, b: Date | string, abs?: boolean): number;
-    /**
-     * - DD-MM-YYYYY (HH:mm)?
-     * - DD.MM.YYYYY (HH:mm)?
-     * - ISODate
-     * - Ticks
-     */
-    function parse(mix: Date | number | string, default_?: Date): Date;
-    /**
-     * s|sec|seconds|m|mins?|h|hours?|d|days?|w|weeks?|months?|y|years?
-     * e.g: 2h
-     * @param str
-     * @param opts Default: ms
-     */
-    function parseTimespan(str: string, opts?: {
-        get?: 'ms' | 's';
-        anchor?: Date;
-    }): number;
-    function additive(date: Date | number | string, x: string | number): Date;
-    function equal(a: Date, b: Date, precision?: 'year' | 'month' | 'date' | 'hour' | 'minute' | 'second' | 'ms'): boolean;
-    function isSameDay(a: Date, b: Date): boolean;
-    function toUnixTimestamp(date?: Date): number;
-    function fromUnixTimestamp(seconds: number | bigint): Date;
-}
-export {};

package/lib/esm/utils/$dependency.d.ts

@@ -1,4 +0,0 @@
-/** ESM and CJS Loader */
-export declare namespace $dependency {
-    function load<T = any>(name: string): Promise<T>;
-}

package/lib/esm/utils/$error.d.ts

@@ -1,8 +0,0 @@
-export declare namespace $error {
-    function normalizeEvmCustomError(error: Error & {
-        data: {
-            type: any;
-            params: any;
-        };
-    }): void;
-}

package/lib/esm/utils/$fn.d.ts

@@ -1,26 +0,0 @@
-export declare namespace $fn {
-    export function retriable<T extends TRetriableMethod>(fn: T, ctx: any): Retriable<T>;
-    export function timeoutPromise<T extends Promise<any>>(promise: T, ms: number): T;
-    export function waitForObject<T>(check: () => Promise<[Error, T?]>, opts?: {
-        intervalMs?: number;
-        timeoutMs?: number;
-        timeoutMessage?: string | (() => string);
-    }): Promise<T>;
-    type TRetriableMethod = (...args: any[]) => Promise<any>;
-    interface IRetriableOptions<T extends TRetriableMethod> {
-        timeout?: number;
-        retries?: number;
-        onError?: (error: any, ...args: any[]) => Promise<Parameters<T>> | void;
-    }
-    class Retriable<T extends TRetriableMethod> {
-        fn: T;
-        ctx: any;
-        private _retries;
-        private _options;
-        constructor(fn: T, ctx: any);
-        options(opts: IRetriableOptions<T>): this;
-        call(...args: Parameters<T>): ReturnType<T>;
-        private tick;
-    }
-    export {};
-}

package/lib/esm/utils/$gas.d.ts

@@ -1,13 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $gas {
-    function getUsed(receipt: TEth.TxReceipt, txData?: {
-        gasPrice?: any;
-    }): {
-        totalEth: number;
-        usage: bigint;
-        priceGwei: number;
-    };
-    function formatUsed(txData: {
-        gasPrice?: any;
-    }, receipt: TEth.TxReceipt): string;
-}

package/lib/esm/utils/$hex.d.ts

@@ -1,30 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $hex {
-    const ZERO = "0x";
-    /**
-     * Adds '00' bytes to the hex string.
-     * @param hex
-     * @param byteSize Min bytes count in the hex string
-     */
-    function padBytes(hex: TEth.Hex, byteSize: number, opts?: {
-        padEnd?: boolean;
-    }): TEth.Hex;
-    /**
-     * Trims '00' bytes from start or end, e.g.  0x68656c6c6f000000 =>  0x68656c6c6f
-     */
-    function trimBytes(hex: TEth.Hex): TEth.Hex;
-    function trimLeadingZerosFromNumber(hex: string): string;
-    function getBytes(hex: string, offset: number, length: number): TEth.Hex;
-    function getBytesLength(hex: string): number;
-    function getNumber(hex: string, byteIndex: number, bytesCount?: number): number;
-    function raw(hex: string): string;
-    function concat(arr: (string | TEth.Hex | Uint8Array)[]): TEth.Hex;
-    function toHex(value: string | boolean | number | bigint): TEth.Hex;
-    function toHexBuffer(value: string | boolean | number | bigint): TEth.Hex;
-    function convert(hex: string, abiType: 'uint256' | 'address' | 'bool' | 'string' | string): string | number | bigint | boolean;
-    /**
-     * Adds `0x` to the start if not present
-     */
-    function ensure(mix: string | number | boolean | bigint | Uint8Array): TEth.Hex;
-    function isEmpty(hex: string): boolean;
-}

package/lib/esm/utils/$http.d.ts

@@ -1,40 +0,0 @@
-interface THttpResponse<T> {
-    status: 200 | number;
-    data: T;
-}
-export declare namespace $http {
-    const handlers: {
-        rgx: RegExp;
-        handler: (opts: IHttpFetch) => Promise<{
-            status: any;
-            data: any;
-            headers?: any;
-        }>;
-    }[];
-    export function register(rgx: RegExp, handler: (typeof handlers[0]['handler'])): void;
-    export interface IHttpFetch {
-        url: string;
-        method?: 'GET' | string;
-        params?: Record<string, string>;
-        body?: string | Record<string, string> | any;
-        headers?: Record<string, string>;
-        responseType?: 'stream';
-    }
-    export function get<T = any>(opts: IHttpFetch): Promise<THttpResponse<T>>;
-    export function get<T = any>(url: string): Promise<THttpResponse<T>>;
-    export function post<T = any>(opts: IHttpFetch): Promise<THttpResponse<T>>;
-    /**
-     *  output: Directory or File
-     */
-    export function download(url: string, config: IHttpFetch & {
-        output: string;
-    }): Promise<void>;
-    export {};
-}
-export declare namespace $httpBrowser {
-    /**
-     *  output: Directory or File
-     */
-    function download(url: string, output: string, config?: RequestInit): Promise<void>;
-}
-export {};

package/lib/esm/utils/$is.d.ts

@@ -1,17 +0,0 @@
-import { TEth } from '../models/TEth';
-export declare namespace $is {
-    function Number<T>(val: number | any): val is number;
-    function notNull<T>(val: T): boolean;
-    function notEmpty<T extends string | any[]>(val: T): boolean;
-    function empty<T extends string | any[] | number | Uint8Array>(val: T): boolean;
-    function BigInt<T>(val: bigint | any): val is bigint;
-    function Address(val: string, message?: string): val is TEth.Address;
-    function Promise(val: any): val is Promise<any>;
-    function TxHash(val: string | TEth.Hex): boolean;
-    function Hex(str: string | any): str is TEth.Hex;
-    function HexBytes32(str: string | any): str is TEth.Hex;
-    function Array(val: any): val is any[];
-    function ArrayOfStrings(val: any): val is string[];
-    const BROWSER: boolean;
-    const NODE: boolean;
-}