@rocketh/core 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018-present Ronan Sandford
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @rocketh/core

package/dist/environment/index.d.ts

@@ -0,0 +1,17 @@
+import { Environment, UnknownDeployments, UnresolvedUnknownNamedAccounts, UnresolvedNetworkSpecificData, ResolvedExecutionParams, ResolvedUserConfig, DeploymentStore } from '../types.js';
+import { InternalEnvironment } from '../internal/types.js';
+export declare function loadDeployments(deploymentStore: DeploymentStore, 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}`;
+}>;
+export declare function createEnvironment<NamedAccounts extends UnresolvedUnknownNamedAccounts = UnresolvedUnknownNamedAccounts, Data extends UnresolvedNetworkSpecificData = UnresolvedNetworkSpecificData, Deployments extends UnknownDeployments = UnknownDeployments>(userConfig: ResolvedUserConfig<NamedAccounts, Data>, resolvedExecutionParams: ResolvedExecutionParams, deploymentStore: DeploymentStore): Promise<{
+    internal: InternalEnvironment;
+    external: Environment<NamedAccounts, Data, Deployments>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/environment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/environment/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIN,WAAW,EAOX,kBAAkB,EAClB,8BAA8B,EAC9B,6BAA6B,EAG7B,uBAAuB,EACvB,kBAAkB,EAElB,eAAe,EACf,MAAM,aAAa,CAAC;AAErB,OAAO,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AA8BzD,wBAAsB,eAAe,CACpC,eAAe,EAAE,eAAe,EAChC,eAAe,EAAE,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,iBAAiB,CAAC,EAAE,OAAO,EAC3B,aAAa,CAAC,EAAE;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;IAAC,uCAAuC,CAAC,EAAE,OAAO,CAAA;CAAC,GAC/G,OAAO,CAAC;IACV,WAAW,EAAE,kBAAkB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,KAAK,MAAM,EAAE,CAAC;CAC5B,CAAC,CAgGD;AAED,wBAAsB,iBAAiB,CACtC,aAAa,SAAS,8BAA8B,GAAG,8BAA8B,EACrF,IAAI,SAAS,6BAA6B,GAAG,6BAA6B,EAC1E,WAAW,SAAS,kBAAkB,GAAG,kBAAkB,EAE3D,UAAU,EAAE,kBAAkB,CAAC,aAAa,EAAE,IAAI,CAAC,EACnD,uBAAuB,EAAE,uBAAuB,EAChD,eAAe,EAAE,eAAe,GAC9B,OAAO,CAAC;IAAC,QAAQ,EAAE,mBAAmB,CAAC;IAAC,QAAQ,EAAE,WAAW,CAAC,aAAa,EAAE,IAAI,EAAE,WAAW,CAAC,CAAA;CAAC,CAAC,CAgoBnG"}

package/dist/environment/index.js

@@ -0,0 +1,630 @@
+import { JSONToString, stringToJSON } from '../utils/json.js';
+import { log, spin } from '../internal/logging.js';
+import { mergeArtifacts } from './utils/artifacts.js';
+import { TransactionHashTrackerProvider } from './providers/TransactionHashTracker.js';
+function wait(numSeconds) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, numSeconds * 1000);
+    });
+}
+function displayTransaction(transaction) {
+    if (transaction.type === '0x2') {
+        return `(maxFeePerGas: ${BigInt(transaction.maxFeePerGas).toString()}, maxPriorityFeePerGas: ${BigInt(transaction.maxPriorityFeePerGas).toString()})`;
+    }
+    else {
+        return `(gasPrice: ${BigInt(transaction.gasPrice).toString()})`;
+    }
+}
+export async function loadDeployments(deploymentStore, deploymentsPath, networkName, onlyABIAndAddress, expectedChain) {
+    const deploymentsFound = {};
+    let fileNames;
+    try {
+        fileNames = await deploymentStore.listFiles(deploymentsPath, networkName, (name) => !(name.startsWith('.') && name !== '.migrations.json') && name !== 'solcInputs');
+    }
+    catch (e) {
+        // console.log('no folder at ' + deployPath);
+        return { deployments: {}, migrations: {} };
+    }
+    let chainId;
+    let genesisHash;
+    if (fileNames.length > 0) {
+        if (await deploymentStore.hasFile(deploymentsPath, networkName, '.chain')) {
+            const chainSTR = await deploymentStore.readFile(deploymentsPath, networkName, '.chain');
+            const chainData = JSON.parse(chainSTR);
+            chainId = chainData.chainId;
+            genesisHash = chainData.genesisHash;
+        }
+        else if (await deploymentStore.hasFile(deploymentsPath, networkName, '.chainId')) {
+            chainId = await deploymentStore.readFile(deploymentsPath, networkName, '.chainId');
+        }
+        else {
+            throw new Error(`A '.chain' or '.chainId' file is expected to be present in the deployment folder for network ${networkName}`);
+        }
+        if (expectedChain) {
+            if (expectedChain.chainId !== chainId) {
+                throw new Error(`Loading deployment from environment '${networkName}' (with chainId: ${chainId}) for a different chainId (${expectedChain.chainId})`);
+            }
+            if (genesisHash) {
+                if (expectedChain.genesisHash && expectedChain.genesisHash !== genesisHash) {
+                    if (expectedChain.deleteDeploymentsIfDifferentGenesisHash) {
+                        // we delete the old folder
+                        await deploymentStore.deleteAll(deploymentsPath, networkName);
+                        return { deployments: {}, migrations: {} };
+                    }
+                    else {
+                        throw new Error(`Loading deployment from environment '${networkName}' (with genesisHash: ${genesisHash}) for a different genesisHash (${expectedChain.genesisHash})`);
+                    }
+                }
+            }
+            else {
+                console.warn(`genesisHash not found in environment '${networkName}' (with chainId: ${chainId}), writing .chain with expected one...`);
+                await deploymentStore.writeFile(deploymentsPath, networkName, '.chain', JSON.stringify({ chainId: expectedChain.chainId, genesisHash: expectedChain.genesisHash }));
+                try {
+                    await deploymentStore.deleteFile(deploymentsPath, networkName, '.chainId');
+                }
+                catch { }
+            }
+        }
+    }
+    else {
+        return { deployments: {}, migrations: {} };
+    }
+    let migrations = {};
+    const migrationsFileName = '.migrations.json';
+    if (await deploymentStore.hasFile(deploymentsPath, networkName, migrationsFileName)) {
+        try {
+            migrations = JSON.parse(await deploymentStore.readFile(deploymentsPath, networkName, migrationsFileName));
+        }
+        catch (err) {
+            console.error(`failed to parse .migrations.json`);
+        }
+    }
+    for (const fileName of fileNames) {
+        if (fileName.substring(fileName.length - 5) === '.json' && fileName !== '.migrations.json') {
+            let deployment = JSON.parse(await deploymentStore.readFile(deploymentsPath, networkName, fileName));
+            if (onlyABIAndAddress) {
+                deployment = {
+                    address: deployment.address,
+                    abi: deployment.abi,
+                    linkedData: deployment.linkedData,
+                };
+            }
+            const name = fileName.slice(0, fileName.length - 5);
+            // console.log('fetching ' + deploymentFileName + '  for ' + name);
+            deploymentsFound[name] = deployment;
+        }
+    }
+    return { deployments: deploymentsFound, migrations, chainId, genesisHash };
+}
+export async function createEnvironment(userConfig, resolvedExecutionParams, deploymentStore) {
+    const rawProvider = resolvedExecutionParams.provider;
+    const provider = new TransactionHashTrackerProvider(rawProvider);
+    const chainIdHex = await provider.request({ method: 'eth_chainId' });
+    const chainId = '' + Number(chainIdHex);
+    let genesisHash;
+    try {
+        let genesisBlock;
+        try {
+            genesisBlock = await provider.request({ method: 'eth_getBlockByNumber', params: ['earliest', false] });
+        }
+        catch {
+            genesisBlock = await provider.request({ method: 'eth_getBlockByNumber', params: ['0x0', false] });
+        }
+        if (!genesisBlock) {
+            console.error(`failed to get genesis block, returned null`);
+        }
+        genesisHash = genesisBlock?.hash;
+    }
+    catch (err) {
+        console.error(`failed to get genesis block`);
+    }
+    const deploymentsFolder = userConfig.deployments;
+    const environmentName = resolvedExecutionParams.environment.name;
+    const saveDeployments = resolvedExecutionParams.saveDeployments;
+    let networkTags = {};
+    for (const networkTag of resolvedExecutionParams.environment.tags) {
+        networkTags[networkTag] = true;
+    }
+    const resolvedAccounts = {};
+    const allRemoteAccounts = await provider.request({ method: 'eth_accounts' });
+    const accountCache = {};
+    async function getAccount(name, accounts, accountDef) {
+        if (accountCache[name]) {
+            return accountCache[name];
+        }
+        let account;
+        if (typeof accountDef === 'number') {
+            const accountPerIndex = allRemoteAccounts[accountDef];
+            if (accountPerIndex) {
+                accountCache[name] = account = {
+                    type: 'remote',
+                    address: accountPerIndex,
+                    signer: provider,
+                };
+            }
+        }
+        else if (typeof accountDef === 'string') {
+            if (accountDef.startsWith('0x')) {
+                if (accountDef.length === 66) {
+                    const privateKeyProtocol = userConfig.signerProtocols?.['privateKey'];
+                    if (privateKeyProtocol) {
+                        const namedSigner = await privateKeyProtocol(`privateKey:${accountDef}`);
+                        const [address] = await namedSigner.signer.request({ method: 'eth_accounts' });
+                        accountCache[name] = account = {
+                            ...namedSigner,
+                            address,
+                        };
+                    }
+                }
+                else {
+                    accountCache[name] = account = {
+                        type: 'remote',
+                        address: accountDef,
+                        signer: provider,
+                    };
+                }
+            }
+            else {
+                if (accountDef.indexOf(':') > 0) {
+                    const [protocolID, extra] = accountDef.split(':');
+                    const protocol = userConfig.signerProtocols?.[protocolID];
+                    if (!protocol) {
+                        throw new Error(`protocol: ${protocolID} is not supported`);
+                    }
+                    const namedSigner = await protocol(accountDef);
+                    const [address] = await namedSigner.signer.request({ method: 'eth_accounts' });
+                    accountCache[name] = account = {
+                        ...namedSigner,
+                        address,
+                    };
+                }
+                else {
+                    const accountFetched = await getAccount(name, accounts, accounts[accountDef]);
+                    if (accountFetched) {
+                        accountCache[name] = account = accountFetched;
+                    }
+                }
+            }
+        }
+        else {
+            // TODO allow for canonical chain name ?
+            const accountForNetwork = accountDef[environmentName] || accountDef[chainId] || accountDef['default'];
+            if (typeof accountForNetwork !== undefined) {
+                const accountFetched = await getAccount(name, accounts, accountForNetwork);
+                if (accountFetched) {
+                    accountCache[name] = account = accountFetched;
+                }
+            }
+        }
+        return account;
+    }
+    if (userConfig.accounts) {
+        const accountNames = Object.keys(userConfig.accounts);
+        for (const accountName of accountNames) {
+            const account = await getAccount(accountName, userConfig.accounts, userConfig.accounts[accountName]);
+            if (!account) {
+                throw new Error(`cannot get account for ${accountName} = ${JSON.stringify(userConfig.accounts[accountName], null, 2)}\nEnsure your provider (or hardhat) has some accounts set up for ${environmentName}\n`);
+            }
+            resolvedAccounts[accountName] = account;
+        }
+    }
+    const resolvedData = {};
+    async function getData(name, dataDef) {
+        const dataForNetwork = dataDef[environmentName] || dataDef[chainId] || dataDef['default'];
+        return dataForNetwork;
+    }
+    if (userConfig.data) {
+        const dataFields = Object.keys(userConfig.data);
+        for (const dataField of dataFields) {
+            let fieldData = await getData(dataField, userConfig.data[dataField]);
+            resolvedData[dataField] = fieldData;
+        }
+    }
+    const context = {
+        accounts: resolvedAccounts,
+        data: resolvedData,
+        fork: resolvedExecutionParams.environment.fork,
+        saveDeployments,
+        tags: networkTags,
+    };
+    const { deployments, migrations } = await loadDeployments(deploymentStore, deploymentsFolder, environmentName, false, context.fork
+        ? undefined
+        : {
+            chainId,
+            genesisHash,
+            deleteDeploymentsIfDifferentGenesisHash: true,
+        });
+    const namedAccounts = {};
+    const namedSigners = {};
+    const addressSigners = {};
+    for (const entry of Object.entries(resolvedAccounts)) {
+        const name = entry[0];
+        const { address, ...namedSigner } = entry[1];
+        namedAccounts[name] = address;
+        addressSigners[address] = namedSigner;
+        namedSigners[name] = namedSigner;
+    }
+    const unnamedAccounts = allRemoteAccounts.filter((v) => !addressSigners[v]);
+    for (const account of unnamedAccounts) {
+        addressSigners[account] = {
+            type: 'remote',
+            signer: provider,
+        };
+    }
+    const perliminaryEnvironment = {
+        context: {
+            saveDeployments: context.saveDeployments,
+        },
+        name: environmentName,
+        tags: context.tags,
+        deployments: deployments,
+        namedAccounts: namedAccounts,
+        data: resolvedData,
+        namedSigners: namedSigners,
+        unnamedAccounts,
+        addressSigners: addressSigners,
+        network: {
+            chain: resolvedExecutionParams.chain,
+            fork: context.fork,
+            provider,
+            deterministicDeployment: resolvedExecutionParams.environment.deterministicDeployment,
+            // for backward compatibility
+            tags: context.tags,
+        },
+        extra: resolvedExecutionParams.extra || {},
+    };
+    // const signer = {
+    // 	async sendTransaction(
+    // 		provider: EIP1193ProviderWithoutEvents,
+    // 		account: {
+    // 			addresss: EIP1193Account;
+    // 			config: unknown;
+    // 		},
+    // 		transaction: EIP1193TransactionEIP1193DATA
+    // 	): Promise<EIP1193DATA> {
+    // 		return '0x';
+    // 	},
+    // };
+    // async function sendTransaction(transaction: EIP1193TransactionEIP1193DATA): Promise<EIP1193DATA> {
+    // 	return '0x';
+    // }
+    function get(name) {
+        const deployment = deployments[name];
+        if (!deployment) {
+            throw new Error(`no deployment named "${name}" found.`);
+        }
+        return deployment;
+    }
+    function getOrNull(name) {
+        return (deployments[name] || null);
+    }
+    function hasMigrationBeenDone(id) {
+        return migrations[id] ? true : false;
+    }
+    function recordMigration(id) {
+        migrations[id] = Math.floor(Date.now() / 1000);
+        if (context.saveDeployments) {
+            deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, '.migrations.json', JSON.stringify(migrations));
+        }
+    }
+    function fromAddressToNamedABIOrNull(address) {
+        let list = [];
+        for (const name of Object.keys(deployments)) {
+            const deployment = deployments[name];
+            if (deployment.address.toLowerCase() == address.toLowerCase()) {
+                list.push({ name, artifact: deployment });
+            }
+        }
+        if (list.length === 0) {
+            return null;
+        }
+        const { mergedABI } = mergeArtifacts(list);
+        return {
+            mergedABI: mergedABI,
+            names: list.map((v) => v.name),
+        };
+    }
+    function fromAddressToNamedABI(address) {
+        const n = fromAddressToNamedABIOrNull(address);
+        if (!n) {
+            throw new Error(`could not find artifact for address ${address}`);
+        }
+        return n;
+    }
+    async function save(name, deployment, options) {
+        if (!options?.doNotCountAsNewDeployment) {
+            let numDeployments = 1;
+            const oldDeployment = deployments[name];
+            if (oldDeployment) {
+                numDeployments = (oldDeployment.numDeployments || 1) + 1;
+            }
+            deployments[name] = { ...deployment, numDeployments };
+        }
+        else {
+            deployments[name] = { ...deployment, numDeployments: 1 };
+        }
+        if (context.saveDeployments) {
+            deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, `${name}.json`, JSONToString(deployment, 2));
+        }
+        return deployment;
+    }
+    async function recoverTransactionsIfAny() {
+        if (!context.saveDeployments) {
+            return;
+        }
+        let existingPendingTansactions;
+        try {
+            existingPendingTansactions = stringToJSON(await deploymentStore.readFile(deploymentsFolder, environmentName, '.pending_transactions.json'));
+        }
+        catch {
+            existingPendingTansactions = [];
+        }
+        if (existingPendingTansactions.length > 0) {
+            while (existingPendingTansactions.length > 0) {
+                const pendingTransaction = existingPendingTansactions.shift();
+                if (pendingTransaction) {
+                    if (pendingTransaction.type === 'deployment') {
+                        const spinner = spin(`recovering ${pendingTransaction.name} with transaction ${pendingTransaction.transaction.hash}`);
+                        try {
+                            await waitForDeploymentTransactionAndSave(pendingTransaction);
+                            await deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, '.pending_transactions.json', JSONToString(existingPendingTansactions, 2));
+                            spinner.succeed();
+                        }
+                        catch (e) {
+                            spinner.fail();
+                            throw e;
+                        }
+                    }
+                    else {
+                        const spinner = spin(`recovering execution's transaction ${pendingTransaction.transaction.hash}`);
+                        try {
+                            await waitForTransaction(pendingTransaction.transaction.hash);
+                            await deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, '.pending_transactions.json', JSONToString(existingPendingTansactions, 2));
+                            spinner.succeed();
+                        }
+                        catch (e) {
+                            spinner.fail();
+                            throw e;
+                        }
+                    }
+                }
+            }
+            await deploymentStore.deleteFile(deploymentsFolder, environmentName, '.pending_transactions.json');
+        }
+    }
+    async function savePendingTransaction(pendingTransaction) {
+        if (context.saveDeployments) {
+            let existingPendinTransactions;
+            try {
+                existingPendinTransactions = stringToJSON(await deploymentStore.readFile(deploymentsFolder, environmentName, '.pending_transactions.json'));
+            }
+            catch {
+                existingPendinTransactions = [];
+            }
+            existingPendinTransactions.push(pendingTransaction);
+            await deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, '.pending_transactions.json', JSONToString(existingPendinTransactions, 2));
+        }
+        return deployments;
+    }
+    async function waitForTransactionReceipt(params) {
+        const { hash, pollingInterval } = { pollingInterval: resolvedExecutionParams.pollingInterval, ...params };
+        let receipt = null;
+        try {
+            receipt = await provider.request({
+                method: 'eth_getTransactionReceipt',
+                params: [hash],
+            });
+        }
+        catch (err) { }
+        if (!receipt || !receipt.blockHash) {
+            await wait(pollingInterval);
+            return waitForTransactionReceipt(params);
+        }
+        return receipt;
+    }
+    async function deleteTransaction(hash) {
+        if (context.saveDeployments) {
+            let existingPendinTransactions;
+            try {
+                existingPendinTransactions = stringToJSON(await deploymentStore.readFile(deploymentsFolder, environmentName, '.pending_transactions.json'));
+            }
+            catch {
+                existingPendinTransactions = [];
+            }
+            existingPendinTransactions = existingPendinTransactions.filter((v) => v.transaction.hash !== hash);
+            if (existingPendinTransactions.length === 0) {
+                await deploymentStore.deleteFile(deploymentsFolder, environmentName, '.pending_transactions.json');
+            }
+            else {
+                await deploymentStore.writeFileWithChainInfo({ chainId, genesisHash }, deploymentsFolder, environmentName, '.pending_transactions.json', JSONToString(existingPendinTransactions, 2));
+            }
+        }
+    }
+    async function waitForTransaction(hash, info) {
+        const spinner = spin(info?.message
+            ? info.message
+            : `  - Broadcasting tx:\n      ${hash}${info?.transaction ? `\n      ${displayTransaction(info?.transaction)}` : ''}`);
+        let receipt;
+        try {
+            receipt = await waitForTransactionReceipt({
+                hash,
+            });
+        }
+        catch (e) {
+            spinner.fail();
+            throw e;
+        }
+        if (!receipt) {
+            throw new Error(`receipt for ${hash} not found`);
+        }
+        else {
+            spinner.succeed();
+        }
+        return receipt;
+    }
+    async function waitForDeploymentTransactionAndSave(pendingDeployment, transaction) {
+        const nameToDisplay = pendingDeployment.name || '<no name>';
+        const message = `  - Deploying ${nameToDisplay} with tx:\n      ${pendingDeployment.transaction.hash}${transaction ? `\n      ${displayTransaction(transaction)}` : ''}`;
+        const receipt = await waitForTransaction(pendingDeployment.transaction.hash, {
+            message,
+            transaction,
+        });
+        // TODO we could make pendingDeployment.expectedAddress a spec for fetching address from event too
+        const contractAddress = pendingDeployment.expectedAddress || receipt.contractAddress;
+        if (!contractAddress) {
+            console.error(receipt);
+            throw new Error(`no contract address found for ${nameToDisplay}`);
+        }
+        showMessage(`    => ${contractAddress}`);
+        const { abi, ...artifactObjectWithoutABI } = pendingDeployment.partialDeployment;
+        if (!pendingDeployment.transaction.nonce) {
+            // const spinner = spin(`fetching nonce for ${pendingDeployment.transaction.hash}`);
+            let transaction = null;
+            try {
+                transaction = await provider.request({
+                    method: 'eth_getTransactionByHash',
+                    params: [pendingDeployment.transaction.hash],
+                });
+            }
+            catch (e) {
+                // spinner.fail(`failed to get transaction, even after receipt was found`);
+                throw e;
+            }
+            if (!transaction) {
+                // spinner.fail(`tx ${pendingDeployment.transaction.hash} not found,  even after receipt was found`);
+                // or : spinner.stop();
+            }
+            else {
+                // spinner.stop();
+            }
+            if (transaction) {
+                pendingDeployment.transaction = {
+                    nonce: transaction.nonce,
+                    hash: transaction.hash,
+                    origin: transaction.from,
+                };
+            }
+        }
+        // TODO options
+        for (const key of Object.keys(artifactObjectWithoutABI)) {
+            if (key.startsWith('_')) {
+                delete artifactObjectWithoutABI[key];
+            }
+            if (key === 'evm') {
+                if (artifactObjectWithoutABI.evm) {
+                    if ('gasEstimates' in artifactObjectWithoutABI['evm']) {
+                        const { gasEstimates } = artifactObjectWithoutABI.evm;
+                        artifactObjectWithoutABI.evm = {
+                            gasEstimates,
+                        };
+                    }
+                }
+            }
+        }
+        const deployment = {
+            address: contractAddress,
+            abi,
+            ...artifactObjectWithoutABI,
+            transaction: pendingDeployment.transaction,
+            receipt: {
+                blockHash: receipt.blockHash,
+                blockNumber: receipt.blockNumber,
+                transactionIndex: receipt.transactionIndex,
+            },
+        };
+        if (pendingDeployment.name) {
+            return save(pendingDeployment.name, deployment);
+        }
+        else {
+            return deployment;
+        }
+    }
+    async function savePendingExecution(pendingExecution) {
+        await savePendingTransaction(pendingExecution);
+        let transaction = null;
+        const spinner = spin(); // TODO spin(`fetching tx from peers ${pendingDeployment.txHash}`);
+        try {
+            transaction = await provider.request({
+                method: 'eth_getTransactionByHash',
+                params: [pendingExecution.transaction.hash],
+            });
+        }
+        catch (e) {
+            spinner.fail();
+            throw e;
+        }
+        if (!transaction) {
+            // spinner.fail(`execution tx ${pendingExecution.transaction.hash} not found in the mempool yet`);
+            spinner.stop();
+        }
+        else {
+            spinner.stop();
+        }
+        if (transaction) {
+            pendingExecution.transaction.nonce = transaction.nonce;
+            pendingExecution.transaction.origin = transaction.from;
+        }
+        const receipt = await waitForTransaction(pendingExecution.transaction.hash, { transaction });
+        await deleteTransaction(pendingExecution.transaction.hash);
+        return receipt;
+    }
+    async function savePendingDeployment(pendingDeployment) {
+        await savePendingTransaction(pendingDeployment);
+        let transaction = null;
+        const spinner = spin(); // TODO spin(`fetching tx from peers ${pendingDeployment.txHash}`);
+        try {
+            transaction = await provider.request({
+                method: 'eth_getTransactionByHash',
+                params: [pendingDeployment.transaction.hash],
+            });
+        }
+        catch (e) {
+            spinner.fail(`failed to fetch tx ${pendingDeployment.transaction.hash}. Can't know its status`);
+            throw e;
+        }
+        if (!transaction) {
+            // spinner.fail(`deployment tx ${pendingDeployment.transaction.hash} not found in the mempool yet`);
+            spinner.stop();
+        }
+        else {
+            spinner.stop();
+        }
+        if (transaction) {
+            // we update the tx data with the one we get from the network
+            pendingDeployment = {
+                ...pendingDeployment,
+                transaction: { hash: transaction.hash, nonce: transaction.nonce, origin: transaction.from },
+            };
+        }
+        const deployment = await waitForDeploymentTransactionAndSave(pendingDeployment, transaction);
+        await deleteTransaction(pendingDeployment.transaction.hash);
+        return deployment;
+    }
+    function showMessage(message) {
+        log(message);
+    }
+    function showProgress(message) {
+        return spin(message);
+    }
+    let env = {
+        ...perliminaryEnvironment,
+        save,
+        savePendingDeployment,
+        savePendingExecution,
+        get,
+        getOrNull,
+        fromAddressToNamedABI,
+        fromAddressToNamedABIOrNull,
+        showMessage,
+        showProgress,
+        hasMigrationBeenDone,
+    };
+    return {
+        external: env,
+        internal: {
+            recoverTransactionsIfAny,
+            recordMigration,
+        },
+    };
+}
+//# sourceMappingURL=index.js.map