"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonRpcProvider = exports.JsonRpcSigner = void 0;
var abstract_signer_1 = require("@ethersproject/abstract-signer");
var bignumber_1 = require("@ethersproject/bignumber");
var bytes_1 = require("@ethersproject/bytes");
var hash_1 = require("@ethersproject/hash");
var properties_1 = require("@ethersproject/properties");
var strings_1 = require("@ethersproject/strings");
var transactions_1 = require("@ethersproject/transactions");
var web_1 = require("@ethersproject/web");
var logger_1 = require("@ethersproject/logger");
var _version_1 = require("./_version");
var logger = new logger_1.Logger(_version_1.version);
var base_provider_1 = require("./base-provider");
var errorGas = ["call", "estimateGas"];
function checkError(method, error, params) {
// Undo the "convenience" some nodes are attempting to prevent backwards
// incompatibility; maybe for v6 consider forwarding reverts as errors
if (method === "call" && error.code === logger_1.Logger.errors.SERVER_ERROR) {
var e = error.error;
if (e && e.message.match("reverted") && (0, bytes_1.isHexString)(e.data)) {
return e.data;
}
logger.throwError("missing revert data in call exception", logger_1.Logger.errors.CALL_EXCEPTION, {
error: error,
data: "0x"
});
}
var message = error.message;
if (error.code === logger_1.Logger.errors.SERVER_ERROR && error.error && typeof (error.error.message) === "string") {
message = error.error.message;
}
else if (typeof (error.body) === "string") {
message = error.body;
}
else if (typeof (error.responseText) === "string") {
message = error.responseText;
}
message = (message || "").toLowerCase();
var transaction = params.transaction || params.signedTransaction;
// "insufficient funds for gas * price + value + cost(data)"
if (message.match(/insufficient funds|base fee exceeds gas limit/)) {
logger.throwError("insufficient funds for intrinsic transaction cost", logger_1.Logger.errors.INSUFFICIENT_FUNDS, {
error: error,
method: method,
transaction: transaction
});
}
// "nonce too low"
if (message.match(/nonce too low/)) {
logger.throwError("nonce has already been used", logger_1.Logger.errors.NONCE_EXPIRED, {
error: error,
method: method,
transaction: transaction
});
}
// "replacement transaction underpriced"
if (message.match(/replacement transaction underpriced/)) {
logger.throwError("replacement fee too low", logger_1.Logger.errors.REPLACEMENT_UNDERPRICED, {
error: error,
method: method,
transaction: transaction
});
}
// "replacement transaction underpriced"
if (message.match(/only replay-protected/)) {
logger.throwError("legacy pre-eip-155 transactions not supported", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
error: error,
method: method,
transaction: transaction
});
}
if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) {
logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", logger_1.Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
error: error,
method: method,
transaction: transaction
});
}
throw error;
}
function timer(timeout) {
return new Promise(function (resolve) {
setTimeout(resolve, timeout);
});
}
function getResult(payload) {
if (payload.error) {
// @TODO: not any
var error = new Error(payload.error.message);
error.code = payload.error.code;
error.data = payload.error.data;
throw error;
}
return payload.result;
}
function getLowerCase(value) {
if (value) {
return value.toLowerCase();
}
return value;
}
var _constructorGuard = {};
var JsonRpcSigner = /** @class */ (function (_super) {
__extends(JsonRpcSigner, _super);
function JsonRpcSigner(constructorGuard, provider, addressOrIndex) {
var _newTarget = this.constructor;
var _this = this;
logger.checkNew(_newTarget, JsonRpcSigner);
_this = _super.call(this) || this;
if (constructorGuard !== _constructorGuard) {
throw new Error("do not call the JsonRpcSigner constructor directly; use provider.getSigner");
}
(0, properties_1.defineReadOnly)(_this, "provider", provider);
if (addressOrIndex == null) {
addressOrIndex = 0;
}
if (typeof (addressOrIndex) === "string") {
(0, properties_1.defineReadOnly)(_this, "_address", _this.provider.formatter.address(addressOrIndex));
(0, properties_1.defineReadOnly)(_this, "_index", null);
}
else if (typeof (addressOrIndex) === "number") {
(0, properties_1.defineReadOnly)(_this, "_index", addressOrIndex);
(0, properties_1.defineReadOnly)(_this, "_address", null);
}
else {
logger.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
}
return _this;
}
JsonRpcSigner.prototype.connect = function (provider) {
return logger.throwError("cannot alter JSON-RPC Signer connection", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
operation: "connect"
});
};
JsonRpcSigner.prototype.connectUnchecked = function () {
return new UncheckedJsonRpcSigner(_constructorGuard, this.provider, this._address || this._index);
};
JsonRpcSigner.prototype.getAddress = function () {
var _this = this;
if (this._address) {
return Promise.resolve(this._address);
}
return this.provider.send("eth_accounts", []).then(function (accounts) {
if (accounts.length <= _this._index) {
logger.throwError("unknown account #" + _this._index, logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
operation: "getAddress"
});
}
return _this.provider.formatter.address(accounts[_this._index]);
});
};
JsonRpcSigner.prototype.sendUncheckedTransaction = function (transaction) {
var _this = this;
transaction = (0, properties_1.shallowCopy)(transaction);
var fromAddress = this.getAddress().then(function (address) {
if (address) {
address = address.toLowerCase();
}
return address;
});
// The JSON-RPC for eth_sendTransaction uses 90000 gas; if the user
// wishes to use this, it is easy to specify explicitly, otherwise
// we look it up for them.
if (transaction.gasLimit == null) {
var estimate = (0, properties_1.shallowCopy)(transaction);
estimate.from = fromAddress;
transaction.gasLimit = this.provider.estimateGas(estimate);
}
if (transaction.to != null) {
transaction.to = Promise.resolve(transaction.to).then(function (to) { return __awaiter(_this, void 0, void 0, function () {
var address;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (to == null) {
return [2 /*return*/, null];
}
return [4 /*yield*/, this.provider.resolveName(to)];
case 1:
address = _a.sent();
if (address == null) {
logger.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
}
return [2 /*return*/, address];
}
});
}); });
}
return (0, properties_1.resolveProperties)({
tx: (0, properties_1.resolveProperties)(transaction),
sender: fromAddress
}).then(function (_a) {
var tx = _a.tx, sender = _a.sender;
if (tx.from != null) {
if (tx.from.toLowerCase() !== sender) {
logger.throwArgumentError("from address mismatch", "transaction", transaction);
}
}
else {
tx.from = sender;
}
var hexTx = _this.provider.constructor.hexlifyTransaction(tx, { from: true });
return _this.provider.send("eth_sendTransaction", [hexTx]).then(function (hash) {
return hash;
}, function (error) {
return checkError("sendTransaction", error, hexTx);
});
});
};
JsonRpcSigner.prototype.signTransaction = function (transaction) {
return logger.throwError("signing transactions is unsupported", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
operation: "signTransaction"
});
};
JsonRpcSigner.prototype.sendTransaction = function (transaction) {
return __awaiter(this, void 0, void 0, function () {
var blockNumber, hash, error_1;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.provider._getInternalBlockNumber(100 + 2 * this.provider.pollingInterval)];
case 1:
blockNumber = _a.sent();
return [4 /*yield*/, this.sendUncheckedTransaction(transaction)];
case 2:
hash = _a.sent();
_a.label = 3;
case 3:
_a.trys.push([3, 5, , 6]);
return [4 /*yield*/, (0, web_1.poll)(function () { return __awaiter(_this, void 0, void 0, function () {
var tx;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.provider.getTransaction(hash)];
case 1:
tx = _a.sent();
if (tx === null) {
return [2 /*return*/, undefined];
}
return [2 /*return*/, this.provider._wrapTransaction(tx, hash, blockNumber)];
}
});
}); }, { oncePoll: this.provider })];
case 4:
// Unfortunately, JSON-RPC only provides and opaque transaction hash
// for a response, and we need the actual transaction, so we poll
// for it; it should show up very quickly
return [2 /*return*/, _a.sent()];
case 5:
error_1 = _a.sent();
error_1.transactionHash = hash;
throw error_1;
case 6: return [2 /*return*/];
}
});
});
};
JsonRpcSigner.prototype.signMessage = function (message) {
return __awaiter(this, void 0, void 0, function () {
var data, address;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
data = ((typeof (message) === "string") ? (0, strings_1.toUtf8Bytes)(message) : message);
return [4 /*yield*/, this.getAddress()];
case 1:
address = _a.sent();
return [4 /*yield*/, this.provider.send("personal_sign", [(0, bytes_1.hexlify)(data), address.toLowerCase()])];
case 2: return [2 /*return*/, _a.sent()];
}
});
});
};
JsonRpcSigner.prototype._legacySignMessage = function (message) {
return __awaiter(this, void 0, void 0, function () {
var data, address;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
data = ((typeof (message) === "string") ? (0, strings_1.toUtf8Bytes)(message) : message);
return [4 /*yield*/, this.getAddress()];
case 1:
address = _a.sent();
return [4 /*yield*/, this.provider.send("eth_sign", [address.toLowerCase(), (0, bytes_1.hexlify)(data)])];
case 2:
// https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign
return [2 /*return*/, _a.sent()];
}
});
});
};
JsonRpcSigner.prototype._signTypedData = function (domain, types, value) {
return __awaiter(this, void 0, void 0, function () {
var populated, address;
var _this = this;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, hash_1._TypedDataEncoder.resolveNames(domain, types, value, function (name) {
return _this.provider.resolveName(name);
})];
case 1:
populated = _a.sent();
return [4 /*yield*/, this.getAddress()];
case 2:
address = _a.sent();
return [4 /*yield*/, this.provider.send("eth_signTypedData_v4", [
address.toLowerCase(),
JSON.stringify(hash_1._TypedDataEncoder.getPayload(populated.domain, types, populated.value))
])];
case 3: return [2 /*return*/, _a.sent()];
}
});
});
};
JsonRpcSigner.prototype.unlock = function (password) {
return __awaiter(this, void 0, void 0, function () {
var provider, address;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
provider = this.provider;
return [4 /*yield*/, this.getAddress()];
case 1:
address = _a.sent();
return [2 /*return*/, provider.send("personal_unlockAccount", [address.toLowerCase(), password, null])];
}
});
});
};
return JsonRpcSigner;
}(abstract_signer_1.Signer));
exports.JsonRpcSigner = JsonRpcSigner;
var UncheckedJsonRpcSigner = /** @class */ (function (_super) {
__extends(UncheckedJsonRpcSigner, _super);
function UncheckedJsonRpcSigner() {
return _super !== null && _super.apply(this, arguments) || this;
}
UncheckedJsonRpcSigner.prototype.sendTransaction = function (transaction) {
var _this = this;
return this.sendUncheckedTransaction(transaction).then(function (hash) {
return {
hash: hash,
nonce: null,
gasLimit: null,
gasPrice: null,
data: null,
value: null,
chainId: null,
confirmations: 0,
from: null,
wait: function (confirmations) { return _this.provider.waitForTransaction(hash, confirmations); }
};
});
};
return UncheckedJsonRpcSigner;
}(JsonRpcSigner));
var allowedTransactionKeys = {
chainId: true, data: true, gasLimit: true, gasPrice: true, nonce: true, to: true, value: true,
type: true, accessList: true,
maxFeePerGas: true, maxPriorityFeePerGas: true
};
var JsonRpcProvider = /** @class */ (function (_super) {
__extends(JsonRpcProvider, _super);
function JsonRpcProvider(url, network) {
var _newTarget = this.constructor;
var _this = this;
logger.checkNew(_newTarget, JsonRpcProvider);
var networkOrReady = network;
// The network is unknown, query the JSON-RPC for it
if (networkOrReady == null) {
networkOrReady = new Promise(function (resolve, reject) {
setTimeout(function () {
_this.detectNetwork().then(function (network) {
resolve(network);
}, function (error) {
reject(error);
});
}, 0);
});
}
_this = _super.call(this, networkOrReady) || this;
// Default URL
if (!url) {
url = (0, properties_1.getStatic)(_this.constructor, "defaultUrl")();
}
if (typeof (url) === "string") {
(0, properties_1.defineReadOnly)(_this, "connection", Object.freeze({
url: url
}));
}
else {
(0, properties_1.defineReadOnly)(_this, "connection", Object.freeze((0, properties_1.shallowCopy)(url)));
}
_this._nextId = 42;
return _this;
}
Object.defineProperty(JsonRpcProvider.prototype, "_cache", {
get: function () {
if (this._eventLoopCache == null) {
this._eventLoopCache = {};
}
return this._eventLoopCache;
},
enumerable: false,
configurable: true
});
JsonRpcProvider.defaultUrl = function () {
return "http:/\/localhost:8545";
};
JsonRpcProvider.prototype.detectNetwork = function () {
var _this = this;
if (!this._cache["detectNetwork"]) {
this._cache["detectNetwork"] = this._uncachedDetectNetwork();
// Clear this cache at the beginning of the next event loop
setTimeout(function () {
_this._cache["detectNetwork"] = null;
}, 0);
}
return this._cache["detectNetwork"];
};
JsonRpcProvider.prototype._uncachedDetectNetwork = function () {
return __awaiter(this, void 0, void 0, function () {
var chainId, error_2, error_3, getNetwork;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, timer(0)];
case 1:
_a.sent();
chainId = null;
_a.label = 2;
case 2:
_a.trys.push([2, 4, , 9]);
return [4 /*yield*/, this.send("eth_chainId", [])];
case 3:
chainId = _a.sent();
return [3 /*break*/, 9];
case 4:
error_2 = _a.sent();
_a.label = 5;
case 5:
_a.trys.push([5, 7, , 8]);
return [4 /*yield*/, this.send("net_version", [])];
case 6:
chainId = _a.sent();
return [3 /*break*/, 8];
case 7:
error_3 = _a.sent();
return [3 /*break*/, 8];
case 8: return [3 /*break*/, 9];
case 9:
if (chainId != null) {
getNetwork = (0, properties_1.getStatic)(this.constructor, "getNetwork");
try {
return [2 /*return*/, getNetwork(bignumber_1.BigNumber.from(chainId).toNumber())];
}
catch (error) {
return [2 /*return*/, logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
chainId: chainId,
event: "invalidNetwork",
serverError: error
})];
}
}
return [2 /*return*/, logger.throwError("could not detect network", logger_1.Logger.errors.NETWORK_ERROR, {
event: "noNetwork"
})];
}
});
});
};
JsonRpcProvider.prototype.getSigner = function (addressOrIndex) {
return new JsonRpcSigner(_constructorGuard, this, addressOrIndex);
};
JsonRpcProvider.prototype.getUncheckedSigner = function (addressOrIndex) {
return this.getSigner(addressOrIndex).connectUnchecked();
};
JsonRpcProvider.prototype.listAccounts = function () {
var _this = this;
return this.send("eth_accounts", []).then(function (accounts) {
return accounts.map(function (a) { return _this.formatter.address(a); });
});
};
JsonRpcProvider.prototype.send = function (method, params) {
var _this = this;
var request = {
method: method,
params: params,
id: (this._nextId++),
jsonrpc: "2.0"
};
this.emit("debug", {
action: "request",
request: (0, properties_1.deepCopy)(request),
provider: this
});
// We can expand this in the future to any call, but for now these
// are the biggest wins and do not require any serializing parameters.
var cache = (["eth_chainId", "eth_blockNumber"].indexOf(method) >= 0);
if (cache && this._cache[method]) {
return this._cache[method];
}
var result = (0, web_1.fetchJson)(this.connection, JSON.stringify(request), getResult).then(function (result) {
_this.emit("debug", {
action: "response",
request: request,
response: result,
provider: _this
});
return result;
}, function (error) {
_this.emit("debug", {
action: "response",
error: error,
request: request,
provider: _this
});
throw error;
});
// Cache the fetch, but clear it on the next event loop
if (cache) {
this._cache[method] = result;
setTimeout(function () {
_this._cache[method] = null;
}, 0);
}
return result;
};
JsonRpcProvider.prototype.prepareRequest = function (method, params) {
switch (method) {
case "getBlockNumber":
return ["eth_blockNumber", []];
case "getGasPrice":
return ["eth_gasPrice", []];
case "getBalance":
return ["eth_getBalance", [getLowerCase(params.address), params.blockTag]];
case "getTransactionCount":
return ["eth_getTransactionCount", [getLowerCase(params.address), params.blockTag]];
case "getCode":
return ["eth_getCode", [getLowerCase(params.address), params.blockTag]];
case "getStorageAt":
return ["eth_getStorageAt", [getLowerCase(params.address), params.position, params.blockTag]];
case "sendTransaction":
return ["eth_sendRawTransaction", [params.signedTransaction]];
case "getBlock":
if (params.blockTag) {
return ["eth_getBlockByNumber", [params.blockTag, !!params.includeTransactions]];
}
else if (params.blockHash) {
return ["eth_getBlockByHash", [params.blockHash, !!params.includeTransactions]];
}
return null;
case "getTransaction":
return ["eth_getTransactionByHash", [params.transactionHash]];
case "getTransactionReceipt":
return ["eth_getTransactionReceipt", [params.transactionHash]];
case "call": {
var hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
return ["eth_call", [hexlifyTransaction(params.transaction, { from: true }), params.blockTag]];
}
case "estimateGas": {
var hexlifyTransaction = (0, properties_1.getStatic)(this.constructor, "hexlifyTransaction");
return ["eth_estimateGas", [hexlifyTransaction(params.transaction, { from: true })]];
}
case "getLogs":
if (params.filter && params.filter.address != null) {
params.filter.address = getLowerCase(params.filter.address);
}
return ["eth_getLogs", [params.filter]];
default:
break;
}
return null;
};
JsonRpcProvider.prototype.perform = function (method, params) {
return __awaiter(this, void 0, void 0, function () {
var tx, feeData, args, error_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!(method === "call" || method === "estimateGas")) return [3 /*break*/, 2];
tx = params.transaction;
if (!(tx && tx.type != null && bignumber_1.BigNumber.from(tx.type).isZero())) return [3 /*break*/, 2];
if (!(tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null)) return [3 /*break*/, 2];
return [4 /*yield*/, this.getFeeData()];
case 1:
feeData = _a.sent();
if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) {
// Network doesn't know about EIP-1559 (and hence type)
params = (0, properties_1.shallowCopy)(params);
params.transaction = (0, properties_1.shallowCopy)(tx);
delete params.transaction.type;
}
_a.label = 2;
case 2:
args = this.prepareRequest(method, params);
if (args == null) {
logger.throwError(method + " not implemented", logger_1.Logger.errors.NOT_IMPLEMENTED, { operation: method });
}
_a.label = 3;
case 3:
_a.trys.push([3, 5, , 6]);
return [4 /*yield*/, this.send(args[0], args[1])];
case 4: return [2 /*return*/, _a.sent()];
case 5:
error_4 = _a.sent();
return [2 /*return*/, checkError(method, error_4, params)];
case 6: return [2 /*return*/];
}
});
});
};
JsonRpcProvider.prototype._startEvent = function (event) {
if (event.tag === "pending") {
this._startPending();
}
_super.prototype._startEvent.call(this, event);
};
JsonRpcProvider.prototype._startPending = function () {
if (this._pendingFilter != null) {
return;
}
var self = this;
var pendingFilter = this.send("eth_newPendingTransactionFilter", []);
this._pendingFilter = pendingFilter;
pendingFilter.then(function (filterId) {
function poll() {
self.send("eth_getFilterChanges", [filterId]).then(function (hashes) {
if (self._pendingFilter != pendingFilter) {
return null;
}
var seq = Promise.resolve();
hashes.forEach(function (hash) {
// @TODO: This should be garbage collected at some point... How? When?
self._emitted["t:" + hash.toLowerCase()] = "pending";
seq = seq.then(function () {
return self.getTransaction(hash).then(function (tx) {
self.emit("pending", tx);
return null;
});
});
});
return seq.then(function () {
return timer(1000);
});
}).then(function () {
if (self._pendingFilter != pendingFilter) {
self.send("eth_uninstallFilter", [filterId]);
return;
}
setTimeout(function () { poll(); }, 0);
return null;
}).catch(function (error) { });
}
poll();
return filterId;
}).catch(function (error) { });
};
JsonRpcProvider.prototype._stopEvent = function (event) {
if (event.tag === "pending" && this.listenerCount("pending") === 0) {
this._pendingFilter = null;
}
_super.prototype._stopEvent.call(this, event);
};
// Convert an ethers.js transaction into a JSON-RPC transaction
// - gasLimit => gas
// - All values hexlified
// - All numeric values zero-striped
// - All addresses are lowercased
// NOTE: This allows a TransactionRequest, but all values should be resolved
// before this is called
// @TODO: This will likely be removed in future versions and prepareRequest
// will be the preferred method for this.
JsonRpcProvider.hexlifyTransaction = function (transaction, allowExtra) {
// Check only allowed properties are given
var allowed = (0, properties_1.shallowCopy)(allowedTransactionKeys);
if (allowExtra) {
for (var key in allowExtra) {
if (allowExtra[key]) {
allowed[key] = true;
}
}
}
(0, properties_1.checkProperties)(transaction, allowed);
var result = {};
// JSON-RPC now requires numeric values to be "quantity" values
["chainId", "gasLimit", "gasPrice", "type", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "value"].forEach(function (key) {
if (transaction[key] == null) {
return;
}
var value = (0, bytes_1.hexValue)(transaction[key]);
if (key === "gasLimit") {
key = "gas";
}
result[key] = value;
});
["from", "to", "data"].forEach(function (key) {
if (transaction[key] == null) {
return;
}
result[key] = (0, bytes_1.hexlify)(transaction[key]);
});
if (transaction.accessList) {
result["accessList"] = (0, transactions_1.accessListify)(transaction.accessList);
}
return result;
};
return JsonRpcProvider;
}(base_provider_1.BaseProvider));
exports.JsonRpcProvider = JsonRpcProvider;
//# sourceMappingURL=json-rpc-provider.js.map