essential-eth 0.4.9-beta.1 → 0.4.9-beta.4

package/lib/cjs/shared/tiny-big/helpers.d.ts

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

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scientificStrToDecimalStr = void 0;
+// strips both leading and trailing zeroes
+function stripTrailingZeroes(numberString) {
+    const isNegative = numberString.startsWith('-');
+    numberString = numberString.replace('-', '');
+    numberString = numberString.replace(/\.0*$/g, '' /* for numbers like "1.0" -> "1" */);
+    numberString = numberString.replace(/^0+/, '');
+    // for numbers like "1.10" -> "1.1"
+    if (numberString.includes('.')) {
+        numberString = numberString.replace(/0+$/, '');
+    }
+    if (numberString.startsWith('.')) {
+        // so that ".1" returns as "0.1"
+        numberString = `0${numberString}`;
+    }
+    return `${isNegative ? '-' : ''}${numberString}`;
+}
+function scientificStrToDecimalStr(scientificString) {
+    // Does not contain "e" nor "E"
+    if (!scientificString.match(/e/i /* lowercase and uppercase E */)) {
+        return stripTrailingZeroes(scientificString);
+    }
+    // eslint-disable-next-line prefer-const
+    let [base, power] = scientificString.split(/e/i /* lowercase and uppercase E */);
+    // remove the leading "-" if negative
+    const isNegative = Number(base) < 0;
+    base = base.replace('-', '');
+    base = stripTrailingZeroes(base);
+    const [wholeNumber, fraction /* move decimal this many places */ = ''] = 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) {
+            // move decimal left
+            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))) {
+                // starts with zeroes
+                splitPaddedNumber = ['.', ...splitPaddedNumber];
+            }
+            else {
+                splitPaddedNumber.splice(splitPaddedNumber.length - Math.abs(Number(power)), 0, '.');
+            }
+        }
+        else {
+            // move decimal right
+            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}`;
+    }
+}
+exports.scientificStrToDecimalStr = scientificStrToDecimalStr;

package/lib/cjs/shared/tiny-big/tiny-big.d.ts

@@ -0,0 +1,19 @@
+import Big from 'big.js';
+/**
+ * A wrapper around big.js which expands scientific notation and creates a "toHexString" function.
+ * This is the return type of every operation on ether, wei, etc.
+ */
+export declare class TinyBig extends Big {
+    constructor(value: string | number | TinyBig | Big);
+    /**
+     * Used anytime you're passing in "value" to ethers or web3
+     * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
+     */
+    toHexString(): string;
+    toNumber(): number;
+    toString(): string;
+}
+/**
+ * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ */
+export declare function tinyBig(value: string | number | TinyBig | Big): TinyBig;

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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tinyBig = exports.TinyBig = void 0;
+const big_js_1 = __importDefault(require("big.js"));
+const helpers_1 = require("./helpers");
+/**
+ * A wrapper around big.js which expands scientific notation and creates a "toHexString" function.
+ * This is the return type of every operation on ether, wei, etc.
+ */
+class TinyBig extends big_js_1.default {
+    constructor(value) {
+        super(value);
+    }
+    /**
+     * Used anytime you're passing in "value" to ethers or web3
+     * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
+     */
+    toHexString() {
+        return `0x${BigInt(this.toString()).toString(16)}`;
+    }
+    toNumber() {
+        return Number((0, helpers_1.scientificStrToDecimalStr)(super.toString()));
+    }
+    toString() {
+        if (this.toNumber() === 0) {
+            return '0';
+        }
+        return (0, helpers_1.scientificStrToDecimalStr)(super.toString());
+    }
+}
+exports.TinyBig = TinyBig;
+/**
+ * Helper factory function so that you don't have to type "new" when instantiating a new TinyBig
+ */
+function tinyBig(value) {
+    return new TinyBig(value);
+}
+exports.tinyBig = tinyBig;

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateType = void 0;
+const validateType = (value, allowedTypes) => {
+    if (!allowedTypes.includes(typeof value)) {
+        throw new Error(`${allowedTypes.join(' or ')} required. Received ${typeof value}`);
+    }
+};
+exports.validateType = validateType;

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

@@ -0,0 +1,47 @@
+import { RPCTransaction, Transaction } from './Transaction.types';
+export interface Block {
+    baseFeePerGas: string;
+    difficulty: number;
+    extraData: string;
+    gasLimit: number;
+    gasUsed: number;
+    hash: string;
+    logsBloom: string;
+    miner: string;
+    mixHash: string;
+    nonce: string;
+    number: number;
+    parentHash: string;
+    receiptsRoot: string;
+    sha3Uncles: string;
+    size: number;
+    stateRoot: string;
+    timestamp: number;
+    totalDifficulty: number;
+    transactions: string[] | Transaction[];
+    transactionsRoot: string;
+    uncles: unknown[];
+}
+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> | Array<RPCTransaction>;
+    transactionsRoot: string;
+    uncles: unknown[];
+}

package/lib/cjs/types/Block.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

package/lib/cjs/types/Contract.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types/Network.types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A trimmed version of https://chainid.network/chains.json
+ */
+export interface Network {
+    chainId: number;
+    ensAddress: string | null;
+    name: string;
+}

package/lib/cjs/types/Network.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/types/Transaction.types.d.ts

@@ -0,0 +1,34 @@
+export interface Transaction {
+    blockHash: string;
+    blockNumber: number;
+    from: string;
+    gas: number;
+    gasPrice: string;
+    hash: string;
+    input: string;
+    nonce: number;
+    r: string;
+    s: string;
+    to: string;
+    transactionIndex: number;
+    type: number;
+    v: string;
+    value: string;
+}
+export interface RPCTransaction {
+    blockHash: string;
+    blockNumber: 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;
+}

package/lib/cjs/types/Transaction.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src/utils/ether-to-wei.ts → lib/cjs/utils/ether-to-wei.d.ts}

@@ -1,7 +1,5 @@
 import Big from 'big.js';
-import { TinyBig, tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
-
+import { TinyBig } from '../shared/tiny-big/tiny-big';
 /**
  * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
  *
@@ -23,10 +21,4 @@ import { validateType } from '../shared/validate-type';
  * // 1000000000000000000000
  * ```
  */
