rocketh 0.15.0-testing.17 → 0.15.0-testing.2

package/src/environment/types.ts

@@ -0,0 +1,380 @@
+import type {Abi, AbiConstructor, AbiError, AbiEvent, AbiFallback, AbiFunction, AbiReceive, Narrow} from 'abitype';
+import {
+	EIP1193Account,
+	EIP1193DATA,
+	EIP1193ProviderWithoutEvents,
+	EIP1193QUANTITY,
+	EIP1193SignerProvider,
+	EIP1193TransactionReceipt,
+	EIP1193WalletProvider,
+} from 'eip-1193';
+import type {Address, Chain, DeployContractParameters} from 'viem';
+import {
+	DeterministicDeploymentInfo,
+	type Create2DeterministicDeploymentInfo,
+	type Create3DeterministicDeploymentInfo,
+} from '../executor/index.js';
+import {ProgressIndicator} from '../internal/logging.js';
+import {TransactionHashTracker} from './providers/TransactionHashTracker.js';
+import {SignerProtocolFunction} from './index.js';
+import {ChainInfo} from '../executor/types.js';
+
+export type {Abi, AbiConstructor, AbiError, AbiEvent, AbiFallback, AbiFunction, AbiReceive};
+export type Libraries = {readonly [libraryName: string]: EIP1193Account};
+
+export type GasEstimate = 'infinite' | `${number}`;
+export type CreationGasEstimate = {
+	readonly codeDepositCost: GasEstimate;
+	readonly executionCost: GasEstimate;
+	readonly totalCost: GasEstimate;
+};
+
+export type GasEstimates = {
+	readonly creation?: CreationGasEstimate;
+	readonly external?: {
+		readonly [signature: string]: GasEstimate;
+	};
+	readonly internal?: {
+		readonly [signature: string]: GasEstimate;
+	};
+};
+
+export type Storage = {
+	readonly astId: number;
+	readonly contract: string; // canonical name <path>:<name>
+	readonly label: string; // variable name
+	readonly offset: number;
+	readonly slot: `${number}`; // slot bytes32
+	readonly type: string; // "t_mapping(t_uint256,t_struct(Cell)12382_storage)"
+};
+export type TypeDef = {
+	readonly encoding: 'inplace' | string; // TODO
+	readonly label: 'address' | 'byte24' | string; // TODO
+	readonly numberOfBytes: `${number}`;
+	readonly key?: string; // ref to another typedef
+	readonly value?: string;
+	readonly members?: readonly Storage[];
+};
+
+export type DevEventDoc = {
+	readonly details?: string;
+	readonly params?: {readonly [name: string]: string};
+};
+
+export type DevErrorDoc = {
+	readonly details?: string; // TODO check if it can exists
+	readonly params?: {readonly [name: string]: string};
+};
+
+export type DevMethodDoc = {
+	readonly details?: string; // TODO check if it can exists
+	readonly params?: {readonly [name: string]: string};
+	readonly returns?: {
+		readonly [key: string | `_${number}`]: string; // description
+	};
+};
+
+export type NoticeUserDoc = {
+	readonly notice?: string;
+};
+
+export type DevDoc = {
+	readonly events?: {
+		[signature: string]: DevEventDoc;
+	};
+	readonly errors?: {
+		[signature: string]: readonly DevErrorDoc[];
+	};
+	readonly methods: {
+		[signature: string]: DevMethodDoc;
+	};
+	readonly kind?: 'dev';
+	readonly version?: number;
+	readonly title?: string;
+	readonly author?: string;
+};
+
+export type UserDoc = {
+	readonly events?: {
+		readonly [signature: string]: NoticeUserDoc;
+	};
+	readonly errors?: {
+		readonly [signature: string]: readonly NoticeUserDoc[];
+	};
+	readonly kind?: 'user';
+	readonly methods: {
+		readonly [signature: string]: NoticeUserDoc;
+	};
+	readonly version?: number;
+	readonly notice?: string;
+};
+
+export type JSONTypePlusBigInt =
+	| bigint
+	| string
+	| number
+	| boolean
+	| null
+	| JSONTypePlusBigInt[]
+	| {[key: string]: JSONTypePlusBigInt};
+export type LinkedData = Record<string, JSONTypePlusBigInt>;
+
+export type StorageLayout = {
+	readonly storage: readonly Storage[];
+	readonly types: {
+		readonly [name: string]: TypeDef;
+	} | null;
+};
+
+export type MinimalDeployment<TAbi extends Abi = Abi> = {
+	readonly address: EIP1193Account;
+	readonly abi: Narrow<TAbi>;
+};
+
+export type Deployment<TAbi extends Abi> = MinimalDeployment<TAbi> & {
+	readonly bytecode: EIP1193DATA;
+	readonly argsData: EIP1193DATA;
+	readonly metadata: string;
+
+	readonly transaction?: {
+		readonly hash: EIP1193DATA;
+		readonly origin?: EIP1193Account;
+		readonly nonce?: EIP1193DATA;
+	};
+	readonly receipt?: {
+		blockHash: EIP1193DATA;
+		blockNumber: EIP1193QUANTITY;
+		transactionIndex: EIP1193QUANTITY;
+	};
+	readonly numDeployments?: number;
+	readonly libraries?: Libraries;
+	readonly linkedData?: LinkedData;
+	readonly deployedBytecode?: EIP1193DATA;
+	readonly linkReferences?: any; // TODO
+	readonly deployedLinkReferences?: any; // TODO
+	readonly contractName?: string;
+	readonly sourceName?: string; // relative path
+	readonly devdoc?: DevDoc;
+	readonly evm?: {
+		readonly gasEstimates?: GasEstimates | null;
+	} & any;
+	readonly storageLayout?: StorageLayout;
+	readonly userdoc?: UserDoc;
+} & Record<string, unknown>;
+
+export type Artifact<TAbi extends Abi = Abi> = {
+	readonly abi: TAbi;
+	readonly bytecode: EIP1193DATA;
+	readonly metadata: string;
+	readonly deployedBytecode?: EIP1193DATA;
+	readonly linkReferences?: any; // TODO
+	readonly deployedLinkReferences?: any; // TODO
+	readonly contractName?: string;
+	readonly sourceName?: string; // relative path
+	readonly devdoc?: DevDoc;
+	readonly evm?: {
+		readonly gasEstimates?: GasEstimates | null;
+	} & any;
+	readonly storageLayout?: StorageLayout;
+	readonly userdoc?: UserDoc;
+};
+
+export type AccountDefinition = EIP1193Account | string | number;
+
+export type AccountType =
+	| AccountDefinition
+	| {
+			[networkOrChainId: string | number]: AccountDefinition;
+	  };
+
+export type ResolvedAccount = {
+	address: EIP1193Account;
+} & Signer;
+
+export type UnknownDeployments = Record<string, Deployment<Abi>>;
+export type UnknownNamedAccounts = {
+	[name: string]: EIP1193Account;
+};
+
+export type UnresolvedUnknownNamedAccounts = {
+	[name: string]: AccountType;
+};
+
+export type ResolvedNamedAccounts<T extends UnresolvedUnknownNamedAccounts> = {
+	[Property in keyof T]: EIP1193Account;
+};
+
+export type DataType<T> = {
+	[networkOrChainId: string | number]: T;
+};
+
+export type UnknownData = {
+	[name: string]: unknown;
+};
+
+export type UnresolvedNetworkSpecificData = {
+	[name: string]: DataType<unknown>;
+};
+
+export type ResolvedNetworkSpecificData<T extends UnresolvedNetworkSpecificData> = {
+	[Property in keyof T]: T[Property] extends DataType<infer U> ? U : never;
+};
+
+export type Signer =
+	| {type: 'signerOnly'; signer: EIP1193SignerProvider}
+	| {type: 'remote'; signer: EIP1193ProviderWithoutEvents}
+	| {type: 'wallet'; signer: EIP1193WalletProvider};
+
+export type ResolvedNamedSigners<T extends UnknownNamedAccounts> = {
+	[Property in keyof T]: Signer;
+};
+
+export type UnknownDeploymentsAcrossNetworks = Record<string, UnknownDeployments>;
+
+type TargetConfigBase = {
+	name: string;
+	tags: string[];
+	fork?: boolean;
+	deterministicDeployment?: DeterministicDeploymentInfo;
+	scripts?: string | string[];
+	chainInfo?: ChainInfo;
+	pollingInterval?: number;
+	properties?: Record<string, JSONTypePlusBigInt>;
+};
+type TargetConfigForJSONRPC = TargetConfigBase & {
+	nodeUrl: string;
+};
+
+type TargetConfigForEIP1193Provider = TargetConfigBase & {
+	provider: EIP1193ProviderWithoutEvents;
+};
+
+export type TargetConfig = TargetConfigForJSONRPC | TargetConfigForEIP1193Provider;
+
+export type Config<
+	AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+> = {
+	target: TargetConfig;
+	targetTags?: string[];
+	scripts?: string | string[];
+	deployments?: string;
+	saveDeployments?: boolean;
+
+	tags?: string[];
+	askBeforeProceeding?: boolean;
+	reportGasUse?: boolean;
+
+	logLevel?: number;
+	// TODO
+	gasPricing?: {};
+	accounts?: AccountsType;
+
+	data?: Data;
+	signerProtocols?: Record<string, SignerProtocolFunction>;
+	extra?: Record<string, unknown>;
+	defaultPollingInterval?: number;
+};
+
+export type ResolvedConfig<
+	AccountsType extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData
+> = Config & {
+	deployments: string;
+	scripts: string[];
+	tags: string[];
+	target: {
+		pollingInterval: number;
+		name: string;
+		tags: string[];
+		fork?: boolean;
+		deterministicDeployment: {
+			create2: Create2DeterministicDeploymentInfo;
+			create3: Create3DeterministicDeploymentInfo;
+		};
+		nodeUrl?: string;
+		chain?: ChainInfo;
+		properties?: Record<string, JSONTypePlusBigInt>;
+	};
+	saveDeployments?: boolean;
+	askBeforeProceeding?: boolean;
+	reportGasUse?: boolean;
+	accounts: AccountsType;
+	data: Data;
+	signerProtocols: Record<string, SignerProtocolFunction>;
+	extra: Record<string, unknown>;
+	defaultPollingInterval: number;
+};
+
+export interface Environment<
+	NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts,
+	Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData,
+	Deployments extends UnknownDeployments = UnknownDeployments,
+	Extra extends Record<string, unknown> = Record<string, unknown>
+> {
+	config: ResolvedConfig;
+	network: {
+		chain: Chain;
+		name: string;
+		tags: {[tag: string]: boolean};
+		provider: TransactionHashTracker;
+	};
+	deployments: Deployments;
+	namedAccounts: ResolvedNamedAccounts<NamedAccounts>;
+	data: ResolvedNetworkSpecificData<Data>;
+	namedSigners: ResolvedNamedSigners<ResolvedNamedAccounts<NamedAccounts>>;
+	unnamedAccounts: EIP1193Account[];
+	// unnamedSigners: {type: 'remote'; signer: EIP1193ProviderWithoutEvents}[];
+	addressSigners: {[name: `0x${string}`]: Signer};
+	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>;
+	getOrNull<TAbi extends Abi>(name: string): Deployment<TAbi> | null;
+	fromAddressToNamedABI<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]};
+	fromAddressToNamedABIOrNull<TAbi extends Abi>(address: Address): {mergedABI: TAbi; names: string[]} | null;
+	showMessage(message: string): void;
+	showProgress(message?: string): ProgressIndicator;
+
+	hasMigrationBeenDone(id: string): boolean;
+	extra?: Extra;
+}
+
+export type DeploymentConstruction<TAbi extends Abi> = Omit<
+	DeployContractParameters<TAbi>,
+	'bytecode' | 'account' | 'abi' | 'chain'
+> & {account: string | EIP1193Account; artifact: Artifact<TAbi>};
+
+export type PartialDeployment<TAbi extends Abi = Abi> = Artifact<TAbi> & {
+	argsData: EIP1193DATA;
+	libraries?: Libraries;
+	linkedData?: LinkedData;
+};
+
+export type PendingDeployment<TAbi extends Abi = Abi> = {
+	type: 'deployment';
+	name?: string;
+	transaction: {
+		hash: `0x${string}`;
+		nonce?: `0x${string}`;
+		origin?: `0x${string}`;
+	};
+	partialDeployment: PartialDeployment<TAbi>;
+	expectedAddress?: `0x${string}`; // TODO we could make that a event specification so we can get address from factory event
+};
+
+export type PendingExecution = {
+	type: 'execution';
+	description?: string;
+	transaction: {
+		hash: `0x${string}`;
+		nonce?: `0x${string}`;
+		origin?: `0x${string}`;
+	};
+};
+
+export type PendingTransaction = PendingDeployment | PendingExecution;

