@rocketh/web 0.17.12 → 0.17.14

package/README.md

@@ -1 +1,7 @@
-# rocketh
+# @rocketh/web
+
+Rocketh for web browsers, enabling you to run deployment scripts and interact with smart contracts directly in web applications.
+
+For full documentation, visit [rocketh.dev](https://rocketh.dev).
+
+For hardhat-deploy documentation, see [rocketh.dev/hardhat-deploy/](https://rocketh.dev/hardhat-deploy/).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocketh/web",
-  "version": "0.17.12",
+  "version": "0.17.14",
   "description": "rocketh for web",
   "publishConfig": {
     "access": "public"
@@ -18,20 +18,21 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "dependencies": {
     "ldenv": "^0.3.16",
     "tsx": "^4.21.0",
-    "@rocketh/core": "0.17.7"
+    "@rocketh/core": "0.17.9"
   },
   "devDependencies": {
-    "as-soon": "^0.0.11",
+    "as-soon": "^0.1.4",
     "typescript": "^5.9.3",
-    "rocketh": "0.17.12"
+    "rocketh": "0.17.14"
   },
   "peerDependencies": {
-    "rocketh": "0.17.12"
+    "rocketh": "0.17.14"
   },
   "scripts": {
     "build": "tsc --project tsconfig.json",

package/src/deployment-store.ts

@@ -0,0 +1,83 @@
+import type {DeploymentStore} from 'rocketh/types';
+
+export function createEmptyDeploymentStore(): DeploymentStore {
+	// function getFolder(deploymentsFolder: string, environmentName: string) {
+	// 	return path.join(deploymentsFolder, environmentName);
+	// }
+	// function getFile(deploymentsFolder: string, environmentName: string, name: string) {
+	// 	return path.join(deploymentsFolder, environmentName, name);
+	// }
+
+	// async function ensureChainInfoRecorded(
+	// 	deploymentsFolder: string,
+	// 	environmentName: string,
+	// 	chainId: string,
+	// 	genesisHash?: string
+	// ) {
+	// 	if (!(await hasFile(deploymentsFolder, environmentName, '.chain'))) {
+	// 		await writeFile(
+	// 			deploymentsFolder,
+	// 			environmentName,
+	// 			'.chain',
+	// 			JSON.stringify({ chainId, genesisHash })
+	// 		);
+	// 	}
+	// }
+
+	async function writeFileWithChainInfo(
+		chaininfo: {chainId: string; genesisHash?: string},
+		deploymentsFolder: string,
+		environmentName: string,
+		name: string,
+		content: string,
+	): Promise<void> {
+		// await ensureChainInfoRecorded(
+		// 	deploymentsFolder,
+		// 	environmentName,
+		// 	chaininfo.chainId,
+		// 	chaininfo.genesisHash
+		// );
+		// fs.mkdirSync(getFolder(deploymentsFolder, environmentName), { recursive: true });
+		// fs.writeFileSync(getFile(deploymentsFolder, environmentName, name), content);
+	}
+
+	async function writeFile(
+		deploymentsFolder: string,
+		environmentName: string,
+		name: string,
+		content: string,
+	): Promise<void> {
+		// fs.mkdirSync(getFolder(deploymentsFolder, environmentName), { recursive: true });
+		// fs.writeFileSync(getFile(deploymentsFolder, environmentName, name), content);
+	}
+
+	async function readFile(deploymentsFolder: string, environmentName: string, name: string): Promise<string> {
+		// return fs.readFileSync(getFile(deploymentsFolder, environmentName, name), 'utf-8');
+		return '';
+	}
+	async function deleteFile(deploymentsFolder: string, environmentName: string, name: string): Promise<void> {
+		// fs.unlinkSync(getFile(deploymentsFolder, environmentName, name));
+	}
+
+	async function listFiles(deploymentsFolder: string, environmentName: string): Promise<string[]> {
+		// return fs.readdirSync(getFolder(deploymentsFolder, environmentName));
+		return [];
+	}
+	async function hasFile(deploymentsFolder: string, environmentName: string, name: string): Promise<boolean> {
+		// return fs.existsSync(getFile(deploymentsFolder, environmentName, name));
+		return false;
+	}
+	async function deleteAll(deploymentsFolder: string, environmentName: string): Promise<void> {
+		// fs.rmSync(getFolder(deploymentsFolder, environmentName), { recursive: true, force: true });
+	}
+
+	return {
+		writeFileWithChainInfo,
+		listFiles,
+		hasFile,
+		deleteAll,
+		readFile,
+		writeFile,
+		deleteFile,
+	};
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+import type {
+	ModuleObject,
+	DeploymentStore,
+	Environment,
+	ExecutionParams,
+	PromptExecutor,
+	UnknownDeployments,
+	UnresolvedNetworkSpecificData,
+	UnresolvedUnknownNamedAccounts,
+	UserConfig,
+	EnhancedEnvironment,
+} from '@rocketh/core/types';
+import {
+	createExecutor,
+	getChainIdForEnvironment,
+	getEnvironmentName,
+	loadDeployments,
+	loadEnvironment,
+	resolveConfig,
+	resolveExecutionParams,
+} from 'rocketh';
+import {enhanceEnvIfNeeded} from '@rocketh/core/environment';
+import {createEmptyDeploymentStore} from './deployment-store.js';
+
+const deploymentStore: DeploymentStore = createEmptyDeploymentStore();
+
+const promptExecutor: PromptExecutor = {
+	async prompt() {
+		return {
+			proceed: true,
+		};
+	},
+	exit() {
+		console.error(`not implemented`);
+	},
+};
+
+const executor = createExecutor(deploymentStore, promptExecutor);
+
+export function loadDeploymentsFromIndexedDB(
+	deploymentsPath: string,
+	networkName: string,
+	onlyABIAndAddress?: boolean,
+	expectedChain?: {chainId: string; genesisHash?: `0x${string}`; deleteDeploymentsIfDifferentGenesisHash?: boolean},
+): Promise<{
+	deployments: UnknownDeployments;
+	migrations: Record<string, number>;
+	chainId?: string;
+	genesisHash?: `0x${string}`;
+}> {
+	return loadDeployments(deploymentStore, deploymentsPath, networkName, onlyABIAndAddress, expectedChain);
+}
+
+async function loadAndExecuteDeployments<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	ArgumentsType = undefined,
+	Extra extends Record<string, unknown> = Record<string, unknown>,
+>(
+	moduleObjects: ModuleObject<NamedAccounts, Data, ArgumentsType>[],
+	config: UserConfig<NamedAccounts, Data>,
+	executionParams: ExecutionParams<Extra>,
+	args?: ArgumentsType,
+): Promise<Environment<NamedAccounts, Data, UnknownDeployments>> {
+	const userConfig = await resolveConfig<NamedAccounts, Data>(config, executionParams.config);
+	const {name: environmentName, fork} = getEnvironmentName(executionParams);
+	const chainId = await getChainIdForEnvironment(userConfig, environmentName, executionParams.provider);
+	const resolvedExecutionParams = resolveExecutionParams(userConfig, executionParams, chainId);
+	// console.log(JSON.stringify(options, null, 2));
+	// console.log(JSON.stringify(resolvedConfig, null, 2));
+
+	return executor.executeDeployScriptModules(moduleObjects, userConfig, resolvedExecutionParams, args);
+}
+
+export function setupEnvironment<
+	Extensions extends Record<string, (env: Environment<any, any, any>) => any> = {},
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Extra extends Record<string, unknown> = Record<string, unknown>,
+>(config: UserConfig<NamedAccounts, Data>, extensions: Extensions) {
+	async function loadAndExecuteDeploymentsWithExtensions<
+		Extra extends Record<string, unknown> = Record<string, unknown>,
+		ArgumentsType = undefined,
+	>(
+		moduleObjects: ModuleObject<NamedAccounts, Data, ArgumentsType>[],
+		executionParams: ExecutionParams<Extra>,
+		args?: ArgumentsType,
+	): Promise<EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions>> {
+		const env = await loadAndExecuteDeployments<NamedAccounts, Data, ArgumentsType, Extra>(
+			moduleObjects,
+			config,
+			executionParams,
+			args,
+		);
+		return enhanceEnvIfNeeded(env, extensions);
+	}
+
+	async function loadEnvironmentWithExtensions(
+		executionParams: ExecutionParams<Extra>,
+	): Promise<EnhancedEnvironment<NamedAccounts, Data, UnknownDeployments, Extensions>> {
+		const env = await loadEnvironment<NamedAccounts, Data, Extra>(config, executionParams, deploymentStore);
+		return enhanceEnvIfNeeded(env, extensions);
+	}
+
+	return {
+		loadAndExecuteDeploymentsFromModules: loadAndExecuteDeploymentsWithExtensions,
+		loadEnvironment: loadEnvironmentWithExtensions,
+	};
+}