saepenatus
Version:
Web3-Onboard makes it simple to connect Ethereum hardware and software wallets to your dapp. Features standardised spec compliant web3 providers for all supported wallets, framework agnostic modern javascript UI with code splitting, CSS customization, mul
763 lines • 35 kB
JavaScript
"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 = {};
// Some nodes (INFURA ropsten; INFURA mainnet is fine) do not like leading zeros.
["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