rocketh 0.11.1 → 0.11.3

package/src/environment/types.ts

@@ -128,6 +128,7 @@ export type Deployment<TAbi extends Abi> = {
 	readonly bytecode: EIP1193DATA;
 	readonly argsData: EIP1193DATA;
 	readonly metadata: string;
+	readonly numDeployments?: number;
 	readonly libraries?: Libraries;
 	readonly linkedData?: any; // TODO
 	readonly deployedBytecode?: EIP1193DATA;
@@ -197,19 +198,6 @@ export type ResolvedNamedSigners<T extends UnknownNamedAccounts> = {
 
 export type UnknownDeploymentsAcrossNetworks = Record<string, UnknownDeployments>;
 
-export type Context<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
-	NamedAccounts extends UnknownNamedAccounts = UnknownNamedAccounts
-> = {
-	network: {
-		name: string;
-		tags: {[tag: string]: boolean};
-		saveDeployments: boolean;
-	};
-	accounts: NamedAccounts;
-	artifacts: Artifacts;
-};
-
 type NetworkConfigBase = {
 	name: string;
 	tags: string[];
@@ -225,7 +213,7 @@ type NetworkConfigForEIP1193Provider = NetworkConfigBase & {
 
 export type NetworkConfig = NetworkConfigForJSONRPC | NetworkConfigForEIP1193Provider;
 
-export type Config = {
+export type Config<AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts> = {
 	network: NetworkConfig;
 	networkTags?: string[];
 	scripts?: string;
@@ -239,24 +227,26 @@ export type Config = {
 	logLevel?: number;
 	// TODO
 	gasPricing?: {};
+	accounts?: AccountsType;
 };
 
-export type ResolvedConfig = Config & {
-	deployments: string;
-	scripts: string;
-	tags: string[];
-	network: {
-		name: string;
+export type ResolvedConfig<AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts> =
+	Config & {
+		deployments: string;
+		scripts: string;
 		tags: string[];
-		fork?: boolean;
+		network: {
+			name: string;
+			tags: string[];
+			fork?: boolean;
+		};
+		saveDeployments?: boolean;
+		askBeforeProceeding?: boolean;
+		reportGasUse?: boolean;
+		accounts: AccountsType;
 	};
-	saveDeployments?: boolean;
-	askBeforeProceeding?: boolean;
-	reportGasUse?: boolean;
-};
 
 export interface Environment<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	Deployments extends UnknownDeployments = UnknownDeployments
 > {
@@ -273,8 +263,11 @@ export interface Environment<
 	unnamedAccounts: EIP1193Account[];
 	// unnamedSigners: {type: 'remote'; signer: EIP1193ProviderWithoutEvents}[];
 	addressSigners: {[name: `0x${string}`]: Signer};
-	artifacts: Artifacts;
-	save<TAbi extends Abi = Abi>(name: string, deployment: Deployment<TAbi>): Promise<Deployment<TAbi>>;
+	save<TAbi extends Abi = Abi>(
+		name: string,
+		deployment: Deployment<TAbi>,
+		options?: {doNotCountAsNewDeployment?: boolean}
+	): Promise<Deployment<TAbi>>;
 	savePendingDeployment<TAbi extends Abi = Abi>(pendingDeployment: PendingDeployment<TAbi>): Promise<Deployment<TAbi>>;
 	savePendingExecution(pendingExecution: PendingExecution): Promise<EIP1193TransactionReceipt>;
 	get<TAbi extends Abi>(name: string): Deployment<TAbi>;
@@ -283,12 +276,14 @@ export interface Environment<
 	fromAddressToNamedABIOrNull<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]} | null;
 	showMessage(message: string): void;
 	showProgress(message?: string): ProgressIndicator;
+
+	hasMigrationBeenDone(id: string): boolean;
 }
 
 export type DeploymentConstruction<TAbi extends Abi> = Omit<
 	DeployContractParameters<TAbi>,
 	'bytecode' | 'account' | 'abi' | 'chain'
-> & {account: string | EIP1193Account; artifact: string | Artifact<TAbi>};
+> & {account: string | EIP1193Account; artifact: Artifact<TAbi>};
 
 export type PartialDeployment<TAbi extends Abi = Abi> = Artifact<TAbi> & {
 	argsData: EIP1193DATA;
@@ -298,7 +293,7 @@ export type PartialDeployment<TAbi extends Abi = Abi> = Artifact<TAbi> & {
 
 export type PendingDeployment<TAbi extends Abi = Abi> = {
 	type: 'deployment';
-	name: string;
+	name?: string;
 	transaction: {
 		hash: `0x${string}`;
 		nonce?: `0x${string}`;

package/src/executor/index.ts

@@ -11,7 +11,7 @@ import type {
 	UnresolvedUnknownNamedAccounts,
 } from '../environment/types.js';
 import {createEnvironment} from '../environment/index.js';
-import {DeployScriptFunction, DeployScriptModule, ProvidedContext} from './types.js';
+import {DeployScriptFunction, DeployScriptModule} from './types.js';
 import {logger, setLogLevel, spin} from '../internal/logging.js';
 import {EIP1193GenericRequestProvider, EIP1193ProviderWithoutEvents} from 'eip-1193';
 import {getRoughGasPriceEstimate} from '../utils/eth.js';
@@ -20,26 +20,31 @@ import {formatEther} from 'viem';
 import {tsImport} from 'tsx/esm/api';
 
 export function execute<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	ArgumentsType = undefined,
 	Deployments extends UnknownDeployments = UnknownDeployments
 >(
-	context: ProvidedContext<Artifacts, NamedAccounts>,
-	callback: DeployScriptFunction<Artifacts, ResolvedNamedAccounts<NamedAccounts>, ArgumentsType, Deployments>,
-	options: {tags?: string[]; dependencies?: string[]}
-): DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType, Deployments> {
-	const scriptModule = (
-		env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>,
+	callback: DeployScriptFunction<ResolvedNamedAccounts<NamedAccounts>, ArgumentsType, Deployments>,
+	options: {tags?: string[]; dependencies?: string[]; id?: string}
+): DeployScriptModule<NamedAccounts, ArgumentsType, Deployments> {
+	const scriptModule: DeployScriptModule<NamedAccounts, ArgumentsType, Deployments> = (
+		env: Environment<ResolvedNamedAccounts<NamedAccounts>, Deployments>,
 		args?: ArgumentsType
 	) => callback(env, args);
-	scriptModule.providedContext = context;
 	scriptModule.tags = options.tags;
 	scriptModule.dependencies = options.dependencies;
-	// TODO id + skip
-	return scriptModule as unknown as DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType, Deployments>;
+	scriptModule.id = options.id;
+	// TODO runAtTheEnd ?
+	return scriptModule;
 }
 
+export type NamedAccountExecuteFunction<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts
+> = <ArgumentsType = undefined, Deployments extends UnknownDeployments = UnknownDeployments>(
+	callback: DeployScriptFunction<ResolvedNamedAccounts<NamedAccounts>, ArgumentsType, Deployments>,
+	options: {tags?: string[]; dependencies?: string[]; id?: string}
+) => DeployScriptModule<NamedAccounts, ArgumentsType, Deployments>;
+
 export interface UntypedRequestArguments {
 	readonly method: string;
 	readonly params?: readonly unknown[] | object;
@@ -61,14 +66,58 @@ export type ConfigOptions = {
 	reportGasUse?: boolean;
 };
 
-export function readConfig(options: ConfigOptions): Config {
-	type Networks = {[name: string]: {rpcUrl?: string; tags?: string[]}};
-	type ConfigFile = {networks: Networks; deployments?: string; scripts?: string};
+type Networks = {[name: string]: {rpcUrl?: string; tags?: string[]}};
+export type UserConfig<NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts> = {
+	networks?: Networks;
+	deployments?: string;
+	scripts?: string;
+	accounts?: NamedAccounts;
+};
+
+export async function readConfig<NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts>(
+	options: ConfigOptions
+): Promise<Config<NamedAccounts>> {
+	type ConfigFile = UserConfig<NamedAccounts>;
 	let configFile: ConfigFile | undefined;
-	try {
-		const configString = fs.readFileSync('./rocketh.json', 'utf-8');
-		configFile = JSON.parse(configString);
-	} catch {}
+
+	// TODO more sophisticated config file finding mechanism (look up parents, etc..)
+	const tsFilePath = path.join(process.cwd(), 'rocketh.ts');
+	const jsFilePath = path.join(process.cwd(), 'rocketh.js');
+	const jsonFilePath = path.join(process.cwd(), 'rocketh.json');
+
+	const tsVersionExists = fs.existsSync(tsFilePath);
+	const jsVersionExists = fs.existsSync(jsFilePath);
+	const jsonVersionExists = fs.existsSync(jsonFilePath);
+	const existingConfigs = [tsVersionExists, jsVersionExists, jsonVersionExists].filter(Boolean).length;
+
+	// console.log({tsFilePath, tsVersionExists, existingConfigs});
+
+	// Throw error if multiple config files exist
+	if (existingConfigs > 1) {
+		throw new Error(
+			'Multiple configuration files found. Please use only one of: rocketh.ts, rocketh.js, or rocketh.json'
+		);
+	}
+	if (tsVersionExists) {
+		const moduleLoaded = await tsImport(tsFilePath, import.meta.url);
+		configFile = moduleLoaded.config;
+		// console.log({tsVersionExists: configFile});
+		// if ((configFile as any).default) {
+		// 	configFile = (configFile as any).default as ConfigFile;
+		// 	if ((configFile as any).default) {
+		// 		logger.warn(`double default...`);
+		// 		configFile = (configFile as any).default as ConfigFile;
+		// 	}
+		// }
+	} else if (jsVersionExists) {
+		const moduleLoaded = await tsImport(jsFilePath, import.meta.url);
+		configFile = moduleLoaded.config;
+	} else if (jsonVersionExists) {
+		try {
+			const configString = fs.readFileSync(jsonFilePath, 'utf-8');
+			configFile = JSON.parse(configString);
+		} catch {}
+	}
 
 	if (configFile) {
 		if (!options.deployments && configFile.deployments) {
@@ -139,6 +188,7 @@ export function readConfig(options: ConfigOptions): Config {
 			logLevel: options.logLevel,
 			askBeforeProceeding: options.askBeforeProceeding,
 			reportGasUse: options.reportGasUse,
+			accounts: configFile?.accounts,
 		};
 	} else {
 		return {
@@ -155,63 +205,59 @@ export function readConfig(options: ConfigOptions): Config {
 			logLevel: options.logLevel,
 			askBeforeProceeding: options.askBeforeProceeding,
 			reportGasUse: options.reportGasUse,
+			accounts: configFile?.accounts,
 		};
 	}
 }
 
-export function readAndResolveConfig(options: ConfigOptions): ResolvedConfig {
-	return resolveConfig(readConfig(options));
+export async function readAndResolveConfig<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts
+>(options: ConfigOptions): Promise<ResolvedConfig<NamedAccounts>> {
+	return resolveConfig<NamedAccounts>(await readConfig<NamedAccounts>(options));
 }
 
-export function resolveConfig(config: Config): ResolvedConfig {
-	const resolvedConfig: ResolvedConfig = {
+export function resolveConfig<NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts>(
+	config: Config<NamedAccounts>
+): ResolvedConfig<NamedAccounts> {
+	const resolvedConfig: ResolvedConfig<NamedAccounts> = {
 		...config,
-		network: config.network, // TODO default to || {name: 'memory'....}
+		network: config.network,
 		deployments: config.deployments || 'deployments',
 		scripts: config.scripts || 'deploy',
 		tags: config.tags || [],
 		networkTags: config.networkTags || [],
 		saveDeployments: config.saveDeployments,
+		accounts: config.accounts || ({} as NamedAccounts),
 	};
 	return resolvedConfig;
 }
 
 export async function loadEnvironment<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts
->(
-	options: ConfigOptions,
-	context: ProvidedContext<Artifacts, NamedAccounts>
-): Promise<Environment<Artifacts, NamedAccounts, UnknownDeployments>> {
-	const resolvedConfig = readAndResolveConfig(options);
-	const {external, internal} = await createEnvironment(resolvedConfig, context);
+>(options: ConfigOptions): Promise<Environment<NamedAccounts, UnknownDeployments>> {
+	const resolvedConfig = await readAndResolveConfig<NamedAccounts>(options);
+	// console.log(JSON.stringify(resolvedConfig, null, 2));
+	const {external, internal} = await createEnvironment(resolvedConfig);
 	return external;
 }
 
 export async function loadAndExecuteDeployments<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	ArgumentsType = undefined
->(
-	options: ConfigOptions,
-	context?: ProvidedContext<Artifacts, NamedAccounts>,
-	args?: ArgumentsType
-): Promise<Environment<Artifacts, NamedAccounts, UnknownDeployments>> {
-	const resolvedConfig = readAndResolveConfig(options);
+>(options: ConfigOptions, args?: ArgumentsType): Promise<Environment<NamedAccounts, UnknownDeployments>> {
+	const resolvedConfig = await readAndResolveConfig<NamedAccounts>(options);
 	// console.log(JSON.stringify(options, null, 2));
 	// console.log(JSON.stringify(resolvedConfig, null, 2));
-	return executeDeployScripts<Artifacts, NamedAccounts, ArgumentsType>(resolvedConfig, context, args);
+	return executeDeployScripts<NamedAccounts, ArgumentsType>(resolvedConfig, args);
 }
 
 export async function executeDeployScripts<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	ArgumentsType = undefined
 >(
-	config: ResolvedConfig,
-	context?: ProvidedContext<Artifacts, NamedAccounts>,
+	config: ResolvedConfig<NamedAccounts>,
 	args?: ArgumentsType
-): Promise<Environment<Artifacts, NamedAccounts, UnknownDeployments>> {
+): Promise<Environment<NamedAccounts, UnknownDeployments>> {
 	setLogLevel(typeof config.logLevel === 'undefined' ? 0 : config.logLevel);
 
 	let filepaths;
@@ -228,33 +274,28 @@ export async function executeDeployScripts<
 			return 0;
 		});
 
-	let providedContext: ProvidedContext<Artifacts, NamedAccounts> | undefined = context;
-	const providedFromArguments = !!providedContext;
-
-	const scriptModuleByFilePath: {[filename: string]: DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>} = {};
+	const scriptModuleByFilePath: {[filename: string]: DeployScriptModule<NamedAccounts, ArgumentsType>} = {};
 	const scriptPathBags: {[tag: string]: string[]} = {};
 	const scriptFilePaths: string[] = [];
 
 	for (const filepath of filepaths) {
 		const scriptFilePath = path.resolve(filepath);
-		let scriptModule: DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>;
+		let scriptModule: DeployScriptModule<NamedAccounts, ArgumentsType>;
 		try {
 			scriptModule = await tsImport(scriptFilePath, import.meta.url);
 
+			// console.log({
+			// 	scriptFilePath,
+			// 	scriptModule,
+			// });
 			if ((scriptModule as any).default) {
-				scriptModule = (scriptModule as any).default as DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>;
+				scriptModule = (scriptModule as any).default as DeployScriptModule<NamedAccounts, ArgumentsType>;
 				if ((scriptModule as any).default) {
 					logger.warn(`double default...`);
-					scriptModule = (scriptModule as any).default as DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>;
+					scriptModule = (scriptModule as any).default as DeployScriptModule<NamedAccounts, ArgumentsType>;
 				}
 			}
 			scriptModuleByFilePath[scriptFilePath] = scriptModule;
-			if (!providedFromArguments) {
-				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) {
 			logger.error(`could not import ${filepath}`);
 			throw e;
@@ -296,21 +337,17 @@ export async function executeDeployScripts<
 		}
 	}
 
-	if (!providedContext) {
-		throw new Error(`no context loaded`);
-	}
-
-	const {internal, external} = await createEnvironment(config, providedContext);
+	const {internal, external} = await createEnvironment(config);
 
 	await internal.recoverTransactionsIfAny();
 
 	const scriptsRegisteredToRun: {[filename: string]: boolean} = {};
 	const scriptsToRun: Array<{
-		func: DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>;
+		func: DeployScriptModule<NamedAccounts, ArgumentsType>;
 		filePath: string;
 	}> = [];
 	const scriptsToRunAtTheEnd: Array<{
-		func: DeployScriptModule<Artifacts, NamedAccounts, ArgumentsType>;
+		func: DeployScriptModule<NamedAccounts, ArgumentsType>;
 		filePath: string;
 	}> = [];
 	function recurseDependencies(scriptFilePath: string) {
@@ -379,22 +416,22 @@ Do you want to proceed (note that gas price can change for each tx)`,
 	for (const deployScript of scriptsToRun.concat(scriptsToRunAtTheEnd)) {
 		const filename = path.basename(deployScript.filePath);
 		const relativeFilepath = path.relative('.', deployScript.filePath);
-		// if (deployScript.func.id && this.db.migrations[deployScript.func.id]) {
-		// 	logger.info(`skipping ${filename} as migrations already executed and complete`);
-		// 	continue;
-		// }
+		if (deployScript.func.id && external.hasMigrationBeenDone(deployScript.func.id)) {
+			logger.info(`skipping ${filename} as migrations already executed and complete`);
+			continue;
+		}
 		let skip = false;
 		const spinner = spin(`- Executing ${filename}`);
-		if (deployScript.func.skip) {
-			const spinner = spin(`  - skip?()`);
-			try {
-				skip = await deployScript.func.skip(external, args);
-				spinner.succeed(skip ? `skipping ${filename}` : undefined);
-			} catch (e) {
-				spinner.fail();
-				throw e;
-			}
-		}
+		// if (deployScript.func.skip) {
+		// 	const spinner = spin(`  - skip?()`);
+		// 	try {
+		// 		skip = await deployScript.func.skip(external, args);
+		// 		spinner.succeed(skip ? `skipping ${filename}` : undefined);
+		// 	} catch (e) {
+		// 		spinner.fail();
+		// 		throw e;
+		// 	}
+		// }
 		if (!skip) {
 			let result;
 
@@ -406,29 +443,12 @@ Do you want to proceed (note that gas price can change for each tx)`,
 				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, '  ')
-				// 	);
-				// }
+				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`
+					);
+				}
+				internal.recordMigration(deployScript.func.id);
 			}
 		}
 	}

package/src/executor/types.ts

@@ -1,49 +1,30 @@
 import type {
 	Environment,
 	ResolvedNamedAccounts,
-	UnknownArtifacts,
 	UnknownDeployments,
 	UnknownNamedAccounts,
 	UnresolvedUnknownNamedAccounts,
 } from '../environment/types.js';
 
 export type DeployScriptFunction<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnknownNamedAccounts = UnknownNamedAccounts,
 	ArgumentsTypes = undefined,
 	Deployments extends UnknownDeployments = UnknownDeployments
-> = (env: Environment<Artifacts, NamedAccounts, Deployments>, args?: ArgumentsTypes) => Promise<void | boolean>;
+> = (env: Environment<NamedAccounts, Deployments>, args?: ArgumentsTypes) => Promise<void | boolean>;
 
 export interface DeployScriptModule<
-	Artifacts extends UnknownArtifacts = UnknownArtifacts,
 	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
 	ArgumentsTypes = undefined,
 	Deployments extends UnknownDeployments = UnknownDeployments
 > {
-	(env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>, args?: ArgumentsTypes): Promise<
-		void | boolean
-	>;
-	providedContext: ProvidedContext<Artifacts, NamedAccounts>;
-	skip?: (
-		env: Environment<Artifacts, ResolvedNamedAccounts<NamedAccounts>, Deployments>,
-		args?: ArgumentsTypes
-	) => Promise<boolean>;
+	(env: Environment<ResolvedNamedAccounts<NamedAccounts>, Deployments>, args?: ArgumentsTypes): Promise<void | 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>;
+> = (env: Environment<NamedAccounts, Deployments>) => Promise<void>;

package/src/internal/types.ts

@@ -1,4 +1,5 @@
 export type InternalEnvironment = {
 	exportDeploymentsAsTypes(): Promise<void>;
 	recoverTransactionsIfAny(): Promise<void>;
+	recordMigration(id: string): void;
 };