chore: fmt!:js

Author: guidiaz

scripts/postinstall.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const exec = require("node:child_process").execSync;
+const _exec = require("node:child_process").execSync;
 const fs = require("node:fs");
 if (!fs.existsSync(".no-postinstall") && !fs.existsSync(`${process.env.INIT_CWD}/.env_witnet`)) {
 	console.info(`Copying .env_witnet file from ${process.env.INIT_CWD}...`);

src/bin/bots/randomizer.cjs

@@ -84,7 +84,7 @@ async function main() {
 
 	program.parse();
 
-	const { host, maxGasPrice, minBalance, network, port, schedule, scheduleOverlap, scheduleTimezone, signer,target } =
+	const { host, maxGasPrice, minBalance, network, port, schedule, scheduleOverlap, scheduleTimezone, signer, target } =
 		program.opts();
 
 	traceHeader(`@WITNET/SOLIDITY RANDOMIZER BOT v${require("../../../package.json").version}`, colors.white);

src/bin/cli/framework.cjs

@@ -35,9 +35,10 @@ module.exports = async (flags = {}, params = []) => {
 		if (flags?.modals) {
 			const dict = utils.flattenRadonModals(assets);
 			if (Object.keys(dict).length > 0 && deployables.modals[network]) {
-				artifacts.push(...Object.entries(deployables.modals[network])
-					.filter(([key]) => dict[key] !== undefined)
-					.map(([key, address]) => [key, { address }])
+				artifacts.push(
+					...Object.entries(deployables.modals[network])
+						.filter(([key]) => dict[key] !== undefined)
+						.map(([key, address]) => [key, { address }]),
 				);
 			}
 		}

src/bin/cli/priceFeeds.cjs

@@ -16,13 +16,16 @@ module.exports = async (options = {}, args = []) => {
 	let { target } = options;
 	let chosen = false;
 	if (!target) {
-		const { apps } = utils.getEvmNetworkAddresses(network)
-		const targets = Object.entries(apps || {}).filter(([key, address]) => (
-			key.startsWith("WitPriceFeeds")
-				&& key.indexOf("Upgradable") === -1
-				&& key.indexOf("Trustable") === -1
-				&& address !== "0x0000000000000000000000000000000000000000"
-		)).map(([, address]) => address);
+		const { apps } = utils.getEvmNetworkAddresses(network);
+		const targets = Object.entries(apps || {})
+			.filter(
+				([key, address]) =>
+					key.startsWith("WitPriceFeeds") &&
+					key.indexOf("Upgradable") === -1 &&
+					key.indexOf("Trustable") === -1 &&
+					address !== "0x0000000000000000000000000000000000000000",
+			)
+			.map(([, address]) => address);
 		if (targets.length === 1) {
 			target = targets[0];
 		} else {
@@ -51,17 +54,21 @@ module.exports = async (options = {}, args = []) => {
 		}
 	}
 
-	let { client: priceFeedClient, legacy: isLegacy } = await helpers.prompter(_resolvePriceFeeds(target)).catch((err) => {
-		console.error(helpers.colors.mred(`Fatal: unable to initialize PriceFeeds wrapper: ${err.message || err}`));
-		process.exit(0);
-	});
+	let { client: priceFeedClient, legacy: isLegacy } = await helpers
+		.prompter(_resolvePriceFeeds(target))
+		.catch((err) => {
+			console.error(helpers.colors.mred(`Fatal: unable to initialize PriceFeeds wrapper: ${err.message || err}`));
+			process.exit(0);
+		});
 
 	let artifact = await priceFeedClient.getEvmImplClass();
 	// if the implementation class reports legacy but we already have a
 	// modern client, switch over to the fully-baked legacy helper.
 	if (artifact.includes("Legacy") && !isLegacy) {
 		priceFeedClient = await helpers.prompter(witOracle._getWitPriceFeedsLegacy(target)).catch((err) => {
-			console.error(helpers.colors.mred(`Fatal: unable to initialize legacy PriceFeeds wrapper: ${err.message || err}`));
+			console.error(
+				helpers.colors.mred(`Fatal: unable to initialize legacy PriceFeeds wrapper: ${err.message || err}`),
+			);
 			process.exit(0);
 		});
 		artifact = await priceFeedClient.getEvmImplClass();
@@ -80,7 +87,7 @@ module.exports = async (options = {}, args = []) => {
 		priceFeeds = (await priceFeedClient.lookupPriceFeeds()).sort((a, b) => a.symbol.localeCompare(b.symbol));
 	} catch (err) {
 		throw new Error(`Failed to lookup price feeds: ${err.message}`);
-	}	
+	}
 
 	if (!options["trace-back"]) {
 		const registry = await witOracle._getWitOracleRadonRegistry();

src/bin/cli/queries.cjs

@@ -70,9 +70,7 @@ module.exports = async (options = {}, args = []) => {
 	// apply limit/offset filter
 	logs =
 		!since || BigInt(since) < 0n
-			? logs
-					.slice(offset || 0)
-					.slice(0, limit || DEFAULT_LIMIT) // oldest first
+			? logs.slice(offset || 0).slice(0, limit || DEFAULT_LIMIT) // oldest first
 			: logs
 					.reverse()
 					.slice(offset || 0)

src/bin/cli/randomness.cjs

@@ -15,15 +15,16 @@ module.exports = async (options = {}, args = []) => {
 
 	const { network, provider } = witOracle;
 	helpers.traceHeader(`${network.toUpperCase()}`, helpers.colors.lcyan);
-	
+
 	let { target } = options;
 	let chosen = false;
 	if (!target) {
-		const { apps } = utils.getEvmNetworkAddresses(network)
-		const targets = Object.entries(apps || {}).filter(([key, address]) => (
-			key.startsWith("WitRandomness")
-				&& address !== "0x0000000000000000000000000000000000000000"
-		)).map(([, address]) => address);
+		const { apps } = utils.getEvmNetworkAddresses(network);
+		const targets = Object.entries(apps || {})
+			.filter(
+				([key, address]) => key.startsWith("WitRandomness") && address !== "0x0000000000000000000000000000000000000000",
+			)
+			.map(([, address]) => address);
 		if (targets.length === 1) {
 			target = targets[0];
 		} else {
@@ -39,7 +40,7 @@ module.exports = async (options = {}, args = []) => {
 			chosen = true;
 		}
 	}
-	
+
 	const randomizer = await helpers.prompter(witOracle._getWitRandomness(target)).catch((err) => {
 		console.error(colors.mred(`Fatal: unable to initialize WitRandomness wrapper: ${err.message || err}`));
 		process.exit(0);
@@ -184,9 +185,7 @@ module.exports = async (options = {}, args = []) => {
 	// apply limit/offset filter
 	logs =
 		!since || BigInt(since) < 0n
-			? logs
-					.slice(offset || 0)
-					.slice(0, limit || DEFAULT_LIMIT) // oldest first
+			? logs.slice(offset || 0).slice(0, limit || DEFAULT_LIMIT) // oldest first
 			: logs
 					.reverse()
 					.slice(offset || 0)

src/bin/cli/reports.cjs

@@ -123,9 +123,7 @@ module.exports = async (options = {}, args = []) => {
 	// apply limit/offset filter
 	logs =
 		!since || BigInt(since) < 0n
-			? logs
-					.slice(offset || 0)
-					.slice(0, limit || DEFAULT_LIMIT) // oldest first
+			? logs.slice(offset || 0).slice(0, limit || DEFAULT_LIMIT) // oldest first
 			: logs
 					.reverse()
 					.slice(offset || 0)

src/lib/utils.ts

@@ -2,7 +2,7 @@ import { Witnet } from "@witnet/sdk";
 
 import { default as cbor } from "cbor";
 
-import { AbiCoder, Contract, JsonRpcApiProvider, type JsonRpcProvider, solidityPackedKeccak256 } from "ethers";
+import { AbiCoder, Contract, type JsonRpcApiProvider, type JsonRpcProvider, solidityPackedKeccak256 } from "ethers";
 import { default as merge } from "lodash.merge";
 import { default as helpers } from "../bin/helpers.cjs";
 import { ABIs } from "../index.js";
@@ -52,11 +52,11 @@ export async function fetchWitOracleFramework(
 					.filter(([key, address]) => {
 						const base = _findBase(contracts, key);
 						return (
-							address
-								&& address !== "0x0000000000000000000000000000000000000000"
-								&& targets.includes(key)
-								&& !exclusions.includes(base)
-								&& (ABIs[key] || ABIs[base])
+							address &&
+							address !== "0x0000000000000000000000000000000000000000" &&
+							targets.includes(key) &&
+							!exclusions.includes(base) &&
+							(ABIs[key] || ABIs[base])
 						);
 					})
 					.map(async ([key, address]) => {
@@ -169,7 +169,9 @@ function _versionLastCommitOf(version?: string) {
 	}
 }
 
-export async function fetchEvmNetworkFromProvider(provider: JsonRpcApiProvider): Promise<{ name: string; id: number } | undefined> {
+export async function fetchEvmNetworkFromProvider(
+	provider: JsonRpcApiProvider,
+): Promise<{ name: string; id: number } | undefined> {
 	return provider.getNetwork().then((value) => {
 		const network = getEvmNetworkByChainId(Number(value.chainId));
 		if (network) {

src/lib/wrappers/ContractWrapper.ts

@@ -1,7 +1,7 @@
 import {
 	AbiCoder,
-	Contract,
 	type Addressable,
+	Contract,
 	type ContractRunner,
 	type Interface,
 	type InterfaceAbi,
@@ -10,7 +10,6 @@ import {
 } from "ethers";
 
 export abstract class ContractWrapper {
-
 	constructor(target: string | Addressable, abi: Interface | InterfaceAbi, runner: ContractRunner) {
 		this.abi = abi;
 		this._address = target;
@@ -40,14 +39,14 @@ export abstract class ContractWrapper {
 	 * @example
 	 * // Assuming `contractWrapper` is an instance of a class that extends ContractWrapper:
 	 * const provider = contractWrapper.provider; // Get the provider
-	 * const signer = contractWrapper.signer; // Get the signer (if available)	
+	 * const signer = contractWrapper.signer; // Get the signer (if available)
 	 */
 	protected _getProviderAndSignerFromContractRunner(runner: ContractRunner): any[] {
 		if ("provider" in runner) {
 			return [
 				runner.provider as JsonRpcApiProvider,
 				// ...this._getNetworkFromProvider(runner.provider as JsonRpcApiProvider),
-				runner instanceof JsonRpcSigner ? runner as JsonRpcSigner : undefined
+				runner instanceof JsonRpcSigner ? (runner as JsonRpcSigner) : undefined,
 			];
 		} else {
 			throw new Error(`${this.constructor.name}: ContractRunner does not have provider property`);
@@ -78,7 +77,7 @@ export abstract class ContractWrapper {
 	 */
 	protected async connect(runner: ContractRunner): Promise<ContractWrapper> {
 		[this._provider, this._signer] = this._getProviderAndSignerFromContractRunner(runner);
-		this._contract = this._contract.connect(runner) as Contract
+		this._contract = this._contract.connect(runner) as Contract;
 		this._runner = runner;
 		return this;
 	}

src/lib/wrappers/WitAppliance.ts

@@ -1,17 +1,16 @@
 import type { Addressable, Interface, InterfaceAbi } from "ethers";
 import { ABIs } from "../../index.js";
 import { getEvmNetworkAddresses } from "../utils.js";
-import type { WitOracle } from "./WitOracle.js";
 import { WitArtifact } from "./WitArtifact.js";
+import type { WitOracle } from "./WitOracle.js";
 
 export abstract class WitAppliance extends WitArtifact {
-	
 	public readonly witOracle: WitOracle;
 
 	constructor(specs: {
-		artifact: string,
-		target?: string | Addressable,
-		witOracle: WitOracle,
+		artifact: string;
+		target?: string | Addressable;
+		witOracle: WitOracle;
 	}) {
 		const { artifact, target: at, witOracle } = specs;
 		const abis: Record<string, Interface | InterfaceAbi> = ABIs;
@@ -31,18 +30,23 @@ export abstract class WitAppliance extends WitArtifact {
 	 */
 	public async attach(target: string | Addressable): Promise<WitAppliance> {
 		const contract = this._contract.attach(target);
-		return contract.getFunction("witOracle()")
+		return contract
+			.getFunction("witOracle()")
 			.staticCall()
 			.then((witOracleAddress) => {
 				if (witOracleAddress.toLowerCase() !== this.witOracle.address.toString().toLowerCase()) {
-					throw new Error(`${this.constructor.name}: Target address ${target} in EVM network ${this.witOracle.network} bound to a different WitOracle (${witOracleAddress}).`);
+					throw new Error(
+						`${this.constructor.name}: Target address ${target} in EVM network ${this.witOracle.network} bound to a different WitOracle (${witOracleAddress}).`,
+					);
 				} else {
 					super.attach(target);
 					return this;
 				}
 			})
 			.catch((error) => {
-				throw new Error(`${this.constructor.name}: Failed to attach to address ${target} in EVM network ${this.witOracle.network}: ${error.message}`);
+				throw new Error(
+					`${this.constructor.name}: Failed to attach to address ${target} in EVM network ${this.witOracle.network}: ${error.message}`,
+				);
 			});
 	}
 }