rocketh 0.4.41 → 0.5.1

package/src/executor/index.ts

@@ -0,0 +1,302 @@
+import {traverseMultipleDirectory} from '../utils/fs';
+import path from 'node:path';
+import fs from 'node:fs';
+import type {
+	Config,
+	Environment,
+	ResolvedConfig,
+	ResolvedNamedAccounts,
+	UnknownArtifacts,
+	UnknownDeployments,
+	UnresolvedUnknownNamedAccounts,
+} from '../environment/types';
+import {createEnvironment} from '../environment';
+import {DeployScriptFunction, DeployScriptModule, ProvidedContext} from './types';
+
+require('esbuild-register/dist/node').register();
+
+export function execute<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+>(
+	context: ProvidedContext<Artifacts, NamedAccounts>,
+	callback: DeployScriptFunction<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>,
+	options: {tags?: string[]; dependencies?: string[]}
+): DeployScriptModule<Artifacts, NamedAccounts, Deployments> {
+	const scriptModule = (env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>) =>
+		callback(env);
+	scriptModule.providedContext = context;
+	scriptModule.tags = options.tags;
+	scriptModule.dependencies = options.dependencies;
+	// TODO id + skip
+	return scriptModule as unknown as DeployScriptModule<Artifacts, NamedAccounts, Deployments>;
+}
+
+export type ConfigOptions = {network: string; deployments?: string; scripts?: string; tags?: string};
+
+export function readConfig(options: ConfigOptions, extra?: {ignoreMissingRPC?: boolean}): Config {
+	type Networks = {[name: string]: {rpcUrl: string}};
+	type ConfigFile = {networks: Networks};
+	let configFile: ConfigFile | undefined;
+	try {
+		const configString = fs.readFileSync('./rocketh.json', 'utf-8');
+		configFile = JSON.parse(configString);
+	} catch {}
+
+	let nodeUrl: string;
+	const fromEnv = process.env['ETH_NODE_URI_' + options.network];
+	if (typeof fromEnv === 'string') {
+		nodeUrl = fromEnv;
+	} else {
+		if (configFile) {
+			const network = configFile.networks && configFile.networks[options.network];
+			if (network) {
+				nodeUrl = network.rpcUrl;
+			} else {
+				if (extra?.ignoreMissingRPC) {
+					nodeUrl = '';
+				} else {
+					console.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
+					process.exit(1);
+				}
+			}
+		} else {
+			if (extra?.ignoreMissingRPC) {
+				nodeUrl = '';
+			} else {
+				console.error(`network "${options.network}" is not configured. Please add it to the rocketh.json file`);
+				process.exit(1);
+			}
+		}
+	}
+
+	return {
+		nodeUrl,
+		networkName: options.network,
+		deployments: options.deployments,
+		scripts: options.scripts,
+		tags: typeof options.tags === 'undefined' ? undefined : options.tags.split(','),
+	};
+}
+
+export function readAndResolveConfig(options: ConfigOptions, extra?: {ignoreMissingRPC?: boolean}): ResolvedConfig {
+	return resolveConfig(readConfig(options, extra));
+}
+
+export function resolveConfig(config: Config): ResolvedConfig {
+	const resolvedConfig: ResolvedConfig = {
+		...config,
+		networkName: config.networkName || 'memory',
+		deployments: config.deployments || 'deployments',
+		scripts: config.scripts || 'deploy',
+		tags: config.tags || [],
+	};
+	return resolvedConfig;
+}
+
+export async function loadAndExecuteDeployments<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+>(config: Config) {
+	const resolvedConfig = resolveConfig(config);
+
+	return executeDeployScripts<Artifacts, NamedAccounts, Deployments>(resolvedConfig);
+
+	// TODO
+	// await this.export(options);
+}
+
+export async function executeDeployScripts<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+>(config: ResolvedConfig): Promise<Deployments> {
+	let filepaths;
+	filepaths = traverseMultipleDirectory([config.scripts]);
+	filepaths = filepaths
+		.filter((v) => !path.basename(v).startsWith('_'))
+		.sort((a: string, b: string) => {
+			if (a < b) {
+				return -1;
+			}
+			if (a > b) {
+				return 1;
+			}
+			return 0;
+		});
+
+	let providedContext: ProvidedContext<Artifacts, NamedAccounts> | undefined;
+
+	const scriptModuleByFilePath: {[filename: string]: DeployScriptModule} = {};
+	const scriptPathBags: {[tag: string]: string[]} = {};
+	const scriptFilePaths: string[] = [];
+
+	for (const filepath of filepaths) {
+		const scriptFilePath = path.resolve(filepath);
+		let scriptModule: DeployScriptModule;
+		try {
+			if (require.cache) {
+				delete require.cache[scriptFilePath]; // ensure we reload it every time, so changes are taken in consideration
+			}
+			scriptModule = require(scriptFilePath);
+
+			if ((scriptModule as any).default) {
+				scriptModule = (scriptModule as any).default as DeployScriptModule;
+				if ((scriptModule as any).default) {
+					console.warn(`double default...`);
+					scriptModule = (scriptModule as any).default as DeployScriptModule;
+				}
+			}
+			scriptModuleByFilePath[scriptFilePath] = scriptModule;
+			if (providedContext && providedContext !== scriptModule.providedContext) {
+				throw new Error(`context between 2 scripts is different, please share the same across them`);
+			}
+			providedContext = scriptModule.providedContext as ProvidedContext<Artifacts, NamedAccounts>;
+		} catch (e) {
+			console.error(`could not import ${filepath}`);
+			throw e;
+		}
+
+		let scriptTags = scriptModule.tags;
+		if (scriptTags !== undefined) {
+			if (typeof scriptTags === 'string') {
+				scriptTags = [scriptTags];
+			}
+			for (const tag of scriptTags) {
+				if (tag.indexOf(',') >= 0) {
+					throw new Error('Tag cannot contains commas');
+				}
+				const bag = scriptPathBags[tag] || [];
+				scriptPathBags[tag] = bag;
+				bag.push(scriptFilePath);
+			}
+		}
+
+		if (config.tags !== undefined && config.tags.length > 0) {
+			let found = false;
+			if (scriptTags !== undefined) {
+				for (const tagToFind of config.tags) {
+					for (const tag of scriptTags) {
+						if (tag === tagToFind) {
+							scriptFilePaths.push(scriptFilePath);
+							found = true;
+							break;
+						}
+					}
+					if (found) {
+						break;
+					}
+				}
+			}
+		} else {
+			scriptFilePaths.push(scriptFilePath);
+		}
+	}
+
+	if (!providedContext) {
+		throw new Error(`no context loaded`);
+	}
+
+	const {internal, external} = await createEnvironment(config, providedContext);
+
+	await internal.recoverTransactionsIfAny();
+
+	const scriptsRegisteredToRun: {[filename: string]: boolean} = {};
+	const scriptsToRun: Array<{
+		func: DeployScriptModule;
+		filePath: string;
+	}> = [];
+	const scriptsToRunAtTheEnd: Array<{
+		func: DeployScriptModule;
+		filePath: string;
+	}> = [];
+	function recurseDependencies(scriptFilePath: string) {
+		if (scriptsRegisteredToRun[scriptFilePath]) {
+			return;
+		}
+		const scriptModule = scriptModuleByFilePath[scriptFilePath];
+		if (scriptModule.dependencies) {
+			for (const dependency of scriptModule.dependencies) {
+				const scriptFilePathsToAdd = scriptPathBags[dependency];
+				if (scriptFilePathsToAdd) {
+					for (const scriptFilenameToAdd of scriptFilePathsToAdd) {
+						recurseDependencies(scriptFilenameToAdd);
+					}
+				}
+			}
+		}
+		if (!scriptsRegisteredToRun[scriptFilePath]) {
+			if (scriptModule.runAtTheEnd) {
+				scriptsToRunAtTheEnd.push({
+					filePath: scriptFilePath,
+					func: scriptModule,
+				});
+			} else {
+				scriptsToRun.push({
+					filePath: scriptFilePath,
+					func: scriptModule,
+				});
+			}
+			scriptsRegisteredToRun[scriptFilePath] = true;
+		}
+	}
+	for (const scriptFilePath of scriptFilePaths) {
+		recurseDependencies(scriptFilePath);
+	}
+
+	for (const deployScript of scriptsToRun.concat(scriptsToRunAtTheEnd)) {
+		const filename = path.basename(deployScript.filePath);
+		// if (deployScript.func.id && this.db.migrations[deployScript.func.id]) {
+		// 	log(`skipping ${filename} as migrations already executed and complete`);
+		// 	continue;
+		// }
+		let skip = false;
+		if (deployScript.func.skip) {
+			try {
+				skip = await deployScript.func.skip(external);
+			} catch (e) {
+				console.error(`skip failed for ${deployScript.filePath}`);
+				throw e;
+			}
+		}
+		if (!skip) {
+			let result;
+			try {
+				// console.log(`Executing...`);
+				result = await deployScript.func(external);
+			} catch (e) {
+				console.error(`execution failed for ${deployScript.filePath}`);
+				throw e;
+			}
+			if (result && typeof result === 'boolean') {
+				// if (!deployScript.func.id) {
+				// 	throw new Error(
+				// 		`${deployScript.filePath} return true to not be executed again, but does not provide an id. the script function needs to have the field "id" to be set`
+				// 	);
+				// }
+				// this.db.migrations[deployScript.func.id] = Math.floor(Date.now() / 1000);
+
+				const deploymentFolderPath = config.deployments;
+
+				// TODO refactor to extract this whole path and folder existence stuff
+				// const toSave = this.db.writeDeploymentsToFiles && this.network.saveDeployments;
+				// if (toSave) {
+				// 	try {
+				// 		fs.mkdirSync(this.deploymentsPath);
+				// 	} catch (e) {}
+				// 	try {
+				// 		fs.mkdirSync(path.join(this.deploymentsPath, deploymentFolderPath));
+				// 	} catch (e) {}
+				// 	fs.writeFileSync(
+				// 		path.join(this.deploymentsPath, deploymentFolderPath, '.migrations.json'),
+				// 		JSON.stringify(this.db.migrations, null, '  ')
+				// 	);
+				// }
+			}
+		}
+	}
+
+	return external.deployments as Deployments;
+}