-export function etherToWei(
-  etherQuantity: string | number | TinyBig | Big,
-): TinyBig {
-  validateType(etherQuantity, ['string', 'number', 'object']);
-  const result = tinyBig(etherQuantity).times('1000000000000000000');
-  return tinyBig(result);
-}
+export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.etherToWei = void 0;
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Similar to ["parseEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ *
+ * Similar to ["toWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html?highlight=towei#towei)
+ *
+ * @example
+ * ```javascript
+ * etherToWei('1000').toString()
+ * // '1000000000000000000000'
+ * etherToWei(1000).toString()
+ * // '1000000000000000000000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * etherToWei('1000').toNumber()
+ * // 1000000000000000000000
+ * etherToWei(1000).toNumber()
+ * // 1000000000000000000000
+ * ```
+ */
+function etherToWei(etherQuantity) {
+    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number', 'object']);
+    const result = (0, tiny_big_1.tinyBig)(etherQuantity).times('1000000000000000000');
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.etherToWei = etherToWei;

package/{src/utils/index.ts → lib/cjs/utils/index.d.ts}

@@ -2,5 +2,4 @@ import { etherToWei } from './ether-to-wei';
 import { isAddress } from './is-address';
 import { toChecksumAddress } from './to-checksum-address';
 import { weiToEther } from './wei-to-ether';
-
 export { etherToWei, isAddress, toChecksumAddress, weiToEther };

package/lib/cjs/utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weiToEther = exports.toChecksumAddress = exports.isAddress = exports.etherToWei = void 0;
+const ether_to_wei_1 = require("./ether-to-wei");
+Object.defineProperty(exports, "etherToWei", { enumerable: true, get: function () { return ether_to_wei_1.etherToWei; } });
+const is_address_1 = require("./is-address");
+Object.defineProperty(exports, "isAddress", { enumerable: true, get: function () { return is_address_1.isAddress; } });
+const to_checksum_address_1 = require("./to-checksum-address");
+Object.defineProperty(exports, "toChecksumAddress", { enumerable: true, get: function () { return to_checksum_address_1.toChecksumAddress; } });
+const wei_to_ether_1 = require("./wei-to-ether");
+Object.defineProperty(exports, "weiToEther", { enumerable: true, get: function () { return wei_to_ether_1.weiToEther; } });

package/lib/cjs/utils/is-address.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a boolean as to whether the input is a valid address.
+ * Does NOT support ICAP addresses
+ */
+export declare function isAddress(address: string): boolean;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAddress = void 0;
+const __1 = require("..");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Returns a boolean as to whether the input is a valid address.
+ * Does NOT support ICAP addresses
+ */
+function isAddress(address) {
+    (0, validate_type_1.validateType)(address, ['string']);
+    try {
+        (0, __1.toChecksumAddress)(address);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.isAddress = isAddress;

package/lib/cjs/utils/to-checksum-address.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Returns an Ethereum address in proper mixed-case checksum.
+ * Does NOT support ICAP
+ *
+ * @param address - An Ethereum address. Mixed, lower, and uppercase are all valid
+ *
+ * @example
+ * ```javascript
+ * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');
+ * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
+ * ```
+ *
+ * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v4/api-utils.html#utils-getaddress)
+ *
+ * Similar to ["toChecksumAddress" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#tochecksumaddress)
+ */
+export declare function toChecksumAddress(address: string): string;

package/lib/cjs/utils/to-checksum-address.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toChecksumAddress = void 0;
+const sha3_1 = require("sha3");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Returns an Ethereum address in proper mixed-case checksum.
+ * Does NOT support ICAP
+ *
+ * @param address - An Ethereum address. Mixed, lower, and uppercase are all valid
+ *
+ * @example
+ * ```javascript
+ * toChecksumAddress('0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359');
+ * // '0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359'
+ * ```
+ *
+ * Similar to ["getAddress" in ethers.js](https://docs.ethers.io/v4/api-utils.html#utils-getaddress)
+ *
+ * Similar to ["toChecksumAddress" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#tochecksumaddress)
+ */
+function toChecksumAddress(address) {
+    (0, validate_type_1.validateType)(address, ['string']);
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        throw new Error(`Invalid Ethereum address "${address}"`);
+    }
+    const _address = address.toLowerCase().replace(/^0x/i, '');
+    const keccak = new sha3_1.Keccak(256);
+    const addressHash = keccak.update(_address).digest('hex').replace(/^0x/i, '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < _address.length; i++) {
+        // If ith character is 8 to f then make it uppercase
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += _address[i].toUpperCase();
+        }
+        else {
+            checksumAddress += _address[i];
+        }
+    }
+    if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) &&
+        checksumAddress !== address) {
+        throw new Error(`Invalid Checksum address for "${address}"`);
+    }
+    return checksumAddress;
+}
+exports.toChecksumAddress = toChecksumAddress;

package/{src/utils/wei-to-ether.ts → lib/cjs/utils/wei-to-ether.d.ts}

@@ -1,8 +1,5 @@
 import Big from 'big.js';
-import { tinyBig } from '../shared/tiny-big/tiny-big';
-import { validateType } from '../shared/validate-type';
 import { TinyBig } from './../shared/tiny-big/tiny-big';
-
 /**
  * Convert from Ether to Wei
  *
@@ -26,8 +23,4 @@ import { TinyBig } from './../shared/tiny-big/tiny-big';
  * // 1000000000000000000000
  * ```
  */
-export function weiToEther(weiQuantity: string | number | TinyBig | Big) {
-  validateType(weiQuantity, ['string', 'number', 'object']);
-  const result = tinyBig(weiQuantity).div('1000000000000000000');
-  return tinyBig(result);
-}
+export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.weiToEther = void 0;
+const tiny_big_1 = require("../shared/tiny-big/tiny-big");
+const validate_type_1 = require("../shared/validate-type");
+/**
+ * Convert from Ether to Wei
+ *
+ * Similar to ["formatEther" in ethers.js](https://docs.ethers.io/v4/api-utils.html#ether-strings-and-wei)
+ *
+ * Similar to ["fromWei" in web3](https://web3js.readthedocs.io/en/v1.2.11/web3-utils.html#fromwei)
+ *
+ * @example
+ * ```javascript
+ * etherToWei('1000').toString()
+ * // '1000000000000000000000'
+ * etherToWei(1000).toString()
+ * '1000000000000000000000'
+ * ```
+ *
+ * @example
+ * ```javascript
+ * etherToWei('1000').toNumber()
+ * // 1000000000000000000000
+ * etherToWei(1000).toNumber()
+ * // 1000000000000000000000
+ * ```
+ */
+function weiToEther(weiQuantity) {
+    (0, validate_type_1.validateType)(weiQuantity, ['string', 'number', 'object']);
+    const result = (0, tiny_big_1.tinyBig)(weiQuantity).div('1000000000000000000');
+    return (0, tiny_big_1.tinyBig)(result);
+}
+exports.weiToEther = weiToEther;

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

@@ -0,0 +1,11 @@
+import { JsonRpcProvider } from '../providers/JsonRpcProvider';
+import { ContractInterface } from '../types/Contract.types';
+export declare class BaseContract {
+    private readonly _address;
+    private readonly _provider;
+    constructor(addressOrName: string, contractInterface: ContractInterface, signerOrProvider: JsonRpcProvider);
+}
+export declare function defineReadOnly<T>(object: T, name: string, value: any): void;
+export declare class Contract extends BaseContract {
+    readonly [key: string]: any;
+}

package/lib/esm/classes/Contract.js

@@ -0,0 +1,70 @@
+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 { decodeRPCResponse, encodeData, } from './utils/encode-decode-transaction';
+import { buildRPCPostBody, post } from './utils/fetchers';
+function estimateGas(txnData) {
+    txnData.split('').reduce((previousValue, currentValue) => {
+        const characterCost = currentValue === '0' ? 4 : 68;
+        return previousValue + characterCost;
+    }, 0);
+}
+export class BaseContract {
+    constructor(addressOrName, contractInterface, signerOrProvider) {
+        this._address = addressOrName;
+        this._provider = signerOrProvider;
+        contractInterface
+            .filter((jsonABIArgument) => jsonABIArgument.type === 'function')
+            .forEach((jsonABIArgument) => {
+            if ('name' in jsonABIArgument &&
+                typeof jsonABIArgument.name === 'string') {
+                defineReadOnly(this, jsonABIArgument.name, (..._args) => __awaiter(this, void 0, void 0, function* () {
+                    let functionArguments = _args;
+                    let options = {};
+                    const lastArg = _args[_args.length - 1];
+                    if (!Array.isArray(lastArg) && typeof lastArg === 'object') {
+                        options = lastArg;
+                        functionArguments = _args.slice(0, _args.length - 1);
+                    }
+                    const data = encodeData(jsonABIArgument, functionArguments);
+                    const decimalGas = typeof options.gasLimit === 'number'
+                        ? options.gasLimit
+                        : typeof (jsonABIArgument === null || jsonABIArgument === void 0 ? void 0 : jsonABIArgument.gas) ===
+                            'number'
+                            ? estimateGas(data)
+                            : null;
+                    const req = () => __awaiter(this, void 0, void 0, function* () {
+                        return yield post(this._provider._rpcUrl[this._provider._rpcUrlCounter], buildRPCPostBody('eth_call', [
+                            Object.assign({ to: this._address.toLowerCase(), data: data }, (decimalGas
+                                ? { gas: `0x${decimalGas.toString(16)}` }
+                                : {})),
+                            'latest',
+                        ])).catch((e) => {
+                            if (e.code === 'ENOTFOUND') {
+                                this._provider._rpcUrlCounter++;
+                                return req();
+                            }
+                        });
+                    });
+                    const nodeResponse = yield req();
+                    return decodeRPCResponse(jsonABIArgument, nodeResponse);
+                }));
+            }
+        });
+    }
+}
+export function defineReadOnly(object, name, value) {
+    Object.defineProperty(object, name, {
+        enumerable: true,
+        value: value,
+        writable: false,
+    });
+}
+export class Contract extends BaseContract {
+}

package/lib/esm/classes/test/Contract/crv-abi.d.ts

@@ -0,0 +1,2 @@
+import { JSONABI } from '../../../types/Contract.types';
+export declare const abi: JSONABI;