@layerzerolabs/hardhat-tron 2.1.12

package/dist/helper.js

@@ -0,0 +1,2484 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForTx = exports.addHelpers = void 0;
+const abi_1 = require("@ethersproject/abi");
+const address_1 = require("@ethersproject/address");
+const bignumber_1 = require("@ethersproject/bignumber");
+const bytes_1 = require("@ethersproject/bytes");
+const constants_1 = require("@ethersproject/constants");
+const contracts_1 = require("@ethersproject/contracts");
+const providers_1 = require("@ethersproject/providers");
+const solidity_1 = require("@ethersproject/solidity");
+const transactions_1 = require("@ethersproject/transactions");
+const wallet_1 = require("@ethersproject/wallet");
+const enquirer_1 = __importDefault(require("enquirer"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const errors_1 = require("hardhat-deploy/dist/src/errors");
+const hdpath_1 = require("hardhat-deploy/dist/src/hdpath");
+const utils_1 = require("hardhat-deploy/dist/src/internal/utils");
+const old_diamondbase_json_1 = __importDefault(require("hardhat-deploy/dist/src/old_diamondbase.json"));
+const utils_2 = require("hardhat-deploy/dist/src/utils");
+const types_1 = require("hardhat-deploy/dist/types");
+const zk = __importStar(require("zksync-web3"));
+const DeploymentFactory_1 = require("./DeploymentFactory");
+const provider_1 = require("./tron/provider");
+let LedgerSigner;
+let ethersprojectHardwareWalletsModule;
+let andrestEthersLedgerModule;
+let TrezorSigner;
+let hardwareSigner;
+let OpenZeppelinTransparentProxy;
+let OptimizedTransparentUpgradeableProxy;
+let DefaultProxyAdmin;
+let eip173Proxy;
+let eip173ProxyWithReceive;
+let erc1967Proxy;
+let diamondBase;
+let diamondERC165Init;
+let diamondCutFacet;
+let diamondLoupeFacet;
+let ownershipFacet;
+async function initArtifacts(isTron) {
+    const importAssertion = { assert: { type: 'json' } };
+    if (isTron) {
+        console.log('loading tron artifacts');
+        OpenZeppelinTransparentProxy = (await import('./extendedArtifactsTron/TransparentUpgradeableProxy.json', importAssertion)).default;
+        OptimizedTransparentUpgradeableProxy = (await import('./extendedArtifactsTron/OptimizedTransparentUpgradeableProxy.json', importAssertion)).default;
+        DefaultProxyAdmin = (await import('./extendedArtifactsTron/ProxyAdmin.json', importAssertion)).default;
+        eip173Proxy = (await import('./extendedArtifactsTron/EIP173Proxy.json', importAssertion)).default;
+        eip173ProxyWithReceive = (await import('./extendedArtifactsTron/EIP173ProxyWithReceive.json', importAssertion))
+            .default;
+        erc1967Proxy = (await import('./extendedArtifactsTron/ERC1967Proxy.json', importAssertion)).default;
+        diamondBase = (await import('./extendedArtifactsTron/Diamond.json', importAssertion)).default;
+        diamondERC165Init = (await import('./extendedArtifactsTron/DiamondERC165Init.json', importAssertion)).default;
+        diamondCutFacet = (await import('./extendedArtifactsTron/DiamondCutFacet.json', importAssertion)).default;
+        diamondLoupeFacet = (await import('./extendedArtifactsTron/DiamondLoupeFacet.json', importAssertion)).default;
+        ownershipFacet = (await import('./extendedArtifactsTron/OwnershipFacet.json', importAssertion)).default;
+    }
+    else {
+        OpenZeppelinTransparentProxy = (await import('hardhat-deploy/extendedArtifacts/TransparentUpgradeableProxy.json', importAssertion)).default;
+        OptimizedTransparentUpgradeableProxy = (await import('hardhat-deploy/extendedArtifacts/OptimizedTransparentUpgradeableProxy.json', importAssertion)).default;
+        DefaultProxyAdmin = (await import('hardhat-deploy/extendedArtifacts/ProxyAdmin.json', importAssertion)).default;
+        eip173Proxy = (await import('hardhat-deploy/extendedArtifacts/EIP173Proxy.json', importAssertion)).default;
+        eip173ProxyWithReceive = (await import('hardhat-deploy/extendedArtifacts/EIP173ProxyWithReceive.json', importAssertion)).default;
+        erc1967Proxy = (await import('hardhat-deploy/extendedArtifacts/ERC1967Proxy.json', importAssertion)).default;
+        diamondBase = (await import('hardhat-deploy/extendedArtifacts/Diamond.json', importAssertion)).default;
+        diamondERC165Init = (await import('hardhat-deploy/extendedArtifacts/DiamondERC165Init.json', importAssertion))
+            .default;
+        diamondCutFacet = (await import('hardhat-deploy/extendedArtifacts/DiamondCutFacet.json', importAssertion))
+            .default;
+        diamondLoupeFacet = (await import('hardhat-deploy/extendedArtifacts/DiamondLoupeFacet.json', importAssertion))
+            .default;
+        ownershipFacet = (await import('hardhat-deploy/extendedArtifacts/OwnershipFacet.json', importAssertion)).default;
+    }
+}
+async function handleSpecificErrors(p) {
+    let result;
+    try {
+        result = await p;
+    }
+    catch (e) {
+        if (typeof e.message === 'string' && e.message.indexOf('already known') !== -1) {
+            console.log(`
+Exact same transaction already in the pool, node reject duplicates.
+You'll need to wait the tx resolve, or increase the gas price via --gasprice (this will use old tx type)
+        `);
+            throw new Error('Exact same transaction already in the pool, node reject duplicates');
+        }
+        else {
+            console.error(e.message, JSON.stringify(e, utils_1.bnReplacer), e);
+            throw e;
+        }
+    }
+    return result;
+}
+function fixProvider(providerGiven) {
+    if (providerGiven.sendAsync === undefined) {
+        providerGiven.sendAsync = (req, callback) => {
+            providerGiven
+                .send(req.method, req.params)
+                .then((result) => callback(null, { result, id: req.id, jsonrpc: req.jsonrpc }))
+                .catch((error) => callback(error, null));
+        };
+    }
+    return providerGiven;
+}
+function findAll(toFind, array) {
+    for (const f of toFind) {
+        if (array.indexOf(f) === -1) {
+            return false;
+        }
+    }
+    return true;
+}
+function linkRawLibrary(bytecode, libraryName, libraryAddress) {
+    const address = libraryAddress.replace('0x', '');
+    let encodedLibraryName;
+    if (libraryName.startsWith('$') && libraryName.endsWith('$')) {
+        encodedLibraryName = libraryName.slice(1, libraryName.length - 1);
+    }
+    else {
+        encodedLibraryName = (0, solidity_1.keccak256)(['string'], [libraryName]).slice(2, 36);
+    }
+    const pattern = new RegExp(`_+\\$${encodedLibraryName}\\$_+`, 'g');
+    if (!pattern.exec(bytecode)) {
+        throw new Error(`Can't link '${libraryName}' (${encodedLibraryName}) in \n----\n ${bytecode}\n----\n`);
+    }
+    return bytecode.replace(pattern, address);
+}
+function linkRawLibraries(bytecode, libraries) {
+    for (const libName of Object.keys(libraries)) {
+        const libAddress = libraries[libName];
+        bytecode = linkRawLibrary(bytecode, libName, libAddress);
+    }
+    return bytecode;
+}
+function linkLibraries(artifact, libraries) {
+    let bytecode = artifact.bytecode;
+    if (libraries) {
+        if (artifact.linkReferences) {
+            for (const [fileName, fileReferences] of Object.entries(artifact.linkReferences)) {
+                for (const [libName, fixups] of Object.entries(fileReferences)) {
+                    const addr = libraries[libName];
+                    if (addr === undefined) {
+                        continue;
+                    }
+                    for (const fixup of fixups) {
+                        bytecode =
+                            bytecode.substr(0, 2 + fixup.start * 2) +
+                                addr.substr(2) +
+                                bytecode.substr(2 + (fixup.start + fixup.length) * 2);
+                    }
+                }
+            }
+        }
+        else {
+            bytecode = linkRawLibraries(bytecode, libraries);
+        }
+    }
+    return bytecode;
+}
+function addHelpers(deploymentManager, partialExtension, network, getArtifact, saveDeployment, willSaveToDisk, onPendingTx, getGasPrice, log, print) {
+    let provider;
+    const availableAccounts = {};
+    async function init() {
+        await initArtifacts(deploymentManager.isTronNetworkWithTronSolc);
+        if (!provider) {
+            await deploymentManager.setupAccounts();
+            if (network.zksync) {
+                provider = new zk.Web3Provider(fixProvider(network.provider));
+            }
+            else if (network.tron) {
+                provider = new provider_1.TronWeb3Provider(fixProvider(network.provider), network.config);
+            }
+            else {
+                provider = new providers_1.Web3Provider(fixProvider(network.provider));
+            }
+            try {
+                const accounts = await provider.send('eth_accounts', []);
+                for (const account of accounts) {
+                    availableAccounts[account.toLowerCase()] = true;
+                }
+                for (const address of deploymentManager.impersonatedAccounts) {
+                    availableAccounts[address.toLowerCase()] = true;
+                }
+            }
+            catch (e) { }
+        }
+        return provider;
+    }
+    function cleanupOverrides(txRequestOrOverrides) {
+        if (txRequestOrOverrides.maxFeePerGas === undefined) {
+            delete txRequestOrOverrides.maxFeePerGas;
+        }
+        if (txRequestOrOverrides.maxPriorityFeePerGas === undefined) {
+            delete txRequestOrOverrides.maxPriorityFeePerGas;
+        }
+        if (txRequestOrOverrides.gasPrice === undefined) {
+            delete txRequestOrOverrides.gasPrice;
+        }
+        if (txRequestOrOverrides.value === undefined) {
+            delete txRequestOrOverrides.value;
+        }
+        return txRequestOrOverrides;
+    }
+    async function setupGasPrice(txRequestOrOverrides) {
+        const gasPriceSetup = await getGasPrice();
+        if (!txRequestOrOverrides.gasPrice) {
+            txRequestOrOverrides.gasPrice = gasPriceSetup.gasPrice;
+        }
+        if (!txRequestOrOverrides.maxFeePerGas) {
+            txRequestOrOverrides.maxFeePerGas = gasPriceSetup.maxFeePerGas;
+        }
+        if (!txRequestOrOverrides.maxPriorityFeePerGas) {
+            txRequestOrOverrides.maxPriorityFeePerGas = gasPriceSetup.maxPriorityFeePerGas;
+        }
+        cleanupOverrides(txRequestOrOverrides);
+    }
+    async function setupNonce(from, txRequestOrOverrides) {
+        if (txRequestOrOverrides.nonce === 'pending' || txRequestOrOverrides.nonce === 'latest') {
+            txRequestOrOverrides.nonce = await provider.getTransactionCount(from, txRequestOrOverrides.nonce);
+        }
+        else if (!txRequestOrOverrides.nonce) {
+            txRequestOrOverrides.nonce = await provider.getTransactionCount(from, 'latest');
+        }
+    }
+    async function overrideGasLimit(txRequestOrOverrides, options, estimate) {
+        const estimatedGasLimit = options.estimatedGasLimit
+            ? bignumber_1.BigNumber.from(options.estimatedGasLimit).toNumber()
+            : undefined;
+        const estimateGasExtra = options.estimateGasExtra
+            ? bignumber_1.BigNumber.from(options.estimateGasExtra).toNumber()
+            : undefined;
+        if (!txRequestOrOverrides.gasLimit) {
+            txRequestOrOverrides.gasLimit = estimatedGasLimit;
+            txRequestOrOverrides.gasLimit = (await estimate(txRequestOrOverrides)).toNumber();
+            if (estimateGasExtra) {
+                txRequestOrOverrides.gasLimit = txRequestOrOverrides.gasLimit + estimateGasExtra;
+                if (estimatedGasLimit) {
+                    txRequestOrOverrides.gasLimit = Math.min(txRequestOrOverrides.gasLimit, estimatedGasLimit);
+                }
+            }
+        }
+    }
+    async function ensureCreate2DeployerReady(options) {
+        const { address: from, ethersSigner, hardwareWallet, unknown } = await getFrom(options.from);
+        const create2DeployerAddress = await deploymentManager.getDeterministicDeploymentFactoryAddress();
+        const code = await provider.getCode(create2DeployerAddress);
+        if (code === '0x') {
+            const senderAddress = await deploymentManager.getDeterministicDeploymentFactoryDeployer();
+            const txRequest = {
+                to: senderAddress,
+                value: (await deploymentManager.getDeterministicDeploymentFactoryFunding()).toHexString(),
+                gasPrice: options.gasPrice,
+                maxFeePerGas: options.maxFeePerGas,
+                maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+            };
+            await setupGasPrice(txRequest);
+            await setupNonce(from, txRequest);
+            if (unknown) {
+                throw new errors_1.UnknownSignerError({
+                    from,
+                    ...txRequest,
+                });
+            }
+            if (options.log || hardwareWallet) {
+                print(`sending eth to create2 contract deployer address (${senderAddress})`);
+                if (hardwareWallet) {
+                    print(` (please confirm on your ${hardwareWallet})`);
+                }
+            }
+            let ethTx = (await handleSpecificErrors(ethersSigner.sendTransaction(txRequest)));
+            if (options.log || hardwareWallet) {
+                log(` (tx: ${ethTx.hash})...`);
+            }
+            ethTx = await onPendingTx(ethTx);
+            await ethTx.wait();
+            if (options.log || hardwareWallet) {
+                print(`deploying create2 deployer contract (at ${create2DeployerAddress}) using deterministic deployment (https://github.com/Arachnid/deterministic-deployment-proxy)`);
+                if (hardwareWallet) {
+                    print(` (please confirm on your ${hardwareWallet})`);
+                }
+            }
+            const deployTx = await provider.sendTransaction(await deploymentManager.getDeterministicDeploymentFactoryDeploymentTx());
+            if (options.log || hardwareWallet) {
+                log(` (tx: ${deployTx.hash})...`);
+            }
+            await deployTx.wait();
+        }
+        return create2DeployerAddress;
+    }
+    async function getArtifactFromOptions(name, options) {
+        let artifact;
+        let artifactName;
+        if (options.contract) {
+            if (typeof options.contract === 'string') {
+                artifactName = options.contract;
+                artifact = await getArtifact(artifactName);
+            }
+            else {
+                artifact = options.contract;
+            }
+        }
+        else {
+            artifactName = name;
+            artifact = await getArtifact(artifactName);
+        }
+        return { artifact, artifactName };
+    }
+    async function getLinkedArtifact(name, options) {
+        const { artifact, artifactName } = await getArtifactFromOptions(name, options);
+        const byteCode = linkLibraries(artifact, options.libraries);
+        return { artifact: { ...artifact, bytecode: byteCode }, artifactName };
+    }
+    async function _deploy(name, options) {
+        const args = options.args ? [...options.args] : [];
+        await init();
+        const { address: from, ethersSigner, hardwareWallet, unknown } = await getFrom(options.from);
+        const { artifact: linkedArtifact, artifactName } = await getLinkedArtifact(name, options);
+        const overrides = {
+            gasLimit: options.gasLimit,
+            gasPrice: options.gasPrice,
+            maxFeePerGas: options.maxFeePerGas,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+            value: options.value,
+            nonce: options.nonce,
+        };
+        const factory = new DeploymentFactory_1.CustomDeploymentFactory(getArtifact, linkedArtifact, args, network, ethersSigner, overrides);
+        const unsignedTx = await factory.getDeployTransaction();
+        let create2Address;
+        if (options.deterministicDeployment) {
+            if (network.tron) {
+                throw new Error('deterministic deployment not supported on Tron');
+            }
+            if (typeof unsignedTx.data === 'string') {
+                const create2DeployerAddress = await ensureCreate2DeployerReady(options);
+                const create2Salt = typeof options.deterministicDeployment === 'string'
+                    ? (0, bytes_1.hexlify)((0, bytes_1.zeroPad)(options.deterministicDeployment, 32))
+                    : '0x0000000000000000000000000000000000000000000000000000000000000000';
+                create2Address = await factory.getCreate2Address(create2DeployerAddress, create2Salt);
+                unsignedTx.to = create2DeployerAddress;
+                unsignedTx.data = create2Salt + unsignedTx.data.slice(2);
+            }
+            else {
+                throw new Error('unsigned tx data as bytes not supported');
+            }
+        }
+        if (network.tron) {
+            const feeLimit = await ethersSigner.getFeeLimit(unsignedTx, overrides);
+            unsignedTx.feeLimit = feeLimit;
+        }
+        else {
+            await overrideGasLimit(unsignedTx, options, (newOverrides) => ethersSigner.estimateGas(newOverrides));
+            await setupGasPrice(unsignedTx);
+            await setupNonce(from, unsignedTx);
+            if (hardwareWallet === 'ledger') {
+                unsignedTx.type = 1;
+            }
+            else if (hardwareWallet === 'trezor') {
+                unsignedTx.type = 1;
+            }
+        }
+        if (unknown) {
+            throw new errors_1.UnknownSignerError({
+                from,
+                ...JSON.parse(JSON.stringify(unsignedTx, utils_1.bnReplacer)),
+            });
+        }
+        if (options.log || hardwareWallet) {
+            print(`deploying "${name}"`);
+            if (hardwareWallet) {
+                print(` (please confirm on your ${hardwareWallet})`);
+            }
+        }
+        let tx = (await handleSpecificErrors(ethersSigner.sendTransaction(unsignedTx)));
+        if (options.log || hardwareWallet) {
+            print(` (tx: ${tx.hash})...`);
+        }
+        if (options.autoMine) {
+            try {
+                await provider.send('evm_mine', []);
+            }
+            catch (e) { }
+        }
+        let preDeployment = {
+            ...linkedArtifact,
+            transactionHash: tx.hash,
+            args,
+            linkedData: options.linkedData,
+        };
+        if (artifactName && willSaveToDisk()) {
+            const extendedArtifact = await partialExtension.getExtendedArtifact(artifactName);
+            preDeployment = {
+                ...extendedArtifact,
+                ...preDeployment,
+            };
+        }
+        tx = await onPendingTx(tx, name, preDeployment);
+        const receipt = await tx.wait(options.waitConfirmations);
+        const address = options.deterministicDeployment && create2Address ? create2Address : receipt.contractAddress;
+        const deployment = {
+            ...preDeployment,
+            address,
+            receipt,
+            transactionHash: receipt.transactionHash,
+            libraries: options.libraries,
+        };
+        await saveDeployment(name, deployment);
+        if (options.log || hardwareWallet) {
+            print(`: deployed at ${deployment.address} with ${receipt?.gasUsed} gas\n`);
+        }
+        return {
+            ...deployment,
+            address,
+            newlyDeployed: true,
+        };
+    }
+    async function deterministic(name, options) {
+        options = { ...options };
+        await init();
+        const deployFunction = () => deploy(name, {
+            ...options,
+            deterministicDeployment: options.salt || true,
+        });
+        if (options.proxy) {
+            let { viaAdminContract, proxyAdminDeployed, proxyAdminName, proxyAdminContract, owner, proxyAdmin, currentProxyAdminOwner, artifact, implementationArgs, implementationName, implementationOptions, proxyName, proxyContract, proxyArgsTemplate, mergedABI, updateMethod, updateArgs, } = await _getProxyInfo(name, options);
+            const { address: implementationAddress } = await deterministic(implementationName, {
+                ...implementationOptions,
+                salt: options.salt,
+            });
+            const implementationContract = new contracts_1.Contract(implementationAddress, artifact.abi);
+            let data = '0x';
+            if (updateMethod) {
+                updateArgs = updateArgs || [];
+                if (!implementationContract[updateMethod]) {
+                    throw new Error(`contract need to implement function ${updateMethod}`);
+                }
+                const txData = await implementationContract.populateTransaction[updateMethod](...updateArgs);
+                data = txData.data || '0x';
+            }
+            if (viaAdminContract) {
+                if (!proxyAdminName) {
+                    throw new Error(`no proxy admin name even though viaAdminContract is not undefined`);
+                }
+                if (!proxyAdminDeployed) {
+                    const { address: proxyAdminAddress } = await deterministic(proxyAdminName, {
+                        from: options.from,
+                        autoMine: options.autoMine,
+                        estimateGasExtra: options.estimateGasExtra,
+                        estimatedGasLimit: options.estimatedGasLimit,
+                        gasPrice: options.gasPrice,
+                        maxFeePerGas: options.maxFeePerGas,
+                        maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                        log: options.log,
+                        contract: proxyAdminContract,
+                        salt: options.salt,
+                        skipIfAlreadyDeployed: true,
+                        args: [owner],
+                        waitConfirmations: options.waitConfirmations,
+                    });
+                    proxyAdmin = proxyAdminAddress;
+                }
+                else {
+                    proxyAdmin = proxyAdminDeployed.address;
+                }
+            }
+            const proxyOptions = { ...options };
+            delete proxyOptions.proxy;
+            delete proxyOptions.libraries;
+            proxyOptions.contract = proxyContract;
+            proxyOptions.args = replaceTemplateArgs(proxyArgsTemplate, {
+                implementationAddress,
+                proxyAdmin,
+                data,
+            });
+            const { address: proxyAddress } = await deterministic(proxyName, {
+                ...proxyOptions,
+                salt: options.salt,
+            });
+            return {
+                address: proxyAddress,
+                implementationAddress,
+                deploy: deployFunction,
+            };
+        }
+        else {
+            const args = options.args ? [...options.args] : [];
+            const { ethersSigner, unknown, address: from } = await getFrom(options.from);
+            const { artifact: linkedArtifact, artifactName } = await getLinkedArtifact(name, options);
+            const factory = new DeploymentFactory_1.CustomDeploymentFactory(getArtifact, linkedArtifact, args, network, ethersSigner);
+            if (unknown) {
+                throw new errors_1.UnknownSignerError({
+                    from,
+                    ...JSON.parse(JSON.stringify(await factory.getDeployTransaction(), utils_1.bnReplacer)),
+                });
+            }
+            return {
+                address: await factory.getCreate2Address(await deploymentManager.getDeterministicDeploymentFactoryAddress(), options.salt
+                    ? (0, bytes_1.hexlify)((0, bytes_1.zeroPad)(options.salt, 32))
+                    : '0x0000000000000000000000000000000000000000000000000000000000000000'),
+                deploy: () => deploy(name, {
+                    ...options,
+                    deterministicDeployment: options.salt || true,
+                }),
+            };
+        }
+    }
+    function getDeployment(name) {
+        return partialExtension.get(name);
+    }
+    function getDeploymentOrNUll(name) {
+        return partialExtension.getOrNull(name);
+    }
+    async function fetchIfDifferent(name, options) {
+        options = { ...options };
+        const args = options.args ? [...options.args] : [];
+        await init();
+        const { ethersSigner } = await getFrom(options.from);
+        const { artifact: linkedArtifact } = await getLinkedArtifact(name, options);
+        const factory = new DeploymentFactory_1.CustomDeploymentFactory(getArtifact, linkedArtifact, args, network, ethersSigner);
+        if (options.deterministicDeployment) {
+            const create2Salt = typeof options.deterministicDeployment === 'string'
+                ? (0, bytes_1.hexlify)((0, bytes_1.zeroPad)(options.deterministicDeployment, 32))
+                : '0x0000000000000000000000000000000000000000000000000000000000000000';
+            const create2DeployerAddress = await deploymentManager.getDeterministicDeploymentFactoryAddress();
+            const create2Address = await factory.getCreate2Address(create2DeployerAddress, create2Salt);
+            const code = await provider.getCode(create2Address);
+            if (code === '0x') {
+                return { differences: true, address: undefined };
+            }
+            else {
+                return { differences: false, address: create2Address };
+            }
+        }
+        const deployment = await partialExtension.getOrNull(name);
+        if (deployment) {
+            if (options.skipIfAlreadyDeployed) {
+                return { differences: false, address: undefined };
+            }
+            let transactionDetailsAvailable = false;
+            let transaction;
+            if (deployment.receipt) {
+                transactionDetailsAvailable = !!deployment.receipt.transactionHash;
+                if (transactionDetailsAvailable) {
+                    transaction = await provider.getTransaction(deployment.receipt.transactionHash);
+                }
+            }
+            else if (deployment.transactionHash) {
+                transactionDetailsAvailable = true;
+                transaction = await provider.getTransaction(deployment.transactionHash);
+            }
+            if (transaction) {
+                const differences = await factory.compareDeploymentTransaction(transaction);
+                return { differences, address: deployment.address };
+            }
+            else {
+                if (transactionDetailsAvailable) {
+                    throw new Error(`cannot get the transaction for ${name}'s previous deployment, please check your node synced status.`);
+                }
+                else {
+                    console.error(`no transaction details found for ${name}'s previous deployment, if the deployment is t be discarded, please delete the file`);
+                    return { differences: false, address: deployment.address };
+                }
+            }
+        }
+        return { differences: true, address: undefined };
+    }
+    async function _deployOne(name, options, failsOnExistingDeterminisitc) {
+        const argsArray = options.args ? [...options.args] : [];
+        options = { ...options, args: argsArray };
+        let result;
+        const diffResult = await fetchIfDifferent(name, options);
+        if (diffResult.differences) {
+            result = await _deploy(name, options);
+        }
+        else {
+            if (failsOnExistingDeterminisitc && options.deterministicDeployment) {
+                throw new Error(`already deployed on same deterministic address: ${diffResult.address}`);
+            }
+            const deployment = await getDeploymentOrNUll(name);
+            if (deployment) {
+                if (options.deterministicDeployment &&
+                    diffResult.address &&
+                    diffResult.address.toLowerCase() !== deployment.address.toLowerCase()) {
+                    const { artifact: linkedArtifact, artifactName } = await getLinkedArtifact(name, options);
+                    const newDeployment = {
+                        ...linkedArtifact,
+                        address: diffResult.address,
+                        linkedData: options.linkedData,
+                        libraries: options.libraries,
+                        args: argsArray,
+                    };
+                    await saveDeployment(name, newDeployment, artifactName);
+                    result = {
+                        ...newDeployment,
+                        newlyDeployed: false,
+                    };
+                }
+                else {
+                    result = deployment;
+                    result.newlyDeployed = false;
+                }
+            }
+            else {
+                if (!diffResult.address) {
+                    throw new Error('no differences found but no address, this should be impossible');
+                }
+                const { artifact: linkedArtifact, artifactName } = await getLinkedArtifact(name, options);
+                const newDeployment = {
+                    ...linkedArtifact,
+                    address: diffResult.address,
+                    linkedData: options.linkedData,
+                    libraries: options.libraries,
+                    args: argsArray,
+                };
+                await saveDeployment(name, newDeployment, artifactName);
+                result = {
+                    ...newDeployment,
+                    newlyDeployed: false,
+                };
+            }
+            if (options.log) {
+                log(`reusing "${name}" at ${result.address}`);
+            }
+        }
+        return result;
+    }
+    function _checkUpgradeIndex(oldDeployment, upgradeIndex) {
+        if (typeof upgradeIndex === 'undefined') {
+            return;
+        }
+        if (upgradeIndex === 0) {
+            if (oldDeployment) {
+                return { ...oldDeployment, newlyDeployed: false };
+            }
+        }
+        else if (upgradeIndex === 1) {
+            if (!oldDeployment) {
+                throw new Error('upgradeIndex === 1 : expects Deployments to already exists');
+            }
+            if ((oldDeployment.history && oldDeployment.history.length > 0) ||
+                (oldDeployment.numDeployments && oldDeployment.numDeployments > 1)) {
+                return { ...oldDeployment, newlyDeployed: false };
+            }
+        }
+        else {
+            if (!oldDeployment) {
+                throw new Error(`upgradeIndex === ${upgradeIndex} : expects Deployments to already exists`);
+            }
+            if (!oldDeployment.history) {
+                if (oldDeployment.numDeployments && oldDeployment.numDeployments > 1) {
+                    if (oldDeployment.numDeployments > upgradeIndex) {
+                        return { ...oldDeployment, newlyDeployed: false };
+                    }
+                    else if (oldDeployment.numDeployments < upgradeIndex) {
+                        throw new Error(`upgradeIndex === ${upgradeIndex} : expects Deployments numDeployments to be at least ${upgradeIndex}`);
+                    }
+                }
+                else {
+                    throw new Error(`upgradeIndex > 1 : expects Deployments history to exists, or numDeployments to be greater than 1`);
+                }
+            }
+            else if (oldDeployment.history.length > upgradeIndex - 1) {
+                return { ...oldDeployment, newlyDeployed: false };
+            }
+            else if (oldDeployment.history.length < upgradeIndex - 1) {
+                throw new Error(`upgradeIndex === ${upgradeIndex} : expects Deployments history length to be at least ${upgradeIndex - 1}`);
+            }
+        }
+    }
+    async function _getProxyInfo(name, options) {
+        const oldDeployment = await getDeploymentOrNUll(name);
+        let contractName = options.contract;
+        let implementationName = name + '_Implementation';
+        let updateMethod;
+        let updateArgs;
+        let upgradeIndex;
+        let proxyContract = eip173Proxy;
+        let checkABIConflict = true;
+        let checkProxyAdmin = true;
+        let viaAdminContract;
+        let proxyArgsTemplate = ['{implementation}', '{admin}', '{data}'];
+        let upgradeMethod;
+        let upgradeArgsTemplate = [];
+        if (typeof options.proxy === 'object') {
+            if (options.proxy.proxyArgs) {
+                proxyArgsTemplate = options.proxy.proxyArgs;
+            }
+            upgradeIndex = options.proxy.upgradeIndex;
+            if (options.proxy.implementationName) {
+                implementationName = options.proxy.implementationName;
+                if (implementationName === name) {
+                    throw new Error(`"implementationName" cannot be equal to the deployment's name (${name}) as this is used for the proxy itself.`);
+                }
+                if (!contractName) {
+                    contractName = implementationName;
+                }
+            }
+            if ('methodName' in options.proxy) {
+                updateMethod = options.proxy.methodName;
+                if ('execute' in options.proxy) {
+                    throw new Error(`cannot have both "methodName" and "execute" options for proxy`);
+                }
+            }
+            else if ('execute' in options.proxy && options.proxy.execute) {
+                if ('methodName' in options.proxy.execute) {
+                    updateMethod = options.proxy.execute.methodName;
+                    updateArgs = options.proxy.execute.args;
+                    if ('init' in options.proxy.execute || 'onUpgrade' in options.proxy.execute) {
+                        throw new Error(`cannot have both "methodName" and ("onUpgrade" or "init") options for proxy.execute`);
+                    }
+                }
+                else if (('init' in options.proxy.execute && options.proxy.execute.init) ||
+                    ('onUpgrade' in options.proxy.execute && options.proxy.execute.onUpgrade)) {
+                    if (oldDeployment) {
+                        updateMethod = options.proxy.execute.onUpgrade?.methodName;
+                        updateArgs = options.proxy.execute.onUpgrade?.args;
+                    }
+                    else {
+                        updateMethod = options.proxy.execute.init.methodName;
+                        updateArgs = options.proxy.execute.init.args;
+                    }
+                }
+            }
+            checkABIConflict = options.proxy.checkABIConflict ?? checkABIConflict;
+            checkProxyAdmin = options.proxy.checkProxyAdmin ?? checkProxyAdmin;
+            if (options.proxy.proxyContract) {
+                if (typeof options.proxy.proxyContract === 'string') {
+                    try {
+                        proxyContract = await partialExtension.getExtendedArtifact(options.proxy.proxyContract);
+                    }
+                    catch (e) { }
+                    if (!proxyContract || proxyContract === eip173Proxy) {
+                        if (options.proxy.proxyContract === 'EIP173ProxyWithReceive') {
+                            proxyContract = eip173ProxyWithReceive;
+                        }
+                        else if (options.proxy.proxyContract === 'EIP173Proxy') {
+                            proxyContract = eip173Proxy;
+                        }
+                        else if (options.proxy.proxyContract === 'OpenZeppelinTransparentProxy') {
+                            checkABIConflict = false;
+                            proxyContract = OpenZeppelinTransparentProxy;
+                            viaAdminContract = 'DefaultProxyAdmin';
+                        }
+                        else if (options.proxy.proxyContract === 'OptimizedTransparentProxy') {
+                            checkABIConflict = false;
+                            proxyContract = OptimizedTransparentUpgradeableProxy;
+                            viaAdminContract = 'DefaultProxyAdmin';
+                        }
+                        else if (options.proxy.proxyContract === 'UUPS') {
+                            checkABIConflict = false;
+                            checkProxyAdmin = false;
+                            proxyContract = erc1967Proxy;
+                            proxyArgsTemplate = ['{implementation}', '{data}'];
+                        }
+                        else {
+                            throw new Error(`no contract found for ${options.proxy.proxyContract}`);
+                        }
+                    }
+                }
+            }
+            if (options.proxy.viaAdminContract) {
+                viaAdminContract = options.proxy.viaAdminContract;
+            }
+            if (options.proxy.upgradeFunction) {
+                upgradeMethod = options.proxy.upgradeFunction.methodName;
+                upgradeArgsTemplate = options.proxy.upgradeFunction.upgradeArgs;
+            }
+        }
+        else if (typeof options.proxy === 'string') {
+            updateMethod = options.proxy;
+        }
+        const proxyName = name + '_Proxy';
+        const { address: owner } = await getProxyOwner(options);
+        const implementationArgs = options.args ? [...options.args] : [];
+        const implementationOptions = {
+            contract: contractName || name,
+            from: options.from,
+            autoMine: options.autoMine,
+            estimateGasExtra: options.estimateGasExtra,
+            estimatedGasLimit: options.estimatedGasLimit,
+            gasPrice: options.gasPrice,
+            maxFeePerGas: options.maxFeePerGas,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+            log: options.log,
+            deterministicDeployment: options.deterministicDeployment,
+            libraries: options.libraries,
+            linkedData: options.linkedData,
+            args: implementationArgs,
+            skipIfAlreadyDeployed: options.skipIfAlreadyDeployed,
+            waitConfirmations: options.waitConfirmations,
+        };
+        const { artifact } = await getArtifactFromOptions(name, implementationOptions);
+        const proxyContractConstructor = proxyContract.abi.find((v) => v.type === 'constructor');
+        const mergedABI = (0, utils_2.mergeABIs)([proxyContract.abi, artifact.abi], {
+            check: checkABIConflict,
+            skipSupportsInterface: true,
+        }).filter((v) => v.type !== 'constructor');
+        mergedABI.push(proxyContractConstructor);
+        const constructor = artifact.abi.find((fragment) => fragment.type === 'constructor');
+        if ((!constructor && implementationArgs.length > 0) ||
+            (constructor && constructor.inputs.length !== implementationArgs.length)) {
+            throw new Error(`The number of arguments passed to not match the number of argument in the implementation constructor.
+Please specify the correct number of arguments as part of the deploy options: "args"`);
+        }
+        if (updateMethod) {
+            const updateMethodFound = artifact.abi.find((fragment) => fragment.type === 'function' && fragment.name === updateMethod);
+            if (!updateMethodFound) {
+                throw new Error(`contract need to implement function ${updateMethod}`);
+            }
+            if (!updateArgs) {
+                if (implementationArgs.length === updateMethodFound.inputs.length) {
+                    updateArgs = implementationArgs;
+                }
+                else {
+                    throw new Error(`
+If only the methodName (and no args) is specified for proxy deployment, the arguments used for the implementation contract will be reused for the update method.
+This allow your contract to both be deployed directly and deployed via proxy.
+
+Currently your contract implementation's constructor do not have the same number of arguments as the update method.
+You can either changes the contract or use the "execute" options and specify different arguments for the update method.
+Note that in this case, the contract deployment will not behave the same if deployed without proxy.
+    `);
+                }
+            }
+        }
+        if (!updateArgs) {
+            updateArgs = implementationArgs;
+        }
+        let proxyAdminName;
+        const proxyAdmin = owner;
+        let currentProxyAdminOwner;
+        let proxyAdminDeployed;
+        let proxyAdminContract;
+        if (viaAdminContract) {
+            let proxyAdminArtifactNameOrContract;
+            if (typeof viaAdminContract === 'string') {
+                proxyAdminName = viaAdminContract;
+                proxyAdminArtifactNameOrContract = viaAdminContract;
+            }
+            else {
+                proxyAdminName = viaAdminContract.name;
+                if (!viaAdminContract.artifact) {
+                    proxyAdminDeployed = await partialExtension.get(proxyAdminName);
+                }
+                proxyAdminArtifactNameOrContract = viaAdminContract.artifact;
+            }
+            if (typeof proxyAdminArtifactNameOrContract === 'string') {
+                try {
+                    proxyAdminContract = await partialExtension.getExtendedArtifact(proxyAdminArtifactNameOrContract);
+                }
+                catch (e) { }
+                if (!proxyAdminContract) {
+                    if (viaAdminContract === 'DefaultProxyAdmin') {
+                        proxyAdminContract = DefaultProxyAdmin;
+                    }
+                    else {
+                        throw new Error(`no contract found for ${proxyAdminArtifactNameOrContract}`);
+                    }
+                }
+            }
+            else {
+                proxyAdminContract = proxyAdminArtifactNameOrContract;
+            }
+        }
+        if (!upgradeMethod) {
+            if (viaAdminContract) {
+                if (updateMethod) {
+                    upgradeMethod = 'upgradeAndCall';
+                    upgradeArgsTemplate = ['{proxy}', '{implementation}', '{data}'];
+                }
+                else {
+                    upgradeMethod = 'upgrade';
+                    upgradeArgsTemplate = ['{proxy}', '{implementation}'];
+                }
+            }
+            else if (updateMethod) {
+                upgradeMethod = 'upgradeToAndCall';
+                upgradeArgsTemplate = ['{implementation}', '{data}'];
+            }
+            else {
+                upgradeMethod = 'upgradeTo';
+                upgradeArgsTemplate = ['{implementation}'];
+            }
+        }
+        return {
+            proxyName,
+            proxyContract,
+            proxyArgsTemplate,
+            mergedABI,
+            viaAdminContract,
+            proxyAdminDeployed,
+            proxyAdminName,
+            proxyAdminContract,
+            owner,
+            proxyAdmin,
+            currentProxyAdminOwner,
+            artifact,
+            implementationArgs,
+            implementationName,
+            implementationOptions,
+            oldDeployment,
+            updateMethod,
+            updateArgs,
+            upgradeIndex,
+            checkProxyAdmin,
+            upgradeMethod,
+            upgradeArgsTemplate,
+        };
+    }
+    async function _deployViaProxy(name, options) {
+        let { oldDeployment, updateMethod, updateArgs, upgradeIndex, viaAdminContract, proxyAdminDeployed, proxyAdminName, proxyAdminContract, owner, proxyAdmin, currentProxyAdminOwner, implementationName, implementationOptions, proxyName, proxyContract, proxyArgsTemplate, mergedABI, checkProxyAdmin, upgradeMethod, upgradeArgsTemplate, } = await _getProxyInfo(name, options);
+        const deployResult = _checkUpgradeIndex(oldDeployment, upgradeIndex);
+        if (deployResult) {
+            return deployResult;
+        }
+        if (viaAdminContract) {
+            if (!proxyAdminName) {
+                throw new Error(`no proxy admin name even though viaAdminContract is not undefined`);
+            }
+            if (!proxyAdminDeployed) {
+                proxyAdminDeployed = await _deployOne(proxyAdminName, {
+                    from: options.from,
+                    autoMine: options.autoMine,
+                    estimateGasExtra: options.estimateGasExtra,
+                    estimatedGasLimit: options.estimatedGasLimit,
+                    gasPrice: options.gasPrice,
+                    maxFeePerGas: options.maxFeePerGas,
+                    maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                    log: options.log,
+                    contract: proxyAdminContract,
+                    deterministicDeployment: options.deterministicDeployment,
+                    skipIfAlreadyDeployed: true,
+                    args: [owner],
+                    waitConfirmations: options.waitConfirmations,
+                });
+            }
+            proxyAdmin = proxyAdminDeployed.address;
+            currentProxyAdminOwner = (await read(proxyAdminName, 'owner'));
+            if (currentProxyAdminOwner.toLowerCase() !== owner.toLowerCase()) {
+                throw new Error(`To change owner/admin, you need to call transferOwnership on ${proxyAdminName}`);
+            }
+            if (currentProxyAdminOwner === constants_1.AddressZero) {
+                throw new Error(`The Proxy Admin (${proxyAdminName}) belongs to no-one. The Proxy cannot be upgraded anymore`);
+            }
+        }
+        const implementation = await _deployOne(implementationName, implementationOptions);
+        if (!oldDeployment || implementation.newlyDeployed) {
+            const implementationContract = new contracts_1.Contract(implementation.address, implementation.abi);
+            let data = '0x';
+            if (updateMethod) {
+                if (!implementationContract[updateMethod]) {
+                    throw new Error(`contract need to implement function ${updateMethod}`);
+                }
+                const txData = await implementationContract.populateTransaction[updateMethod](...updateArgs);
+                data = txData.data || '0x';
+            }
+            let proxy = await getDeploymentOrNUll(proxyName);
+            if (!proxy) {
+                const proxyOptions = { ...options };
+                delete proxyOptions.proxy;
+                delete proxyOptions.libraries;
+                proxyOptions.contract = proxyContract;
+                proxyOptions.args = replaceTemplateArgs(proxyArgsTemplate, {
+                    implementationAddress: implementation.address,
+                    proxyAdmin,
+                    data,
+                });
+                proxy = await _deployOne(proxyName, proxyOptions, true);
+            }
+            else {
+                let from = options.from;
+                const ownerStorage = await provider.getStorageAt(proxy.address, '0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103');
+                const currentOwner = (0, address_1.getAddress)(`0x${ownerStorage.substr(-40)}`);
+                if (currentOwner === constants_1.AddressZero) {
+                    if (checkProxyAdmin) {
+                        throw new Error('The Proxy belongs to no-one. It cannot be upgraded anymore');
+                    }
+                }
+                else if (currentOwner.toLowerCase() !== proxyAdmin.toLowerCase()) {
+                    throw new Error(`To change owner/admin, you need to call the proxy directly, it currently is ${currentOwner}`);
+                }
+                else {
+                    from = currentOwner;
+                }
+                const oldProxy = proxy.abi.find((frag) => frag.name === 'changeImplementation');
+                if (oldProxy) {
+                    upgradeMethod = 'changeImplementation';
+                    upgradeArgsTemplate = ['{implementation}', '{data}'];
+                }
+                const proxyAddress = proxy.address;
+                const upgradeArgs = replaceTemplateArgs(upgradeArgsTemplate, {
+                    implementationAddress: implementation.address,
+                    proxyAdmin,
+                    data,
+                    proxyAddress,
+                });
+                if (!upgradeMethod) {
+                    throw new Error(`No upgrade method found, cannot make upgrades`);
+                }
+                let executeReceipt;
+                if (proxyAdminName) {
+                    if (oldProxy) {
+                        throw new Error(`Old Proxy do not support Proxy Admin contracts`);
+                    }
+                    if (!currentProxyAdminOwner) {
+                        throw new Error(`no currentProxyAdminOwner found in ProxyAdmin`);
+                    }
+                    executeReceipt = await execute(proxyAdminName, { ...options, from: currentProxyAdminOwner }, upgradeMethod, ...upgradeArgs);
+                }
+                else {
+                    executeReceipt = await execute(name, { ...options, from }, upgradeMethod, ...upgradeArgs);
+                }
+                if (!executeReceipt) {
+                    throw new Error(`could not execute ${upgradeMethod}`);
+                }
+            }
+            const proxiedDeployment = {
+                ...proxyContract,
+                receipt: proxy.receipt,
+                address: proxy.address,
+                linkedData: options.linkedData,
+                abi: mergedABI,
+                implementation: implementation.address,
+                args: proxy.args,
+                execute: updateMethod
+                    ? {
+                        methodName: updateMethod,
+                        args: updateArgs,
+                    }
+                    : undefined,
+            };
+            if (oldDeployment) {
+                if (oldDeployment.history) {
+                    proxiedDeployment.history = proxiedDeployment.history
+                        ? proxiedDeployment.history.concat([oldDeployment])
+                        : [oldDeployment];
+                }
+            }
+            await saveDeployment(name, proxiedDeployment);
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: true,
+            };
+        }
+        else {
+            if (oldDeployment.implementation !== implementation.address) {
+                const proxiedDeployment = {
+                    ...oldDeployment,
+                    implementation: implementation.address,
+                    linkedData: options.linkedData,
+                    abi: mergedABI,
+                    execute: updateMethod
+                        ? {
+                            methodName: updateMethod,
+                            args: updateArgs,
+                        }
+                        : undefined,
+                };
+                if (oldDeployment.history) {
+                    proxiedDeployment.history = proxiedDeployment.history
+                        ? proxiedDeployment.history.concat([oldDeployment])
+                        : [oldDeployment];
+                }
+                await saveDeployment(name, proxiedDeployment);
+            }
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: false,
+            };
+        }
+    }
+    async function getProxyOwner(options) {
+        let address = options.from;
+        if (typeof options.proxy === 'object') {
+            address = options.proxy.owner || address;
+        }
+        return getFrom(address);
+    }
+    async function getDiamondOwner(options) {
+        let address = options.from;
+        address = options.owner || address;
+        return getFrom(address);
+    }
+    async function getOptionalFrom(from) {
+        if (!from) {
+            return {
+                address: from,
+                ethersSigner: undefined,
+                hardwareWallet: undefined,
+            };
+        }
+        return getFrom(from);
+    }
+    let ledgerSigner;
+    async function getFrom(from) {
+        let ethersSigner;
+        let wallet;
+        let hardwareWallet = undefined;
+        let unknown = false;
+        let derivationPath = undefined;
+        if (from.length >= 64) {
+            if (from.length === 64) {
+                from = '0x' + from;
+            }
+            if (network.zksync) {
+                wallet = new zk.Wallet(from, provider);
+                ethersSigner = wallet;
+            }
+            else if (network.tron) {
+                wallet = provider.addSigner(from);
+                ethersSigner = wallet;
+            }
+            else {
+                wallet = new wallet_1.Wallet(from, provider);
+                ethersSigner = wallet;
+            }
+            from = wallet.address;
+        }
+        else {
+            if (availableAccounts[from.toLowerCase()]) {
+                ethersSigner = provider.getSigner(from);
+            }
+            else {
+                const registeredProtocol = deploymentManager.addressesToProtocol[from.toLowerCase()];
+                if (registeredProtocol) {
+                    if (registeredProtocol === 'external') {
+                        ethersSigner = provider.getSigner(from);
+                        ethersSigner.sendTransaction = async (txRequest) => {
+                            const response = await enquirer_1.default.prompt({
+                                type: 'input',
+                                name: 'hash',
+                                message: `
+                tx hash please
+                to : ${txRequest.to}
+                data : ${txRequest.data}
+                value : ${txRequest.value}
+                `,
+                            });
+                            return provider.getTransaction(response.hash);
+                        };
+                        hardwareWallet = 'external';
+                    }
+                    else if (registeredProtocol.startsWith('ledger')) {
+                        if (!LedgerSigner) {
+                            let error;
+                            try {
+                                ethersprojectHardwareWalletsModule = require('@ethersproject/hardware-wallets');
+                                LedgerSigner = ethersprojectHardwareWalletsModule.LedgerSigner;
+                            }
+                            catch (e) {
+                                error = e;
+                                try {
+                                    andrestEthersLedgerModule = require('@anders-t/ethers-ledger');
+                                    LedgerSigner = andrestEthersLedgerModule.LedgerSigner;
+                                    error = undefined;
+                                }
+                                catch (e) {
+                                    error = e;
+                                }
+                            }
+                            if (error) {
+                                console.error(`failed to loader hardhware wallet module for ledger, you can either use "@ethersproject/hardware-wallets" which as time of writing does not work or use "@anders-t/ethers-ledger."`);
+                                throw error;
+                            }
+                        }
+                        if (ledgerSigner) {
+                            const __eth = await ledgerSigner._eth;
+                            await __eth.transport.device.close();
+                            ledgerSigner = undefined;
+                        }
+                        if (ethersprojectHardwareWalletsModule) {
+                            derivationPath = (0, hdpath_1.getDerivationPath)(network.config.chainId);
+                            ethersSigner = new LedgerSigner(provider, 'default', derivationPath);
+                        }
+                        else {
+                            ethersSigner = new LedgerSigner(provider, registeredProtocol);
+                        }
+                        ledgerSigner = ethersSigner;
+                    }
+                    else if (registeredProtocol.startsWith('trezor')) {
+                        if (!TrezorSigner) {
+                            let error;
+                            try {
+                                const hardwareWalletModule = require('@nxqbao/eth-signer-trezor');
+                                derivationPath = (0, hdpath_1.getDerivationPath)(network.config.chainId);
+                                if (!derivationPath) {
+                                    throw new Error(`network is currently unsupported with trezor`);
+                                }
+                                TrezorSigner = hardwareWalletModule.TrezorSigner;
+                            }
+                            catch (e) {
+                                error = e;
+                            }
+                            if (error) {
+                                console.error(`failed to loader hardware wallet module for trezor`);
+                                throw error;
+                            }
+                        }
+                        if (!hardwareSigner) {
+                            hardwareSigner = new TrezorSigner(provider, derivationPath, undefined, from, 'hardhat-deploy-trezor');
+                        }
+                        ethersSigner = hardwareSigner;
+                        hardwareWallet = 'trezor';
+                    }
+                    else if (registeredProtocol.startsWith('privatekey')) {
+                        ethersSigner = new wallet_1.Wallet(registeredProtocol.substr(13), provider);
+                    }
+                    else if (registeredProtocol.startsWith('gnosis')) {
+                        ethersSigner = new wallet_1.Wallet(registeredProtocol.substr(13), provider);
+                    }
+                }
+            }
+        }
+        if (!ethersSigner) {
+            unknown = true;
+            ethersSigner = provider.getSigner(from);
+        }
+        return { address: from, ethersSigner, hardwareWallet, unknown };
+    }
+    function sigsFromABI(abi) {
+        return abi
+            .filter((fragment) => fragment.type === 'function')
+            .map((fragment) => abi_1.Interface.getSighash(abi_1.FunctionFragment.from(fragment)));
+    }
+    async function _deployViaDiamondProxy(name, options) {
+        let proxy;
+        const proxyName = name + '_DiamondProxy';
+        const oldDeployment = await getDeploymentOrNUll(name);
+        if (oldDeployment) {
+            proxy = await getDeployment(proxyName);
+        }
+        if (proxy && proxy.deployedBytecode === old_diamondbase_json_1.default.deployedBytecode) {
+            return _old_deployViaDiamondProxy(name, options);
+        }
+        const deployResult = _checkUpgradeIndex(oldDeployment, options.upgradeIndex);
+        if (deployResult) {
+            return deployResult;
+        }
+        let diamondArtifact = diamondBase;
+        if (options.diamondContract) {
+            if (typeof options.diamondContract === 'string') {
+                diamondArtifact = await partialExtension.getExtendedArtifact(options.diamondContract);
+            }
+            else {
+                diamondArtifact = options.diamondContract;
+            }
+        }
+        const { address: owner } = await getDiamondOwner(options);
+        const newSelectors = [];
+        const facetSnapshot = [];
+        let oldFacets = [];
+        if (proxy) {
+            const diamondProxy = new contracts_1.Contract(proxy.address, proxy.abi, provider);
+            oldFacets = await diamondProxy.facets();
+        }
+        const facetsSet = [...options.facets];
+        if (options.defaultCutFacet === undefined || options.defaultCutFacet) {
+            facetsSet.push({
+                name: '_DefaultDiamondCutFacet',
+                contract: diamondCutFacet,
+                args: [],
+                deterministic: true,
+            });
+        }
+        if (options.defaultOwnershipFacet === undefined || options.defaultOwnershipFacet) {
+            facetsSet.push({
+                name: '_DefaultDiamondOwnershipFacet',
+                contract: ownershipFacet,
+                args: [],
+                deterministic: true,
+            });
+        }
+        facetsSet.push({
+            name: '_DefaultDiamondLoupeFacet',
+            contract: diamondLoupeFacet,
+            args: [],
+            deterministic: true,
+        });
+        let changesDetected = !oldDeployment;
+        let abi = diamondArtifact.abi.concat([]);
+        const facetCuts = [];
+        let facetFound;
+        const excludeSelectors = options.excludeSelectors || {};
+        for (const facet of facetsSet) {
+            let deterministicFacet = true;
+            let facetName;
+            let artifact;
+            let linkedData = options.linkedData;
+            let libraries = options.libraries;
+            let facetArgs = options.facetsArgs;
+            if (typeof facet !== 'string') {
+                if (facet.deterministic !== undefined) {
+                    deterministicFacet = facet.deterministic;
+                }
+            }
+            let argsSpecific = false;
+            if (typeof facet === 'string') {
+                artifact = await partialExtension.getExtendedArtifact(facet);
+                facetName = facet;
+            }
+            else {
+                if (facet.linkedData) {
+                    linkedData = facet.linkedData;
+                }
+                if (facet.libraries) {
+                    libraries = facet.libraries;
+                }
+                if (facet.args !== undefined) {
+                    facetArgs = facet.args;
+                    argsSpecific = true;
+                }
+                if (facet.contract) {
+                    if (typeof facet.contract === 'string') {
+                        artifact = await partialExtension.getExtendedArtifact(facet.contract);
+                    }
+                    else {
+                        artifact = facet.contract;
+                    }
+                }
+                else {
+                    if (!facet.name) {
+                        throw new Error(`no name , not contract is specified for facet, cannot proceed`);
+                    }
+                    artifact = await partialExtension.getExtendedArtifact(facet.name);
+                }
+                facetName = facet.name;
+                if (!facetName) {
+                    if (typeof facet.contract === 'string') {
+                        facetName = name + '_facet_' + facet.contract;
+                    }
+                    else {
+                        throw new Error(`facet has no name, please specify one`);
+                    }
+                }
+            }
+            const constructor = artifact.abi.find((fragment) => fragment.type === 'constructor');
+            if (!argsSpecific && (!constructor || constructor.inputs.length === 0)) {
+                facetArgs = [];
+            }
+            let excludeSighashes = new Set();
+            if (facetName in excludeSelectors) {
+                const iface = new abi_1.Interface(artifact.abi);
+                excludeSighashes = new Set(excludeSelectors[facetName].map((selector) => iface.getSighash(selector)));
+            }
+            abi = (0, utils_2.mergeABIs)([abi, (0, utils_2.filterABI)(artifact.abi, excludeSighashes)], {
+                check: true,
+                skipSupportsInterface: false,
+            });
+            const implementation = await _deployOne(facetName, {
+                contract: artifact,
+                from: options.from,
+                autoMine: options.autoMine,
+                estimateGasExtra: options.estimateGasExtra,
+                estimatedGasLimit: options.estimatedGasLimit,
+                gasPrice: options.gasPrice,
+                maxFeePerGas: options.maxFeePerGas,
+                maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                log: options.log,
+                libraries,
+                linkedData,
+                args: facetArgs,
+                deterministicDeployment: deterministicFacet,
+            });
+            let facetAddress;
+            if (implementation.newlyDeployed) {
+                facetAddress = implementation.address;
+                const newFacet = {
+                    facetAddress,
+                    functionSelectors: sigsFromABI((0, utils_2.filterABI)(implementation.abi, excludeSighashes)),
+                };
+                facetSnapshot.push(newFacet);
+                newSelectors.push(...newFacet.functionSelectors);
+            }
+            else {
+                const oldImpl = await getDeployment(facetName);
+                facetAddress = oldImpl.address;
+                const newFacet = {
+                    facetAddress,
+                    functionSelectors: sigsFromABI((0, utils_2.filterABI)(oldImpl.abi, excludeSighashes)),
+                };
+                facetSnapshot.push(newFacet);
+                newSelectors.push(...newFacet.functionSelectors);
+            }
+            if (options.execute && !options.execute.contract) {
+                const methods = artifact.abi.filter((v) => v.name === options.execute?.methodName);
+                if (methods.length > 0) {
+                    if (methods.length > 1) {
+                        throw new Error(`multiple method named "${options.execute.methodName}" found in facet`);
+                    }
+                    else {
+                        if (facetFound) {
+                            throw new Error(`multiple facet with method named "${options.execute.methodName}"`);
+                        }
+                        else {
+                            facetFound = facetAddress;
+                        }
+                    }
+                }
+            }
+        }
+        const oldSelectors = [];
+        const oldSelectorsFacetAddress = {};
+        for (const oldFacet of oldFacets) {
+            for (const selector of oldFacet.functionSelectors) {
+                oldSelectors.push(selector);
+                oldSelectorsFacetAddress[selector] = oldFacet.facetAddress;
+            }
+        }
+        for (const newFacet of facetSnapshot) {
+            const selectorsToAdd = [];
+            const selectorsToReplace = [];
+            for (const selector of newFacet.functionSelectors) {
+                if (oldSelectors.indexOf(selector) >= 0) {
+                    if (oldSelectorsFacetAddress[selector].toLowerCase() !== newFacet.facetAddress.toLowerCase()) {
+                        selectorsToReplace.push(selector);
+                    }
+                }
+                else {
+                    selectorsToAdd.push(selector);
+                }
+            }
+            if (selectorsToReplace.length > 0) {
+                changesDetected = true;
+                facetCuts.push({
+                    facetAddress: newFacet.facetAddress,
+                    functionSelectors: selectorsToReplace,
+                    action: types_1.FacetCutAction.Replace,
+                });
+            }
+            if (selectorsToAdd.length > 0) {
+                changesDetected = true;
+                facetCuts.push({
+                    facetAddress: newFacet.facetAddress,
+                    functionSelectors: selectorsToAdd,
+                    action: types_1.FacetCutAction.Add,
+                });
+            }
+        }
+        const selectorsToDelete = [];
+        for (const selector of oldSelectors) {
+            if (newSelectors.indexOf(selector) === -1) {
+                selectorsToDelete.push(selector);
+            }
+        }
+        if (selectorsToDelete.length > 0) {
+            changesDetected = true;
+            facetCuts.unshift({
+                facetAddress: '0x0000000000000000000000000000000000000000',
+                functionSelectors: selectorsToDelete,
+                action: types_1.FacetCutAction.Remove,
+            });
+        }
+        let executeData = '0x';
+        let executeAddress = '0x0000000000000000000000000000000000000000';
+        if (options.execute) {
+            let addressSpecified;
+            let executionContract = new contracts_1.Contract('0x0000000000000000000000000000000000000001', abi);
+            if (options.execute.contract) {
+                if (typeof options.execute.contract === 'string') {
+                    const executionDeployment = await _deployOne(options.execute.contract, {
+                        from: options.from,
+                        autoMine: options.autoMine,
+                        estimateGasExtra: options.estimateGasExtra,
+                        estimatedGasLimit: options.estimatedGasLimit,
+                        gasPrice: options.gasPrice,
+                        maxFeePerGas: options.maxFeePerGas,
+                        maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                        log: options.log,
+                        deterministicDeployment: true,
+                    });
+                    executionContract = new contracts_1.Contract(executionDeployment.address, executionDeployment.abi);
+                    addressSpecified = executionContract.address;
+                }
+                else {
+                    const executionDeployment = await _deployOne(options.execute.contract.name, {
+                        from: options.from,
+                        contract: options.execute.contract.artifact,
+                        args: options.execute.contract.args,
+                        autoMine: options.autoMine,
+                        estimateGasExtra: options.estimateGasExtra,
+                        estimatedGasLimit: options.estimatedGasLimit,
+                        gasPrice: options.gasPrice,
+                        maxFeePerGas: options.maxFeePerGas,
+                        maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                        log: options.log,
+                        deterministicDeployment: true,
+                    });
+                    executionContract = new contracts_1.Contract(executionDeployment.address, executionDeployment.abi);
+                }
+            }
+            const txData = await executionContract.populateTransaction[options.execute.methodName](...options.execute.args);
+            executeData = txData.data || '0x';
+            executeAddress = addressSpecified || facetFound || '0x0000000000000000000000000000000000000000';
+        }
+        if (changesDetected) {
+            if (!proxy) {
+                const diamondConstructorArgs = options.diamondContractArgs || [
+                    '{owner}',
+                    '{facetCuts}',
+                    '{initializations}',
+                ];
+                const initializationsArgIndex = diamondConstructorArgs.indexOf('{initializations}');
+                const erc165InitArgIndex = diamondConstructorArgs.indexOf('{erc165}');
+                const initArgIndex = diamondConstructorArgs.indexOf('{init}');
+                const initAddressArgIndex = diamondConstructorArgs.indexOf('{initAddress}');
+                const initDataArgIndex = diamondConstructorArgs.indexOf('{initData}');
+                const ownerArgIndex = diamondConstructorArgs.indexOf('{owner}');
+                const facetCutsArgIndex = diamondConstructorArgs.indexOf('{facetCuts}');
+                if (initializationsArgIndex >= 0 &&
+                    (initArgIndex >= 0 || erc165InitArgIndex >= 0 || initDataArgIndex >= 0)) {
+                    throw new Error(`{initializations} found but also one or more of {init} {erc165} {initData}`);
+                }
+                const interfaceList = ['0x48e2b093'];
+                if (options.defaultCutFacet) {
+                    interfaceList.push('0x1f931c1c');
+                }
+                if (options.defaultOwnershipFacet) {
+                    interfaceList.push('0x7f5828d0');
+                }
+                if (initializationsArgIndex >= 0 || erc165InitArgIndex >= 0) {
+                    const diamondERC165InitDeployment = await _deployOne('_DefaultDiamondERC165Init', {
+                        from: options.from,
+                        deterministicDeployment: true,
+                        contract: diamondERC165Init,
+                        autoMine: options.autoMine,
+                        estimateGasExtra: options.estimateGasExtra,
+                        estimatedGasLimit: options.estimatedGasLimit,
+                        gasPrice: options.gasPrice,
+                        maxFeePerGas: options.maxFeePerGas,
+                        maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                        log: options.log,
+                    });
+                    const diamondERC165InitContract = new contracts_1.Contract(diamondERC165InitDeployment.address, diamondERC165InitDeployment.abi);
+                    const interfaceInitTx = await diamondERC165InitContract.populateTransaction.setERC165(interfaceList, []);
+                    if (initializationsArgIndex >= 0) {
+                        const initializations = [];
+                        initializations.push({
+                            initContract: interfaceInitTx.to,
+                            initData: interfaceInitTx.data,
+                        });
+                        diamondConstructorArgs[initializationsArgIndex] = initializations;
+                    }
+                    else {
+                        diamondConstructorArgs[erc165InitArgIndex] = {
+                            initContract: interfaceInitTx.to,
+                            initData: interfaceInitTx.data,
+                        };
+                    }
+                }
+                if (ownerArgIndex >= 0) {
+                    diamondConstructorArgs[ownerArgIndex] = owner;
+                }
+                else {
+                }
+                if (facetCutsArgIndex >= 0) {
+                    diamondConstructorArgs[facetCutsArgIndex] = facetCuts;
+                }
+                else {
+                    throw new Error(`diamond constructor needs a {facetCuts} argument`);
+                }
+                if (executeData) {
+                    if (initializationsArgIndex >= 0) {
+                        if (executeData !== '0x') {
+                            diamondConstructorArgs[initializationsArgIndex].push({
+                                initContract: executeAddress,
+                                initData: executeData,
+                            });
+                        }
+                    }
+                    else {
+                        if (initArgIndex >= 0) {
+                            diamondConstructorArgs[initArgIndex] = {
+                                initContract: executeAddress,
+                                initData: executeData,
+                            };
+                        }
+                        else if (initDataArgIndex >= 0) {
+                            diamondConstructorArgs[initDataArgIndex] = executeData;
+                            if (initAddressArgIndex >= 0) {
+                                diamondConstructorArgs[initAddressArgIndex] = executeAddress;
+                            }
+                        }
+                        else {
+                            throw new Error(`no {init} or {initData} found in list of args even though execute is set in option`);
+                        }
+                    }
+                }
+                let deterministicDiamondAlreadyDeployed = false;
+                let expectedAddress = undefined;
+                let salt = '0x0000000000000000000000000000000000000000000000000000000000000000';
+                if (typeof options.deterministicSalt !== 'undefined') {
+                    if (typeof options.deterministicSalt === 'string') {
+                        if (options.deterministicSalt === salt) {
+                            throw new Error(`deterministicSalt cannot be 0x000..., it needs to be a non-zero bytes32 salt. This is to ensure you are explicitly specyfying different addresses for multiple diamonds`);
+                        }
+                        else {
+                            if (options.deterministicSalt.length !== 66) {
+                                throw new Error(`deterministicSalt needs to be a string of 66 hexadecimal characters (including the 0x prefix)`);
+                            }
+                            salt = options.deterministicSalt;
+                            const factory = new DeploymentFactory_1.CustomDeploymentFactory(getArtifact, diamondArtifact, diamondConstructorArgs, network);
+                            const create2DeployerAddress = await deploymentManager.getDeterministicDeploymentFactoryAddress();
+                            expectedAddress = await factory.getCreate2Address(create2DeployerAddress, salt);
+                            const code = await provider.getCode(expectedAddress);
+                            if (code !== '0x') {
+                                deterministicDiamondAlreadyDeployed = true;
+                            }
+                        }
+                    }
+                    else {
+                        throw new Error(`deterministicSalt need to be a string, an non-zero bytes32 salt`);
+                    }
+                }
+                if (expectedAddress && deterministicDiamondAlreadyDeployed) {
+                    proxy = {
+                        ...diamondArtifact,
+                        address: expectedAddress,
+                        args: diamondConstructorArgs,
+                    };
+                    await saveDeployment(proxyName, proxy);
+                    await saveDeployment(name, {
+                        ...proxy,
+                        linkedData: options.linkedData,
+                        facets: facetSnapshot,
+                        abi,
+                    });
+                    await _deployViaDiamondProxy(name, options);
+                }
+                else {
+                    proxy = await _deployOne(proxyName, {
+                        contract: diamondArtifact,
+                        from: options.from,
+                        args: diamondConstructorArgs,
+                        autoMine: options.autoMine,
+                        deterministicDeployment: options.deterministicSalt,
+                        estimateGasExtra: options.estimateGasExtra,
+                        estimatedGasLimit: options.estimatedGasLimit,
+                        gasLimit: options.gasLimit,
+                        gasPrice: options.gasPrice,
+                        log: options.log,
+                        nonce: options.nonce,
+                        maxFeePerGas: options.maxFeePerGas,
+                        maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                        value: options.value,
+                    });
+                    await saveDeployment(proxyName, { ...proxy, abi });
+                    await saveDeployment(name, {
+                        ...proxy,
+                        linkedData: options.linkedData,
+                        facets: facetSnapshot,
+                        abi,
+                        execute: options.execute,
+                    });
+                }
+            }
+            else {
+                if (!oldDeployment) {
+                    throw new Error(`Cannot find Deployment for ${name}`);
+                }
+                const currentOwner = await read(proxyName, 'owner');
+                if (currentOwner.toLowerCase() !== owner.toLowerCase()) {
+                    throw new Error('To change owner, you need to call `transferOwnership`');
+                }
+                if (currentOwner === constants_1.AddressZero) {
+                    throw new Error('The Diamond belongs to no-one. It cannot be upgraded anymore');
+                }
+                const executeReceipt = await execute(name, { ...options, from: currentOwner }, 'diamondCut', facetCuts, executeData === '0x'
+                    ? '0x0000000000000000000000000000000000000000'
+                    : executeAddress || proxy.address, executeData);
+                if (!executeReceipt) {
+                    throw new Error('failed to execute');
+                }
+                const diamondDeployment = {
+                    ...oldDeployment,
+                    linkedData: options.linkedData,
+                    address: proxy.address,
+                    abi,
+                    facets: facetSnapshot,
+                    execute: options.execute,
+                };
+                if (oldDeployment.history) {
+                    diamondDeployment.history = diamondDeployment.history
+                        ? diamondDeployment.history.concat([oldDeployment])
+                        : [oldDeployment];
+                }
+                await saveDeployment(name, diamondDeployment);
+            }
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: true,
+            };
+        }
+        else {
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: false,
+            };
+        }
+    }
+    async function deploy(name, options) {
+        options = { ...options };
+        await init();
+        if (!options.proxy) {
+            return _deployOne(name, options);
+        }
+        return _deployViaProxy(name, options);
+    }
+    async function diamond(name, options) {
+        options = { ...options };
+        await init();
+        return _deployViaDiamondProxy(name, options);
+    }
+    async function rawTx(tx) {
+        tx = { ...tx };
+        await init();
+        const { address: from, ethersSigner, hardwareWallet, unknown } = await getFrom(tx.from);
+        const transactionData = {
+            to: tx.to,
+            gasLimit: tx.gasLimit,
+            gasPrice: tx.gasPrice ? bignumber_1.BigNumber.from(tx.gasPrice) : undefined,
+            maxFeePerGas: tx.maxFeePerGas ? bignumber_1.BigNumber.from(tx.maxFeePerGas) : undefined,
+            maxPriorityFeePerGas: tx.maxPriorityFeePerGas ? bignumber_1.BigNumber.from(tx.maxPriorityFeePerGas) : undefined,
+            value: tx.value ? bignumber_1.BigNumber.from(tx.value) : undefined,
+            nonce: tx.nonce,
+            data: tx.data,
+        };
+        await overrideGasLimit(transactionData, tx, (newOverrides) => ethersSigner.estimateGas(newOverrides));
+        await setupGasPrice(transactionData);
+        await setupNonce(from, transactionData);
+        if (unknown) {
+            throw new errors_1.UnknownSignerError({
+                from,
+                ...transactionData,
+            });
+        }
+        if (hardwareWallet) {
+            log(` please confirm on your ${hardwareWallet}`);
+        }
+        let pendingTx = (await handleSpecificErrors(ethersSigner.sendTransaction(transactionData)));
+        pendingTx = await onPendingTx(pendingTx);
+        if (tx.autoMine) {
+            try {
+                await provider.send('evm_mine', []);
+            }
+            catch (e) { }
+        }
+        return pendingTx.wait();
+    }
+    async function catchUnknownSigner(action, options) {
+        const outputLog = !options || options.log === undefined || options.log;
+        try {
+            if (action instanceof Promise) {
+                await action;
+            }
+            else {
+                await action();
+            }
+        }
+        catch (e) {
+            if (e instanceof errors_1.UnknownSignerError) {
+                const { from, to, data, value, contract } = e.data;
+                if (outputLog) {
+                    console.log(`---------------------------------------------------------------------------------------`);
+                    console.error('no signer for ' + from);
+                    console.log(`Please execute the following:`);
+                    console.log(`---------------------------------------------------------------------------------------`);
+                    if (contract) {
+                        console.log(`
+from: ${from}
+to: ${to} (${contract.name})${value ? '\nvalue: ' + (typeof value === 'string' ? value : value.toString()) : ''}
+method: ${contract.method}
+args:
+  - ${contract.args.join('\n  - ')}
+
+(raw data: ${data} )
+`);
+                    }
+                    else {
+                        console.log(`
+from: ${from}
+to: ${to ? to : '0x0000000000000000000000000000000000000000'}${value ? '\nvalue: ' + (typeof value === 'string' ? value : value.toString()) : ''}
+data: ${data}
+`);
+                    }
+                    console.log(`---------------------------------------------------------------------------------------`);
+                }
+                if (!value || typeof value === 'string') {
+                    return { from, to, value, data };
+                }
+                return { from, to, value: value?.toString(), data };
+            }
+            else {
+                throw e;
+            }
+        }
+        return null;
+    }
+    async function execute(name, options, methodName, ...args) {
+        options = { ...options };
+        await init();
+        const { address: from, ethersSigner, hardwareWallet, unknown } = await getFrom(options.from);
+        let tx;
+        const deployment = await partialExtension.get(name);
+        const abi = deployment.abi;
+        const overrides = {
+            gasLimit: options.gasLimit,
+            gasPrice: options.gasPrice ? bignumber_1.BigNumber.from(options.gasPrice) : undefined,
+            maxFeePerGas: options.maxFeePerGas ? bignumber_1.BigNumber.from(options.maxFeePerGas) : undefined,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+                ? bignumber_1.BigNumber.from(options.maxPriorityFeePerGas)
+                : undefined,
+            value: options.value ? bignumber_1.BigNumber.from(options.value) : undefined,
+            nonce: options.nonce,
+        };
+        const ethersContract = new contracts_1.Contract(deployment.address, abi, ethersSigner);
+        if (!ethersContract.functions[methodName]) {
+            throw new Error(`No method named "${methodName}" on contract deployed as "${name}"`);
+        }
+        const numArguments = ethersContract.interface.getFunction(methodName).inputs.length;
+        if (args.length !== numArguments) {
+            throw new Error(`expected ${numArguments} arguments for method "${methodName}", got ${args.length}`);
+        }
+        await overrideGasLimit(overrides, options, (newOverrides) => {
+            const ethersArgsWithGasLimit = args ? args.concat([newOverrides]) : [newOverrides];
+            return ethersContract.estimateGas[methodName](...ethersArgsWithGasLimit);
+        });
+        await setupGasPrice(overrides);
+        await setupNonce(from, overrides);
+        const ethersArgs = args ? args.concat([overrides]) : [overrides];
+        if (unknown) {
+            const ethersArgs = args ? args.concat([overrides]) : [overrides];
+            const { data } = await ethersContract.populateTransaction[methodName](...ethersArgs);
+            throw new errors_1.UnknownSignerError({
+                from,
+                to: deployment.address,
+                data,
+                value: options.value,
+                contract: {
+                    name,
+                    method: methodName,
+                    args,
+                },
+            });
+        }
+        if (options.log || hardwareWallet) {
+            print(`executing ${name}.${methodName}`);
+            if (hardwareWallet) {
+                print(` (please confirm on your ${hardwareWallet})`);
+            }
+        }
+        if (network.tron) {
+            const method = ethersContract.interface.getFunction(methodName);
+            const methodParams = method.inputs.map((input) => input.type);
+            const funcSig = `${methodName}(${methodParams.join(',')})`;
+            const tronArgs = args.map((a, i) => ({
+                type: methodParams[i],
+                value: a,
+            }));
+            tx = await handleSpecificErrors(ethersSigner.provider.triggerSmartContract(from, deployment.address, funcSig, tronArgs, overrides));
+        }
+        else {
+            tx = await handleSpecificErrors(ethersContract.functions[methodName](...ethersArgs));
+        }
+        tx = await onPendingTx(tx);
+        if (options.log || hardwareWallet) {
+            print(` (tx: ${tx.hash}) ...`);
+        }
+        if (options.autoMine) {
+            try {
+                await provider.send('evm_mine', []);
+            }
+            catch (e) { }
+        }
+        const receipt = await tx.wait();
+        if (options.log || hardwareWallet) {
+            print(`: performed with ${receipt.gasUsed} gas\n`);
+        }
+        return receipt;
+    }
+    async function read(name, options, methodName, ...args) {
+        if (typeof options === 'string') {
+            if (typeof methodName !== 'undefined') {
+                args.unshift(methodName);
+            }
+            methodName = options;
+            options = {};
+        }
+        options = { ...options };
+        await init();
+        if (typeof args === 'undefined') {
+            args = [];
+        }
+        let caller = provider;
+        const { ethersSigner } = await getOptionalFrom(options.from);
+        if (ethersSigner) {
+            caller = ethersSigner;
+        }
+        const deployment = await partialExtension.get(name);
+        if (!deployment) {
+            throw new Error(`no contract named "${name}"`);
+        }
+        const abi = deployment.abi;
+        const overrides = {
+            gasLimit: options.gasLimit,
+            gasPrice: options.gasPrice ? bignumber_1.BigNumber.from(options.gasPrice) : undefined,
+            maxFeePerGas: options.maxFeePerGas ? bignumber_1.BigNumber.from(options.maxFeePerGas) : undefined,
+            maxPriorityFeePerGas: options.maxPriorityFeePerGas
+                ? bignumber_1.BigNumber.from(options.maxPriorityFeePerGas)
+                : undefined,
+            value: options.value ? bignumber_1.BigNumber.from(options.value) : undefined,
+            nonce: options.nonce,
+        };
+        cleanupOverrides(overrides);
+        const ethersContract = new contracts_1.Contract(deployment.address, abi, caller);
+        const method = ethersContract.callStatic[methodName];
+        if (!method) {
+            throw new Error(`no method named "${methodName}" on contract "${name}"`);
+        }
+        if (args.length > 0) {
+            return method(...args, overrides);
+        }
+        else {
+            return method(overrides);
+        }
+    }
+    async function getSigner(address) {
+        await init();
+        const { ethersSigner } = await getFrom(address);
+        return ethersSigner;
+    }
+    const extension = {
+        ...partialExtension,
+        fetchIfDifferent,
+        deploy,
+        diamond: {
+            deploy: diamond,
+        },
+        catchUnknownSigner,
+        execute,
+        rawTx,
+        read,
+        deterministic,
+        getSigner,
+    };
+    const utils = {
+        dealWithPendingTransactions: async (pendingTxs, pendingTxPath, globalGasPrice) => {
+            await init();
+            const txHashes = Object.keys(pendingTxs);
+            for (const txHash of txHashes) {
+                let tx;
+                const txData = pendingTxs[txHash];
+                if (txData.rawTx || txData.decoded) {
+                    if (txData.rawTx) {
+                        tx = (0, transactions_1.parse)(txData.rawTx);
+                    }
+                    else {
+                        tx = (0, utils_2.recode)(txData.decoded);
+                    }
+                }
+                else {
+                    console.error(`no access to raw data for tx ${txHash}`);
+                }
+                const txFromPeers = await network.provider.send('eth_getTransactionByHash', [txHash]);
+                let feeHistory = undefined;
+                let newGasPriceS = globalGasPrice;
+                if (!newGasPriceS) {
+                    newGasPriceS = await network.provider.send('eth_gasPrice', []);
+                    try {
+                        feeHistory = await network.provider.send('eth_feeHistory', [4, 'latest', [25, 75]]);
+                    }
+                    catch (e) { }
+                }
+                const newGasPrice = bignumber_1.BigNumber.from(newGasPriceS);
+                let newBaseFee = undefined;
+                if (feeHistory) {
+                    newBaseFee = bignumber_1.BigNumber.from(feeHistory.baseFeePerGas[feeHistory.baseFeePerGas.length - 1]);
+                }
+                const choices = ['skip (forget tx)'];
+                if (!txFromPeers) {
+                    if (tx) {
+                        choices.unshift('broadcast again');
+                    }
+                    console.log(`transaction ${txHash} cannot be found among peers`);
+                }
+                else {
+                    choices.unshift('continue waiting');
+                    if (tx) {
+                        console.log(`transaction ${txHash} still pending... It used a gas pricing config of ${tx.gasPrice
+                            ? `(gasPrice: ${tx.gasPrice.toString()} wei)`
+                            : tx.maxPriorityFeePerGas || tx.maxPriorityFeePerGas
+                                ? `maxPriorityFeePerGas: ${tx.maxPriorityFeePerGas?.toString()} maxFeePerGas: ${tx.maxFeePerGas?.toString()}`
+                                : ``} ,
+              current gas price is ${newGasPrice.toString()} wei
+              ${newBaseFee ? `new baseFee is ${newBaseFee.toString()}` : ''}
+              `);
+                    }
+                    else {
+                        console.log(`transaction ${txHash} still pending...`);
+                    }
+                }
+                if (tx && tx.gasPrice && tx.gasPrice.lt(newGasPrice)) {
+                    choices.unshift('increase gas');
+                }
+                else if (tx && (tx.maxFeePerGas || tx.maxPriorityFeePerGas)) {
+                    choices.unshift('increase gas');
+                }
+                const prompt = new enquirer_1.default.Select({
+                    name: 'action',
+                    message: 'Choose what to do with the pending transaction:',
+                    choices,
+                });
+                const answer = await prompt.run();
+                let txHashToWait;
+                if (answer !== 'skip (forget tx)') {
+                    if (answer === 'continue waiting') {
+                        console.log('waiting for transaction...');
+                        txHashToWait = txHash;
+                    }
+                    else if (answer === 'broadcast again') {
+                        if (!tx) {
+                            throw new Error(`cannot resubmit a tx if info not available`);
+                        }
+                        if (txData.rawTx) {
+                            const tx = (await handleSpecificErrors(provider.sendTransaction(txData.rawTx)));
+                            txHashToWait = tx.hash;
+                            if (tx.hash !== txHash) {
+                                console.error('non mathcing tx hashes after resubmitting...');
+                            }
+                            console.log('waiting for newly broadcasted tx ...');
+                        }
+                        else {
+                            console.log('resigning the tx...');
+                            const { ethersSigner, hardwareWallet } = await getOptionalFrom(tx.from);
+                            if (!ethersSigner) {
+                                throw new Error('no signer for ' + tx.from);
+                            }
+                            if (hardwareWallet) {
+                                print(` (please confirm on your ${hardwareWallet})`);
+                            }
+                            const txReq = await handleSpecificErrors(ethersSigner.sendTransaction(cleanupOverrides({
+                                to: tx.to,
+                                from: tx.from,
+                                nonce: tx.nonce,
+                                gasLimit: tx.gasLimit,
+                                gasPrice: tx.gasPrice,
+                                maxFeePerGas: tx.maxFeePerGas,
+                                maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+                                data: tx.data,
+                                value: tx.value,
+                                chainId: tx.chainId,
+                                type: tx.type === null ? undefined : tx.type,
+                                accessList: tx.accessList,
+                            })));
+                            txHashToWait = txReq.hash;
+                            if (txReq.hash !== txHash) {
+                                delete pendingTxs[txHash];
+                                if (Object.keys(pendingTxs).length === 0) {
+                                    fs_extra_1.default.removeSync(pendingTxPath);
+                                }
+                                else {
+                                    fs_extra_1.default.writeFileSync(pendingTxPath, JSON.stringify(pendingTxs, utils_1.bnReplacer, '  '));
+                                }
+                                await onPendingTx(txReq);
+                                console.error('non mathcing tx hashes after resubmitting...');
+                            }
+                        }
+                    }
+                    else if (answer === 'increase gas') {
+                        if (!tx) {
+                            throw new Error(`cannot resubmit a tx if info not available`);
+                        }
+                        const { ethersSigner, hardwareWallet } = await getOptionalFrom(tx.from);
+                        if (!ethersSigner) {
+                            throw new Error('no signer for ' + tx.from);
+                        }
+                        if (hardwareWallet) {
+                            print(` (please confirm on your ${hardwareWallet})`);
+                        }
+                        const gasPriceSetup = await getGasPrice();
+                        const maxFeePerGas = gasPriceSetup.maxFeePerGas;
+                        const maxPriorityFeePerGas = gasPriceSetup.maxPriorityFeePerGas;
+                        let gasPrice;
+                        if (!maxFeePerGas && !maxPriorityFeePerGas) {
+                            gasPrice = gasPriceSetup.gasPrice;
+                            if (gasPrice) {
+                                console.log('using legacy gasPrice with gasprice passed in');
+                            }
+                        }
+                        const txReq = await handleSpecificErrors(ethersSigner.sendTransaction(cleanupOverrides({
+                            to: tx.to,
+                            from: tx.from,
+                            nonce: tx.nonce,
+                            gasLimit: tx.gasLimit,
+                            gasPrice,
+                            maxFeePerGas,
+                            maxPriorityFeePerGas,
+                            data: tx.data,
+                            value: tx.value,
+                            chainId: tx.chainId,
+                            type: tx.type === null ? undefined : tx.type,
+                            accessList: tx.accessList,
+                        })));
+                        txHashToWait = txReq.hash;
+                        delete pendingTxs[txHash];
+                        if (Object.keys(pendingTxs).length === 0) {
+                            fs_extra_1.default.removeSync(pendingTxPath);
+                        }
+                        else {
+                            fs_extra_1.default.writeFileSync(pendingTxPath, JSON.stringify(pendingTxs, utils_1.bnReplacer, '  '));
+                        }
+                        await onPendingTx(txReq);
+                        console.log(`new transaction submitted, waiting... ${txReq.hash}`);
+                    }
+                }
+                if (txHashToWait) {
+                    const receipt = await waitForTx(network.provider, txHashToWait, false);
+                    if ((!receipt.status || receipt.status == 1) &&
+                        receipt.contractAddress &&
+                        txData.name) {
+                        await saveDeployment(txData.name, {
+                            ...txData.deployment,
+                            receipt,
+                        });
+                    }
+                }
+                delete pendingTxs[txHash];
+                if (Object.keys(pendingTxs).length === 0) {
+                    fs_extra_1.default.removeSync(pendingTxPath);
+                }
+                else {
+                    fs_extra_1.default.writeFileSync(pendingTxPath, JSON.stringify(pendingTxs, utils_1.bnReplacer, '  '));
+                }
+            }
+        },
+    };
+    extension.call = (options, name, methodName, ...args) => {
+        if (typeof options === 'string') {
+            args = args || [];
+            if (methodName !== undefined) {
+                args.unshift(methodName);
+            }
+            methodName = name;
+            name = options;
+            options = {};
+        }
+        return read(name, options, methodName, ...args);
+    };
+    extension.sendTxAndWait = (options, name, methodName, ...args) => {
+        return execute(name, options, methodName, ...args);
+    };
+    extension.deployIfDifferent = (name, options, contractName, ...args) => {
+        options.contract = contractName;
+        options.args = args;
+        return deploy(name, options);
+    };
+    async function _old_deployViaDiamondProxy(name, options) {
+        if (options.log) {
+            log(`handling old diamond ${name} ...`);
+        }
+        const oldDeployment = await getDeploymentOrNUll(name);
+        let proxy;
+        const deployResult = _checkUpgradeIndex(oldDeployment, options.upgradeIndex);
+        if (deployResult) {
+            return deployResult;
+        }
+        if (options.deterministicSalt) {
+            throw new Error(`old diamonds do not support determinsitc deployment`);
+        }
+        const proxyName = name + '_DiamondProxy';
+        const { address: owner } = await getDiamondOwner(options);
+        const newSelectors = [];
+        const facetSnapshot = [];
+        const oldFacets = [];
+        const selectorToNotTouch = {};
+        for (const selector of [
+            '0xcdffacc6',
+            '0x52ef6b2c',
+            '0xadfca15e',
+            '0x7a0ed627',
+            '0x01ffc9a7',
+            '0x1f931c1c',
+            '0xf2fde38b',
+            '0x8da5cb5b',
+        ]) {
+            selectorToNotTouch[selector] = true;
+        }
+        if (oldDeployment) {
+            proxy = await getDeployment(proxyName);
+            const diamondProxy = new contracts_1.Contract(proxy.address, proxy.abi, provider);
+            const currentFacets = await diamondProxy.facets();
+            for (const currentFacet of currentFacets) {
+                oldFacets.push(currentFacet);
+                if (findAll(['0xcdffacc6', '0x52ef6b2c', '0xadfca15e', '0x7a0ed627', '0x01ffc9a7'], currentFacet.functionSelectors) ||
+                    currentFacet.functionSelectors[0] === '0x1f931c1c' ||
+                    findAll(['0xf2fde38b', '0x8da5cb5b'], currentFacet.functionSelectors)) {
+                    facetSnapshot.push(currentFacet);
+                    newSelectors.push(...currentFacet.functionSelectors);
+                }
+            }
+        }
+        else {
+            throw new Error(`old diamond deployments are now disabled`);
+        }
+        let changesDetected = !oldDeployment;
+        let abi = old_diamondbase_json_1.default.abi.concat([]);
+        const facetCuts = [];
+        for (const facet of options.facets) {
+            let facetName;
+            let artifact;
+            let linkedData = options.linkedData;
+            let libraries = options.libraries;
+            let facetArgs = options.facetsArgs;
+            let argsSpecific = false;
+            if (typeof facet === 'string') {
+                artifact = await partialExtension.getExtendedArtifact(facet);
+                facetName = facet;
+            }
+            else {
+                if (facet.linkedData) {
+                    linkedData = facet.linkedData;
+                }
+                if (facet.libraries) {
+                    libraries = facet.libraries;
+                }
+                if (facet.args) {
+                    facetArgs = facet.args;
+                    argsSpecific = true;
+                }
+                if (facet.contract) {
+                    if (typeof facet.contract === 'string') {
+                        artifact = await partialExtension.getExtendedArtifact(facet.contract);
+                    }
+                    else {
+                        artifact = facet.contract;
+                    }
+                }
+                else {
+                    if (!facet.name) {
+                        throw new Error(`no name , not contract is specified for facet, cannot proceed`);
+                    }
+                    artifact = await partialExtension.getExtendedArtifact(facet.name);
+                }
+                facetName = facet.name;
+                if (!facetName) {
+                    if (typeof facet.contract === 'string') {
+                        facetName = name + '_facet_' + facet.contract;
+                    }
+                    else {
+                        throw new Error(`facet has no name, please specify one`);
+                    }
+                }
+            }
+            const constructor = artifact.abi.find((fragment) => fragment.type === 'constructor');
+            if ((!argsSpecific && !constructor) || constructor.inputs.length === 0) {
+                facetArgs = [];
+            }
+            abi = (0, utils_2.mergeABIs)([abi, artifact.abi], {
+                check: true,
+                skipSupportsInterface: false,
+            });
+            const implementation = await _deployOne(facetName, {
+                contract: artifact,
+                from: options.from,
+                autoMine: options.autoMine,
+                estimateGasExtra: options.estimateGasExtra,
+                estimatedGasLimit: options.estimatedGasLimit,
+                gasPrice: options.gasPrice,
+                maxFeePerGas: options.maxFeePerGas,
+                maxPriorityFeePerGas: options.maxPriorityFeePerGas,
+                log: options.log,
+                libraries,
+                linkedData,
+                args: facetArgs,
+            });
+            if (implementation.newlyDeployed) {
+                const newFacet = {
+                    facetAddress: implementation.address,
+                    functionSelectors: sigsFromABI(implementation.abi),
+                };
+                facetSnapshot.push(newFacet);
+                newSelectors.push(...newFacet.functionSelectors);
+            }
+            else {
+                const oldImpl = await getDeployment(facetName);
+                const newFacet = {
+                    facetAddress: oldImpl.address,
+                    functionSelectors: sigsFromABI(oldImpl.abi),
+                };
+                facetSnapshot.push(newFacet);
+                newSelectors.push(...newFacet.functionSelectors);
+            }
+        }
+        const oldSelectors = [];
+        const oldSelectorsFacetAddress = {};
+        for (const oldFacet of oldFacets) {
+            for (const selector of oldFacet.functionSelectors) {
+                oldSelectors.push(selector);
+                oldSelectorsFacetAddress[selector] = oldFacet.facetAddress;
+            }
+        }
+        for (const newFacet of facetSnapshot) {
+            const selectorsToAdd = [];
+            const selectorsToReplace = [];
+            for (const selector of newFacet.functionSelectors) {
+                if (oldSelectors.indexOf(selector) > 0) {
+                    if (oldSelectorsFacetAddress[selector].toLowerCase() !== newFacet.facetAddress.toLowerCase() &&
+                        !selectorToNotTouch[selector]) {
+                        selectorsToReplace.push(selector);
+                    }
+                }
+                else {
+                    if (!selectorToNotTouch[selector]) {
+                        selectorsToAdd.push(selector);
+                    }
+                }
+            }
+            if (selectorsToReplace.length > 0) {
+                changesDetected = true;
+                facetCuts.push({
+                    facetAddress: newFacet.facetAddress,
+                    functionSelectors: selectorsToReplace,
+                    action: types_1.FacetCutAction.Replace,
+                });
+            }
+            if (selectorsToAdd.length > 0) {
+                changesDetected = true;
+                facetCuts.push({
+                    facetAddress: newFacet.facetAddress,
+                    functionSelectors: selectorsToAdd,
+                    action: types_1.FacetCutAction.Add,
+                });
+            }
+        }
+        const selectorsToDelete = [];
+        for (const selector of oldSelectors) {
+            if (newSelectors.indexOf(selector) === -1) {
+                selectorsToDelete.push(selector);
+            }
+        }
+        if (selectorsToDelete.length > 0) {
+            changesDetected = true;
+            facetCuts.unshift({
+                facetAddress: '0x0000000000000000000000000000000000000000',
+                functionSelectors: selectorsToDelete,
+                action: types_1.FacetCutAction.Remove,
+            });
+        }
+        let data = '0x';
+        if (options.execute) {
+            const diamondContract = new contracts_1.Contract('0x0000000000000000000000000000000000000001', abi);
+            const txData = await diamondContract.populateTransaction[options.execute.methodName](...options.execute.args);
+            data = txData.data || '0x';
+        }
+        if (changesDetected) {
+            if (!proxy) {
+                throw new Error(`no proxy found: old diamond deployments are now disabled`);
+            }
+            else {
+                const currentOwner = await read(proxyName, 'owner');
+                if (currentOwner.toLowerCase() !== owner.toLowerCase()) {
+                    throw new Error('To change owner, you need to call `transferOwnership`');
+                }
+                if (currentOwner === constants_1.AddressZero) {
+                    throw new Error('The Diamond belongs to no-one. It cannot be upgraded anymore');
+                }
+                const executeReceipt = await execute(name, { ...options, from: currentOwner }, 'diamondCut', facetCuts, data === '0x' ? '0x0000000000000000000000000000000000000000' : proxy.address, data);
+                if (!executeReceipt) {
+                    throw new Error('failed to execute');
+                }
+                const diamondDeployment = {
+                    ...oldDeployment,
+                    linkedData: options.linkedData,
+                    address: proxy.address,
+                    abi,
+                    facets: facetSnapshot,
+                    execute: options.execute,
+                };
+                if (oldDeployment.history) {
+                    diamondDeployment.history = diamondDeployment.history
+                        ? diamondDeployment.history.concat([oldDeployment])
+                        : [oldDeployment];
+                }
+                await saveDeployment(name, diamondDeployment);
+            }
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: true,
+            };
+        }
+        else {
+            const deployment = await partialExtension.get(name);
+            return {
+                ...deployment,
+                newlyDeployed: false,
+            };
+        }
+    }
+    return { extension, utils };
+}
+exports.addHelpers = addHelpers;
+function pause(duration) {
+    return new Promise((res) => setTimeout(res, duration * 1000));
+}
+async function waitForTx(ethereum, txHash, isContract) {
+    let receipt;
+    while (true) {
+        try {
+            receipt = await ethereum.send('eth_getTransactionReceipt', [txHash]);
+        }
+        catch (e) { }
+        if (receipt && receipt.blockNumber) {
+            if (isContract) {
+                if (!receipt.contractAddress) {
+                    throw new Error('contract not deployed');
+                }
+                else {
+                    return receipt;
+                }
+            }
+            else {
+                return receipt;
+            }
+        }
+        await pause(2);
+    }
+}
+exports.waitForTx = waitForTx;
+function replaceTemplateArgs(proxyArgsTemplate, { implementationAddress, proxyAdmin, data, proxyAddress, }) {
+    const proxyArgs = [];
+    for (let i = 0; i < proxyArgsTemplate.length; i++) {
+        const argValue = proxyArgsTemplate[i];
+        if (argValue === '{implementation}') {
+            proxyArgs.push(implementationAddress);
+        }
+        else if (argValue === '{admin}') {
+            proxyArgs.push(proxyAdmin);
+        }
+        else if (argValue === '{data}') {
+            proxyArgs.push(data);
+        }
+        else if (argValue === '{proxy}') {
+            if (!proxyAddress) {
+                throw new Error(`Expected proxy address but none was specified.`);
+            }
+            proxyArgs.push(proxyAddress);
+        }
+        else {
+            proxyArgs.push(argValue);
+        }
+    }
+    return proxyArgs;
+}
+//# sourceMappingURL=helper.js.map