package/src/executor/types.ts

@@ -0,0 +1,42 @@
+import type {
+	Environment,
+	ResolvedNamedAccounts,
+	UnknownArtifacts,
+	UnknownDeployments,
+	UnknownNamedAccounts,
+	UnresolvedUnknownNamedAccounts,
+} from '../environment/types';
+
+export type DeployScriptFunction<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnknownNamedAccounts = UnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+> = (env: Environment<Artifacts, NamedAccounts, Deployments>) => Promise<void | boolean>;
+
+export interface DeployScriptModule<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+> {
+	(env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>): Promise<void | boolean>;
+	providedContext: ProvidedContext<Artifacts, NamedAccounts>;
+	skip?: (env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>) => Promise<boolean>;
+	tags?: string[];
+	dependencies?: string[];
+	runAtTheEnd?: boolean;
+	id?: string;
+}
+
+export type ProvidedContext<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts
+> = {
+	accounts?: NamedAccounts;
+	artifacts: Artifacts;
+};
+
+export type ScriptCallback<
+	Artifacts extends UnknownArtifacts = UnknownArtifacts,
+	NamedAccounts extends UnknownNamedAccounts = UnknownNamedAccounts,
+	Deployments extends UnknownDeployments = UnknownDeployments
+> = (env: Environment<Artifacts, NamedAccounts, Deployments>) => Promise<void>;

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './executor';
+export * from './executor/types';
+export * from './environment/types';
+export {extendEnvironment, handleSignerProtocol} from './environment';
+export {loadDeployments} from './environment/deployments';

