Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
return this.send("eth_sendRawTransaction", [params.signedTransaction]).catch((error) => {
if (error.responseText) {
// "insufficient funds for gas * price + value"
if (error.responseText.indexOf("insufficient funds") > 0) {
logger.throwError("insufficient funds", Logger.errors.INSUFFICIENT_FUNDS, {});
}
// "nonce too low"
if (error.responseText.indexOf("nonce too low") > 0) {
logger.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {});
}
// "replacement transaction underpriced"
if (error.responseText.indexOf("replacement transaction underpriced") > 0) {
logger.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {});
}
}
throw error;
});
case "getBlock":
return __awaiter(this, void 0, void 0, function* () {
// Get the resolver from the blockchain
const network = yield this.getNetwork();
// No ENS...
if (!network.ensAddress) {
logger.throwError("network does not support ENS", Logger.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
}
// keccak256("resolver(bytes32)")
const transaction = {
to: network.ensAddress,
data: ("0x0178b8bf" + namehash(name).substring(2))
};
return this.formatter.callAddress(yield this.call(transaction));
});
}
import { Signer, VoidSigner } from "@ethersproject/abstract-signer";
import { Wallet } from "@ethersproject/wallet";
import * as constants from "@ethersproject/constants";
import * as providers from "@ethersproject/providers";
import { getDefaultProvider } from "@ethersproject/providers";
import { Wordlist, wordlists} from "@ethersproject/wordlists";
import * as utils from "./utils";
import { Logger } from "@ethersproject/logger";
const errors: { [ name: string ]: string } = Logger.errors;
////////////////////////
// Types
import { BigNumberish } from "@ethersproject/bignumber";
import { Bytes, BytesLike, Signature } from "@ethersproject/bytes";
import { Transaction, UnsignedTransaction } from "@ethersproject/transactions";
////////////////////////
// Compile-Time Constants
// This is generated by "npm run dist"
import { version } from "./_version";
const logger = new Logger(version);
function throwFault(message, fault, operation, value) {
const params = { fault: fault, operation: operation };
if (value !== undefined) {
params.value = value;
}
return logger.throwError(message, Logger.errors.NUMERIC_FAULT, params);
}
// Constant to pull zeros from for multipliers
if (!contract.provider && !contract.signer) {
logger.throwError("estimate require a provider or signer", Logger.errors.UNSUPPORTED_OPERATION, { operation: "estimateGas" });
}
return (contract.signer || contract.provider).estimateGas(tx);
}
if (tx.gasLimit == null && method.gas != null) {
tx.gasLimit = BigNumber.from(method.gas).add(21000);
}
if (tx.value != null && !method.payable) {
logger.throwArgumentError("contract method is not payable", "sendTransaction:" + method.format(), tx);
}
if (options.transaction) {
return resolveProperties(tx);
}
if (!contract.signer) {
logger.throwError("sending a transaction requires a signer", Logger.errors.UNSUPPORTED_OPERATION, { operation: "sendTransaction" });
}
return contract.signer.sendTransaction(tx).then((tx) => {
let wait = tx.wait.bind(tx);
tx.wait = (confirmations) => {
return wait(confirmations).then((receipt) => {
receipt.events = receipt.logs.map((log) => {
let event = deepCopy(log);
let parsed = contract.interface.parseLog(log);
if (parsed) {
event.values = parsed.values;
event.decode = (data, topics) => {
return this.interface.decodeEventLog(parsed.eventFragment, data, topics);
};
event.event = parsed.name;
event.eventSignature = parsed.signature;
}
decodeEventLog(eventFragment, data, topics) {
if (typeof (eventFragment) === "string") {
eventFragment = this.getEvent(eventFragment);
}
if (topics != null && !eventFragment.anonymous) {
let topicHash = this.getEventTopic(eventFragment);
if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== topicHash) {
logger.throwError("fragment/topic mismatch", Logger.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: topicHash, value: topics[0] });
}
topics = topics.slice(1);
}
let indexed = [];
let nonIndexed = [];
let dynamic = [];
eventFragment.inputs.forEach((param, index) => {
if (param.indexed) {
if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
indexed.push(ParamType.fromObject({ type: "bytes32", name: param.name }));
dynamic.push(true);
}
else {
indexed.push(param);
dynamic.push(false);
}
return this.provider.send("eth_accounts", []).then((accounts) => {
if (accounts.length <= this._index) {
logger.throwError("unknown account #" + this._index, Logger.errors.UNSUPPORTED_OPERATION, {
operation: "getAddress"
});
}
return this.provider.formatter.address(accounts[this._index]);
});
}
return (contract.signer || contract.provider).call(tx, blockTag).then((value) => {
try {
let result = contract.interface.decodeFunctionResult(method, value);
if (method.outputs.length === 1) {
result = result[0];
}
return result;
}
catch (error) {
if (error.code === Logger.errors.CALL_EXCEPTION) {
error.address = contract.address;
error.args = params;
error.transaction = tx;
}
throw error;
}
});
}
timer = setTimeout(() => {
if (timer == null) { return; }
timer = null;
reject(logger.makeError("timeout", Logger.errors.TIMEOUT, { timeout: timeout }));
}, timeout);
}
constructor(path: string, network?: Networkish) {
logger.checkNew(new.target, IpcProvider);
if (path == null) {
logger.throwError("missing path", Logger.errors.MISSING_ARGUMENT, { arg: "path" });
}
super("ipc://" + path, network);
defineReadOnly(this, "path", path);
}