@solarity/hardhat-migrate
Version:
The simplest way to deploy smart contracts
159 lines • 6.52 kB
JavaScript
"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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.ExtendedHardhatEthersSigner = void 0;
const errors_1 = require("../../errors");
const trezor_integration_1 = require("../integrations/trezor-integration");
const cast_integration_1 = require("../integrations/cast-integration");
const NetworkManager_1 = require("./NetworkManager");
class ExtendedHardhatEthersSigner {
_hre;
_config;
_initialized = false;
provider;
ethersSigner;
signerIdentifier;
static async fromSignerName(signerName) {
const hre = await Promise.resolve().then(() => __importStar(require("hardhat")));
let ethersSigner;
try {
ethersSigner = await NetworkManager_1.networkManager?.getEthersSigner(signerName);
}
catch {
const address = hre.ethers.isAddress(signerName) ? signerName : hre.ethers.ZeroAddress;
ethersSigner = new hre.ethers.VoidSigner(address, hre.ethers.provider);
}
return new ExtendedHardhatEthersSigner(hre, ethersSigner, signerName);
}
constructor(_hre, ethersSigner, signerName) {
this._hre = _hre;
this.ethersSigner = ethersSigner;
this._config = this._hre.config.migrate;
this.provider = this._hre.ethers.provider;
this.signerIdentifier = this._determineSignerIdentifier(signerName);
}
async getAddress() {
if (this._isCastEnabled()) {
return (0, cast_integration_1.getCastWalletAddress)(this._getCastOptions());
}
if (this._config.trezorWallet.enabled) {
return (0, trezor_integration_1.getTrezorAddress)(this._config.trezorWallet.mnemonicIndex || 0);
}
if ("getAddress" in this.ethersSigner) {
return this.ethersSigner.getAddress();
}
throw new errors_1.MigrateError("No valid signer configuration found to determine address");
}
async sendTransaction(tx) {
const hre = await Promise.resolve().then(() => __importStar(require("hardhat")));
await this._ensureInitialized();
if (!this._isCastEnabled() && !this._config.trezorWallet.enabled) {
return this.ethersSigner.sendTransaction(tx);
}
const voidSigner = new hre.ethers.VoidSigner(await this.getAddress(), this.provider);
let preparedTx = await voidSigner.populateTransaction(tx);
if (hre.network.config.gasPrice) {
try {
preparedTx.gasPrice = hre.ethers.parseUnits(hre.network.config.gasPrice.toString(), "gwei");
}
catch {
/* empty */
}
}
if (hre.network.config.gasMultiplier) {
preparedTx.gasLimit = String((BigInt(preparedTx.gasLimit) * BigInt(hre.network.config.gasMultiplier * 100)) / 100n);
}
delete preparedTx.from;
if (this._config.trezorWallet.enabled) {
preparedTx = await this._prepareTrezorTransaction(preparedTx);
}
const signedTx = await this._signTransaction(hre.ethers.Transaction.from(preparedTx));
return this.provider.broadcastTransaction(signedTx);
}
_determineSignerIdentifier(signerName) {
if (signerName) {
return signerName;
}
if (this._isCastEnabled()) {
return (this._config.castWallet.account || this._config.castWallet.keystore);
}
if (this._config.trezorWallet.enabled) {
return "trezor";
}
return this.ethersSigner.getAddress();
}
async _ensureInitialized() {
if (this._initialized)
return;
if (this._config.trezorWallet.enabled) {
await (0, trezor_integration_1.initTrezor)();
}
if (this._isCastEnabled()) {
await (0, cast_integration_1.getCastVersion)();
}
this._initialized = true;
}
async _prepareTrezorTransaction(tx) {
delete tx.maxFeePerBlobGas;
delete tx.maxFeePerGas;
delete tx.maxPriorityFeePerGas;
tx.type = 1;
tx.gasPrice = await this.provider.send("eth_gasPrice", []);
return tx;
}
async _signTransaction(tx) {
if (this._isCastEnabled()) {
return (0, cast_integration_1.getSignedTxViaCast)(tx, this._getCastOptions());
}
if (this._config.trezorWallet.enabled) {
const mnemonicIndex = this._config.trezorWallet.mnemonicIndex || 0;
return (0, trezor_integration_1.signWithTrezor)(tx, mnemonicIndex);
}
throw new errors_1.MigrateError("No valid signer configuration found to sign transaction");
}
_getCastOptions() {
const config = this._config.castWallet;
return {
keystore: config.keystore,
passwordFile: config.passwordFile,
account: config.account,
};
}
_isCastEnabled() {
return this._config.castWallet.account !== undefined || this._config.castWallet.keystore !== undefined;
}
}
exports.ExtendedHardhatEthersSigner = ExtendedHardhatEthersSigner;
//# sourceMappingURL=ExtendedHardhatEthersSigner.js.map