package/src/internal/types.ts

@@ -0,0 +1,6 @@
+import {Config} from '../environment/types';
+
+export type InternalEnvironment = {
+	exportDeploymentsAsTypes(): Promise<void>;
+	recoverTransactionsIfAny(): Promise<void>;
+};

package/src/utils/fs.ts

@@ -0,0 +1,70 @@
+// taken from https://github.com/vitejs/vite/blob/63524bac878e8d3771d34ad7ad2e10cd16870ff4/packages/vite/src/node/utils.ts#L371-L400
+import fs from 'node:fs';
+import path from 'node:path';
+
+interface LookupFileOptions {
+	pathOnly?: boolean;
+	rootDir?: string;
+	predicate?: (file: string) => boolean;
+}
+
+export function lookupFile(dir: string, formats: string[], options?: LookupFileOptions): string | undefined {
+	for (const format of formats) {
+		const fullPath = path.join(dir, format);
+		if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+			const result = options?.pathOnly ? fullPath : fs.readFileSync(fullPath, 'utf-8');
+			if (!options?.predicate || options.predicate(result)) {
+				return result;
+			}
+		}
+	}
+	const parentDir = path.dirname(dir);
+	if (parentDir !== dir && (!options?.rootDir || parentDir.startsWith(options?.rootDir))) {
+		return lookupFile(parentDir, formats, options);
+	}
+}
+
+export function traverseMultipleDirectory(dirs: string[]): string[] {
+	const filepaths = [];
+	for (const dir of dirs) {
+		let filesStats = traverse(dir);
+		filesStats = filesStats.filter((v) => !v.directory);
+		for (const filestat of filesStats) {
+			filepaths.push(path.join(dir, filestat.relativePath));
+		}
+	}
+	return filepaths;
+}
+
+export const traverse = function (
+	dir: string,
+	result: any[] = [],
+	topDir?: string,
+	filter?: (name: string, stats: any) => boolean // TODO any is Stats
+): Array<{
+	name: string;
+	path: string;
+	relativePath: string;
+	mtimeMs: number;
+	directory: boolean;
+}> {
+	fs.readdirSync(dir).forEach((name) => {
+		const fPath = path.resolve(dir, name);
+		const stats = fs.statSync(fPath);
+		if ((!filter && !name.startsWith('.')) || (filter && filter(name, stats))) {
+			const fileStats = {
+				name,
+				path: fPath,
+				relativePath: path.relative(topDir || dir, fPath),
+				mtimeMs: stats.mtimeMs,
+				directory: stats.isDirectory(),
+			};
+			if (fileStats.directory) {
+				result.push(fileStats);
+				return traverse(fPath, result, topDir || dir, filter);
+			}
+			result.push(fileStats);
+		}
+	});
+	return result;
+};