package/src/environment/utils/artifacts.ts

@@ -1,5 +1,5 @@
 import {Abi} from 'abitype';
-import {Artifact, DevDoc, UserDoc} from '../../types.js';
+import {Artifact, DevDoc, UserDoc} from '../types.js';
 import {FunctionFragment} from 'ethers';
 
 type CreateMutable<Type> = {

package/src/environment/utils/chains.ts

@@ -1,13 +1,8 @@
+import type {Chain} from 'viem/chains';
 import * as chains from 'viem/chains';
+import {ResolvedConfig} from '../types.js';
 import {kebabCase} from 'change-case';
-import {
-	ChainConfig,
-	ChainInfo,
-	ChainUserConfig,
-	Create2DeterministicDeploymentInfo,
-	Create3DeterministicDeploymentInfo,
-	ResolvedUserConfig,
-} from '../../types.js';
+import {ChainInfo} from '../../executor/types.js';
 
 export type ChainType = 'zksync' | 'op-stack' | 'celo' | 'default';
 
@@ -35,9 +30,7 @@ const chainTypesByNames: {[chainExportName: string]: ChainType} = {
 export const chainTypes: {[chainId: string]: ChainType} = {};
 
 export const chainById: {[chainId: string]: ChainInfo} = {};
-export const allChains: {[chainExportName: string]: ChainInfo} = {...((chains as any).default || chains)};
-allChains['localhost'] = allChains['hardhat'];
-
+export const allChains = (chains as any).default || chains;
 for (const key of Object.keys(allChains)) {
 	const chain = (allChains as any)[key] as ChainInfo;
 	const chainId = chain.id.toString();
@@ -45,17 +38,17 @@ for (const key of Object.keys(allChains)) {
 	if (specificChainType) {
 		chainTypes[chainId] = specificChainType;
 	}
-	chainById[chainId] = {...chain, chainType: specificChainType};
+	chainById[chainId] = chain;
 }
 
 export const chainByCanonicalName: {[canonicalName: string]: ChainInfo} = {};
-for (const key of Object.keys(chainById)) {
-	const chain = (chainById as any)[key] as ChainInfo;
+for (const key of Object.keys(allChains)) {
+	const chain = (allChains as any)[key] as ChainInfo;
 	const canonicalName = kebabCase(chain.name);
 	chainByCanonicalName[canonicalName] = chain;
 }
 
-export function getChainById(id: string | number): ChainInfo | undefined {
+export function getChain(id: string | number): ChainInfo | undefined {
 	const chain = chainById['' + id];
 
 	return chain;
@@ -66,58 +59,22 @@ export function getChainByName(name: string): ChainInfo | undefined {
 	return chain;
 }
 
-export function getChainConfig(id: number, config: ResolvedUserConfig): ChainConfig {
-	const defaultChainInfo = getChainById(id);
-	const canonicalName = defaultChainInfo ? kebabCase(defaultChainInfo.name) : undefined;
-	if (canonicalName) {
-		if (config.chains?.[id] && config.chains?.[canonicalName]) {
-			throw new Error(
-				`chain should be configured by chainId or name but not both, remove either ${id} or ${canonicalName}`
-			);
-		}
-	}
-
-	let chainConfig: ChainUserConfig | undefined = config.chains?.[id];
-	if (!chainConfig && canonicalName) {
-		chainConfig = config.chains?.[canonicalName];
-	}
-	if (!chainConfig) {
-		chainConfig = {info: defaultChainInfo};
-	}
-
-	let chainInfo = chainConfig?.info || defaultChainInfo;
-
-	let rpcUrl = process.env['ETH_NODE_URI_' + id];
-	if (canonicalName) {
-		const fromEnv = process.env['ETH_NODE_URI_' + canonicalName];
-		if (fromEnv) {
-			rpcUrl = fromEnv;
-		}
-	}
-
-	if (!rpcUrl) {
-		rpcUrl = chainConfig.rpcUrl;
-	}
-
-	if (!rpcUrl) {
-		rpcUrl = chainConfig.info?.rpcUrls.default.http[0];
-	}
+export function getChainWithConfig(id: string, config: ResolvedConfig): ChainInfo {
+	const chain = getChain(id);
 
-	if (!rpcUrl) {
-		if (id === 31337 || id === 1337) {
-			rpcUrl = 'http://127.0.0.1:8545';
+	if (!chain) {
+		if (config.target.chain) {
+			return config.target.chain;
 		}
-	}
-
-	if (!chainInfo) {
-		if (!rpcUrl) {
-			throw new Error(`no chain info found for chain with id ${id}`);
+		console.error(`network ${config.target.name} has no public info`);
+		let nodeUrl: string | undefined;
+		if (!config.target.nodeUrl) {
+			console.error(`no nodeUrl found either for ${config.target.name}`);
 		} else {
-			console.error(`chain with id ${id} has no public info`);
+			nodeUrl = config.target.nodeUrl;
 		}
-
-		chainInfo = {
-			id,
+		return {
+			id: parseInt(id),
 			name: 'unkwown',
 			nativeCurrency: {
 				name: 'Unknown Currency',
@@ -126,59 +83,11 @@ export function getChainConfig(id: number, config: ResolvedUserConfig): ChainCon
 			},
 			rpcUrls: {
 				default: {
-					http: [rpcUrl],
+					http: nodeUrl ? [nodeUrl] : [],
 				},
 			},
 			chainType: 'default',
 		};
 	}
-
-	const create2Info = {
-		factory: '0x4e59b44847b379578588920ca78fbf26c0b4956c',
-		deployer: '0x3fab184622dc19b6109349b94811493bf2a45362',
-		funding: '10000000000000000',
-		signedTx:
-			'0xf8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222',
-	} as const;
-	const create3Info = {
-		factory: '0x000000000004d4f168daE7DB3C610F408eE22F57',
-		salt: '0x5361109ca02853ca8e22046b7125306d9ec4ae4cdecc393c567b6be861df3db6',
-		bytecode:
-			'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',
-		proxyBytecode: '0x67363d3d37363d34f03d5260086018f3',
-	} as const;
-
-	const pollingInterval = chainConfig.pollingInterval || config.defaultPollingInterval;
-
-	let deterministicDeployment: {
-		create2: Create2DeterministicDeploymentInfo;
-		create3: Create3DeterministicDeploymentInfo;
-	} = {
-		create2: (() => {
-			if (!chainConfig.deterministicDeployment) return create2Info;
-			if (!('create3' in chainConfig.deterministicDeployment) && !('create2' in chainConfig.deterministicDeployment))
-				return create2Info;
-			return chainConfig.deterministicDeployment.create2 || create2Info;
-		})(),
-		create3:
-			chainConfig.deterministicDeployment &&
-			'create3' in chainConfig.deterministicDeployment &&
-			chainConfig.deterministicDeployment.create3
-				? chainConfig.deterministicDeployment.create3
-				: create3Info,
-	};
-
-	const defaultTags: string[] = [];
-	if (chainInfo.testnet) {
-		defaultTags.push('testnet');
-	}
-
-	return {
-		info: {...chainInfo},
-		deterministicDeployment,
-		pollingInterval,
-		properties: chainConfig.properties || {},
-		rpcUrl: rpcUrl || chainInfo.rpcUrls.default.http[0],
-		tags: chainConfig.tags || [...defaultTags],
-	};
+	return chain;
 }