package/src/utils/json.ts

@@ -0,0 +1,26 @@
+// TODO share with db-utils
+export function bnReplacer(k: string, v: any): any {
+	if (typeof v === 'bigint') {
+		return v.toString() + 'n';
+	}
+	return v;
+}
+
+export function bnReviver(k: string, v: any): any {
+	if (
+		typeof v === 'string' &&
+		(v.startsWith('-') ? !isNaN(parseInt(v.charAt(1))) : !isNaN(parseInt(v.charAt(0)))) &&
+		v.charAt(v.length - 1) === 'n'
+	) {
+		return BigInt(v.slice(0, -1));
+	}
+	return v;
+}
+
+export function JSONToString<T = unknown>(json: unknown, space?: string | number) {
+	return JSON.stringify(json, bnReplacer, space);
+}
+
+export function stringToJSON<T = unknown>(str: string): T {
+	return JSON.parse(str, bnReviver);
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"compilerOptions": {
+		"moduleResolution": "node",
+		"lib": ["ES2020"],
+		"target": "ES2020",
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true,
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"resolveJsonModule": true,
+		"module": "Node16"
+	}
+}

package/tsup.config.ts

@@ -0,0 +1,5 @@
+import {defineConfig} from 'tsup';
+export default defineConfig({
+	outDir: 'dist',
+	sourcemap: true,
+});

package/.gitattributes

@@ -1 +0,0 @@
-* text=auto eol=lf

package/bitski_subprovider.js

@@ -1,148 +0,0 @@
-const ethers = require('ethers');
-const { BigNumber } = ethers;
-const Bitski = require("bitski-node");
-const {
-    log
-} = require('./utils');
-
-const BitskiSubProvider = function(clientID, credentialID, secret, accounts, chainId, config) {
-    let network = 'mainnet';
-    if(chainId === '4') {
-        network = 'rinkeby';
-    } else if (chainId === '42') {
-        network = 'kovan';
-    } // else if (chainId == 3) {
-    //     network = 'ropsten';
-    // }
-
-    this.lastId = 0;
-    const options = {
-        credentials: {
-          id: credentialID,
-          secret,
-        },
-        network,
-        debug: config.debug,
-        disableBlockTracking: true,
-    };
-      
-    // Pass options with the provider
-    this.bitskiProvider = Bitski.getProvider(clientID, options);
-    // this.bitskiProvider._blockTracker.stop();
-    this.accounts = accounts;
-}
-
-BitskiSubProvider.prototype.setEngine = function(engine) {
-    this.engine = engine;
-}
-
-BitskiSubProvider.prototype.fetchGasPrice = function() {
-    const self = this;
-    return new Promise((resolve, reject) => {
-        self.engine.sendAsync({id: ++this.lastId, method: 'eth_gasPrice', jsonrpc: '2.0'}, (error, json) =>{
-            if(error) {
-                reject(error);
-            } else {
-                resolve(json.result);
-            }
-        });
-    })
-}
-
-BitskiSubProvider.prototype.fetchNonce = function(from) {
-    const self = this;
-    return new Promise((resolve, reject) => {
-        self.engine.sendAsync({ id: ++this.lastId, method: 'eth_getTransactionCount', params: [from, 'latest'], jsonrpc: '2.0'}, (error, json) =>{
-            if(error) {
-                reject(error);
-            } else {
-                resolve(json.result);
-            }
-        });
-    })
-}
-
-BitskiSubProvider.prototype.fetchBalance = function(from) {
-    const self = this;
-    return new Promise((resolve, reject) => {
-        self.engine.sendAsync({ id: ++self.lastId, method: 'eth_getBalance', params: [from, 'latest'], jsonrpc: '2.0'}, (error, json) =>{
-            if(error) {
-                reject(error);
-            } else {
-                resolve(json.result);
-            }
-        });
-    })
-}
-
-BitskiSubProvider.prototype.handleRequest = async function(payload, next, end) {
-    const self = this;
-    if (payload.method === 'eth_accounts' && this.accounts) {
-        return end(null, this.accounts);
-    } else if (payload.method === 'eth_sendTransaction') {
-        const rawTx = payload.params[0];
-        const from = rawTx.from;
-
-        if(!rawTx.gas) {
-            return end(new Error('gas not specified'));
-        }
-
-        const gasPrice = BigNumber.from(rawTx.gasPrice || await this.fetchGasPrice());
-        const gas = BigNumber.from(rawTx.gas);
-        const balance = BigNumber.from(await this.fetchBalance(from));
-        const value = BigNumber.from(rawTx.value || 0);
-        const balanceRequired = (gasPrice.mul(gas)).add(value);
-        
-        // console.log({
-        //     gas: gas.toString(),
-        //     value: value.toString(),
-        //     gasPrice: gasPrice.toString(),
-        //     balanceRequired: balanceRequired.toString(),
-        //     balance: balance.toString(),
-        // })
-        if(balance.lt(balanceRequired)) {
-            return end(new Error('Not enough balance: ' 
-                + balanceRequired.toString()
-                + '( '  + gas.toString()  + ' gas x ' + gasPrice.toString() + ' gasPrice'
-                + ' ) > ' + balance.toString()));
-        }
-
-        const nonce = await this.fetchNonce(from);
-        let result;
-        try{
-            rawTx.gasPrice = gasPrice.toHexString();
-            rawTx.value = value.toHexString();
-            rawTx.gas = gas.toHexString();
-            rawTx.nonce = nonce;
-            // console.log(JSON.stringify(rawTx, null, '  '));
-            result = await this.sendTransaction(rawTx);
-        }catch(e) {
-            return end(e);
-        }
-        return end(null, result);
-    } else if(payload.method == 'eth_sign') { 
-        let signedMessage;
-        try{
-            signedMessage = await this.signMessage(payload.params[0], payload.params[1]);
-        } catch(e) {
-            return end(e);
-        }
-        return end(null, signedMessage);
-    } else {
-       next();
-    }
-}
-
-BitskiSubProvider.prototype.signTransaction = async function(from, rawTx) {
-    return this.bitskiProvider.send('eth_signTransaction', [rawTx]);
-}
-
-BitskiSubProvider.prototype.sendTransaction = async function(tx) {
-    return this.bitskiProvider.send('eth_sendTransaction', [tx]);
-}
-
-BitskiSubProvider.prototype.signMessage = function(from, message) {
-    throw new Error('rocketh TODO: sign Message not implemented in bitski provider');
-}
-
-module.exports = BitskiSubProvider;