983 lines
35 KiB
TypeScript
983 lines
35 KiB
TypeScript
|
"use strict";
|
||
|
|
|
||
|
|
import {
|
||
|
|
Block, BlockTag, BlockWithTransactions, EventType, Filter, FilterByBlockHash, ForkEvent,
|
||
|
|
Listener, Log, Provider, TransactionReceipt, TransactionRequest, TransactionResponse
|
||
|
|
} from "@ethersproject/abstract-provider";
|
||
|
|
import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
|
||
|
|
import { arrayify, hexDataLength, hexlify, hexValue, isHexString } from "@ethersproject/bytes";
|
||
|
|
import * as errors from "@ethersproject/errors";
|
||
|
|
import { namehash } from "@ethersproject/hash";
|
||
|
|
import { getNetwork, Network, Networkish } from "@ethersproject/networks";
|
||
|
|
import { defineReadOnly, isNamedInstance, resolveProperties } from "@ethersproject/properties";
|
||
|
|
import { Transaction } from "@ethersproject/transactions";
|
||
|
|
import { toUtf8String } from "@ethersproject/strings";
|
||
|
|
import { poll } from "@ethersproject/web";
|
||
|
|
|
||
|
|
import { Formatter } from "./formatter";
|
||
|
|
|
||
|
|
|
||
|
|
//////////////////////////////
|
||
|
|
// Event Serializeing
|
||
|
|
|
||
|
|
function checkTopic(topic: string): string {
|
||
|
|
if (topic == null) { return "null"; }
|
||
|
|
if (hexDataLength(topic) !== 32) {
|
||
|
|
errors.throwArgumentError("invalid topic", "topic", topic);
|
||
|
|
}
|
||
|
|
return topic.toLowerCase();
|
||
|
|
}
|
||
|
|
|
||
|
|
function serializeTopics(topics: Array<string | Array<string>>): string {
|
||
|
|
|
||
|
|
// Remove trailing null AND-topics; they are redundant
|
||
|
|
topics = topics.slice();
|
||
|
|
while (topics[topics.length - 1] == null) { topics.pop(); }
|
||
|
|
|
||
|
|
return topics.map((topic) => {
|
||
|
|
if (Array.isArray(topic)) {
|
||
|
|
|
||
|
|
// Only track unique OR-topics
|
||
|
|
let unique: { [ topic: string ]: boolean } = { }
|
||
|
|
topic.forEach((topic) => {
|
||
|
|
unique[checkTopic(topic)] = true;
|
||
|
|
});
|
||
|
|
|
||
|
|
// The order of OR-topics does not matter
|
||
|
|
let sorted = Object.keys(unique);
|
||
|
|
sorted.sort();
|
||
|
|
|
||
|
|
return sorted.join("|");
|
||
|
|
} else {
|
||
|
|
return checkTopic(topic);
|
||
|
|
}
|
||
|
|
}).join("&");
|
||
|
|
}
|
||
|
|
|
||
|
|
function deserializeTopics(data: string): Array<string | Array<string>> {
|
||
|
|
return data.split(/&/g).map((topic) => {
|
||
|
|
return topic.split("|").map((topic) => {
|
||
|
|
return ((topic === "null") ? null: topic);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
function getEventTag(eventName: EventType): string {
|
||
|
|
if (typeof(eventName) === "string") {
|
||
|
|
eventName = eventName.toLowerCase();
|
||
|
|
|
||
|
|
if (hexDataLength(eventName) === 32) {
|
||
|
|
return "tx:" + eventName;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (eventName.indexOf(":") === -1) {
|
||
|
|
return eventName;
|
||
|
|
}
|
||
|
|
|
||
|
|
} else if (Array.isArray(eventName)) {
|
||
|
|
return "filter:*:" + serializeTopics(eventName);
|
||
|
|
|
||
|
|
} else if (isNamedInstance<ForkEvent>(ForkEvent, eventName)) {
|
||
|
|
errors.warn("not implemented");
|
||
|
|
throw new Error("not implemented");
|
||
|
|
|
||
|
|
} else if (eventName && typeof(eventName) === "object") {
|
||
|
|
return "filter:" + (eventName.address || "*") + ":" + serializeTopics(eventName.topics || []);
|
||
|
|
}
|
||
|
|
|
||
|
|
throw new Error("invalid event - " + eventName);
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////
|
||
|
|
// Helper Object
|
||
|
|
|
||
|
|
function getTime() {
|
||
|
|
return (new Date()).getTime();
|
||
|
|
}
|
||
|
|
|
||
|
|
//////////////////////////////
|
||
|
|
// Provider Object
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* EventType
|
||
|
|
* - "block"
|
||
|
|
* - "pending"
|
||
|
|
* - "error"
|
||
|
|
* - filter
|
||
|
|
* - topics array
|
||
|
|
* - transaction hash
|
||
|
|
*/
|
||
|
|
|
||
|
|
class Event {
|
||
|
|
readonly listener: Listener;
|
||
|
|
readonly once: boolean;
|
||
|
|
readonly tag: string;
|
||
|
|
|
||
|
|
constructor(tag: string, listener: Listener, once: boolean) {
|
||
|
|
defineReadOnly(this, "tag", tag);
|
||
|
|
defineReadOnly(this, "listener", listener);
|
||
|
|
defineReadOnly(this, "once", once);
|
||
|
|
}
|
||
|
|
|
||
|
|
pollable(): boolean {
|
||
|
|
return (this.tag.indexOf(":") >= 0 || this.tag === "block" || this.tag === "pending");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
let defaultFormatter: Formatter = null;
|
||
|
|
|
||
|
|
let nextPollId = 1;
|
||
|
|
|
||
|
|
export class BaseProvider extends Provider {
|
||
|
|
_network: Network;
|
||
|
|
|
||
|
|
_events: Array<Event>;
|
||
|
|
|
||
|
|
formatter: Formatter;
|
||
|
|
|
||
|
|
// To help mitigate the eventually conssitent nature of the blockchain
|
||
|
|
// we keep a mapping of events we emit. If we emit an event X, we expect
|
||
|
|
// that a user should be able to query for that event in the callback,
|
||
|
|
// if the node returns null, we stall the response until we get back a
|
||
|
|
// meaningful value, since we may be hitting a re-org, or a node that
|
||
|
|
// has not indexed the event yet.
|
||
|
|
// Events:
|
||
|
|
// - t:{hash} - Transaction hash
|
||
|
|
// - b:{hash} - BlockHash
|
||
|
|
// - block - The most recent emitted block
|
||
|
|
_emitted: { [ eventName: string ]: number | "pending" };
|
||
|
|
|
||
|
|
_pollingInterval: number;
|
||
|
|
_poller: any; // @TODO: what does TypeScript think setInterval returns?
|
||
|
|
|
||
|
|
_lastBlockNumber: number;
|
||
|
|
|
||
|
|
_fastBlockNumber: number;
|
||
|
|
_fastBlockNumberPromise: Promise<number>;
|
||
|
|
_fastQueryDate: number;
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* ready
|
||
|
|
*
|
||
|
|
* A Promise<Network> that resolves only once the provider is ready.
|
||
|
|
*
|
||
|
|
* Sub-classes that call the super with a network without a chainId
|
||
|
|
* MUST set this. Standard named networks have a known chainId.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
ready: Promise<Network>;
|
||
|
|
|
||
|
|
constructor(network: Networkish | Promise<Network>) {
|
||
|
|
errors.checkNew(new.target, Provider);
|
||
|
|
|
||
|
|
super();
|
||
|
|
|
||
|
|
this.formatter = new.target.getFormatter();
|
||
|
|
|
||
|
|
if (network instanceof Promise) {
|
||
|
|
defineReadOnly(this, "ready", network.then((network) => {
|
||
|
|
defineReadOnly(this, "_network", network);
|
||
|
|
return network;
|
||
|
|
}));
|
||
|
|
|
||
|
|
// Squash any "unhandled promise" errors; that do not need to be handled
|
||
|
|
this.ready.catch((error) => { });
|
||
|
|
|
||
|
|
} else {
|
||
|
|
let knownNetwork = getNetwork((network == null) ? "homestead": network);
|
||
|
|
if (knownNetwork) {
|
||
|
|
defineReadOnly(this, "_network", knownNetwork);
|
||
|
|
defineReadOnly(this, "ready", Promise.resolve(this._network));
|
||
|
|
|
||
|
|
} else {
|
||
|
|
errors.throwError("invalid network", errors.INVALID_ARGUMENT, { arg: "network", value: network });
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
this._lastBlockNumber = -2;
|
||
|
|
|
||
|
|
// Events being listened to
|
||
|
|
this._events = [];
|
||
|
|
|
||
|
|
this._pollingInterval = 4000;
|
||
|
|
|
||
|
|
this._emitted = { block: -2 };
|
||
|
|
|
||
|
|
this._fastQueryDate = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static getFormatter(): Formatter {
|
||
|
|
if (defaultFormatter == null) {
|
||
|
|
defaultFormatter = new Formatter();
|
||
|
|
}
|
||
|
|
return defaultFormatter;
|
||
|
|
}
|
||
|
|
|
||
|
|
poll(): void {
|
||
|
|
let pollId = nextPollId++;
|
||
|
|
this.emit("willPoll", pollId);
|
||
|
|
|
||
|
|
// Track all running promises, so we can trigger a post-poll once they are complete
|
||
|
|
let runners: Array<Promise<void>> = [];
|
||
|
|
|
||
|
|
this.getBlockNumber().then((blockNumber) => {
|
||
|
|
this._setFastBlockNumber(blockNumber);
|
||
|
|
|
||
|
|
// If the block has not changed, meh.
|
||
|
|
if (blockNumber === this._lastBlockNumber) { return; }
|
||
|
|
|
||
|
|
// First polling cycle, trigger a "block" events
|
||
|
|
if (this._emitted.block === -2) {
|
||
|
|
this._emitted.block = blockNumber - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Notify all listener for each block that has passed
|
||
|
|
for (let i = (<number>this._emitted.block) + 1; i <= blockNumber; i++) {
|
||
|
|
this.emit("block", i);
|
||
|
|
}
|
||
|
|
|
||
|
|
// The emitted block was updated, check for obsolete events
|
||
|
|
if ((<number>this._emitted.block) !== blockNumber) {
|
||
|
|
this._emitted.block = blockNumber;
|
||
|
|
|
||
|
|
Object.keys(this._emitted).forEach((key) => {
|
||
|
|
// The block event does not expire
|
||
|
|
if (key === "block") { return; }
|
||
|
|
|
||
|
|
// The block we were at when we emitted this event
|
||
|
|
let eventBlockNumber = this._emitted[key];
|
||
|
|
|
||
|
|
// We cannot garbage collect pending transactions or blocks here
|
||
|
|
// They should be garbage collected by the Provider when setting
|
||
|
|
// "pending" events
|
||
|
|
if (eventBlockNumber === "pending") { return; }
|
||
|
|
|
||
|
|
// Evict any transaction hashes or block hashes over 12 blocks
|
||
|
|
// old, since they should not return null anyways
|
||
|
|
if (blockNumber - eventBlockNumber > 12) {
|
||
|
|
delete this._emitted[key];
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// First polling cycle
|
||
|
|
if (this._lastBlockNumber === -2) {
|
||
|
|
this._lastBlockNumber = blockNumber - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Find all transaction hashes we are waiting on
|
||
|
|
this._events.forEach((event) => {
|
||
|
|
let comps = event.tag.split(":");
|
||
|
|
switch (comps[0]) {
|
||
|
|
case "tx": {
|
||
|
|
let hash = comps[1];
|
||
|
|
let runner = this.getTransactionReceipt(hash).then((receipt) => {
|
||
|
|
if (!receipt || receipt.blockNumber == null) { return null; }
|
||
|
|
this._emitted["t:" + hash] = receipt.blockNumber;
|
||
|
|
this.emit(hash, receipt);
|
||
|
|
return null;
|
||
|
|
}).catch((error: Error) => { this.emit("error", error); });
|
||
|
|
|
||
|
|
runners.push(runner);
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case "filter": {
|
||
|
|
let topics = deserializeTopics(comps[2]);
|
||
|
|
let filter = {
|
||
|
|
address: comps[1],
|
||
|
|
fromBlock: this._lastBlockNumber + 1,
|
||
|
|
toBlock: blockNumber,
|
||
|
|
topics: topics
|
||
|
|
}
|
||
|
|
if (!filter.address) { delete filter.address; }
|
||
|
|
let runner = this.getLogs(filter).then((logs) => {
|
||
|
|
if (logs.length === 0) { return; }
|
||
|
|
logs.forEach((log: Log) => {
|
||
|
|
this._emitted["b:" + log.blockHash] = log.blockNumber;
|
||
|
|
this._emitted["t:" + log.transactionHash] = log.blockNumber;
|
||
|
|
this.emit(filter, log);
|
||
|
|
});
|
||
|
|
return null;
|
||
|
|
}).catch((error: Error) => { this.emit("error", error); });
|
||
|
|
|
||
|
|
runners.push(runner);
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
this._lastBlockNumber = blockNumber;
|
||
|
|
|
||
|
|
return null;
|
||
|
|
}).catch((error: Error) => { });
|
||
|
|
|
||
|
|
Promise.all(runners).then(() => {
|
||
|
|
this.emit("didPoll", pollId);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
resetEventsBlock(blockNumber: number): void {
|
||
|
|
this._lastBlockNumber = blockNumber - 1;
|
||
|
|
if (this.polling) { this.poll(); }
|
||
|
|
}
|
||
|
|
|
||
|
|
get network(): Network {
|
||
|
|
return this._network;
|
||
|
|
}
|
||
|
|
|
||
|
|
getNetwork(): Promise<Network> {
|
||
|
|
return this.ready;
|
||
|
|
}
|
||
|
|
|
||
|
|
get blockNumber(): number {
|
||
|
|
return this._fastBlockNumber;
|
||
|
|
}
|
||
|
|
|
||
|
|
get polling(): boolean {
|
||
|
|
return (this._poller != null);
|
||
|
|
}
|
||
|
|
|
||
|
|
set polling(value: boolean) {
|
||
|
|
setTimeout(() => {
|
||
|
|
if (value && !this._poller) {
|
||
|
|
this._poller = setInterval(this.poll.bind(this), this.pollingInterval);
|
||
|
|
|
||
|
|
} else if (!value && this._poller) {
|
||
|
|
clearInterval(this._poller);
|
||
|
|
this._poller = null;
|
||
|
|
}
|
||
|
|
}, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
get pollingInterval(): number {
|
||
|
|
return this._pollingInterval;
|
||
|
|
}
|
||
|
|
|
||
|
|
set pollingInterval(value: number) {
|
||
|
|
if (typeof(value) !== "number" || value <= 0 || parseInt(String(value)) != value) {
|
||
|
|
throw new Error("invalid polling interval");
|
||
|
|
}
|
||
|
|
|
||
|
|
this._pollingInterval = value;
|
||
|
|
|
||
|
|
if (this._poller) {
|
||
|
|
clearInterval(this._poller);
|
||
|
|
this._poller = setInterval(() => { this.poll() }, this._pollingInterval);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
_getFastBlockNumber(): Promise<number> {
|
||
|
|
let now = getTime();
|
||
|
|
|
||
|
|
// Stale block number, request a newer value
|
||
|
|
if ((now - this._fastQueryDate) > 2 * this._pollingInterval) {
|
||
|
|
this._fastQueryDate = now;
|
||
|
|
this._fastBlockNumberPromise = this.getBlockNumber().then((blockNumber) => {
|
||
|
|
if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
|
||
|
|
this._fastBlockNumber = blockNumber;
|
||
|
|
}
|
||
|
|
return this._fastBlockNumber;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._fastBlockNumberPromise;
|
||
|
|
}
|
||
|
|
|
||
|
|
_setFastBlockNumber(blockNumber: number): void {
|
||
|
|
// Older block, maybe a stale request
|
||
|
|
if (this._fastBlockNumber != null && blockNumber < this._fastBlockNumber) { return; }
|
||
|
|
|
||
|
|
// Update the time we updated the blocknumber
|
||
|
|
this._fastQueryDate = getTime();
|
||
|
|
|
||
|
|
// Newer block number, use it
|
||
|
|
if (this._fastBlockNumber == null || blockNumber > this._fastBlockNumber) {
|
||
|
|
this._fastBlockNumber = blockNumber;
|
||
|
|
this._fastBlockNumberPromise = Promise.resolve(blockNumber);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// @TODO: Add .poller which must be an event emitter with a 'start', 'stop' and 'block' event;
|
||
|
|
// this will be used once we move to the WebSocket or other alternatives to polling
|
||
|
|
|
||
|
|
waitForTransaction(transactionHash: string, confirmations?: number): Promise<TransactionReceipt> {
|
||
|
|
if (confirmations == null) { confirmations = 1; }
|
||
|
|
|
||
|
|
if (confirmations === 0) {
|
||
|
|
return this.getTransactionReceipt(transactionHash);
|
||
|
|
}
|
||
|
|
|
||
|
|
return new Promise((resolve) => {
|
||
|
|
let handler = (receipt: TransactionReceipt) => {
|
||
|
|
if (receipt.confirmations < confirmations) { return; }
|
||
|
|
this.removeListener(transactionHash, handler);
|
||
|
|
resolve(receipt);
|
||
|
|
}
|
||
|
|
this.on(transactionHash, handler);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
_runPerform(method: string, params: { [ key: string ]: () => any }): Promise<any> {
|
||
|
|
return this.ready.then(() => {
|
||
|
|
// Execute all the functions now that we are "ready"
|
||
|
|
Object.keys(params).forEach((key) => {
|
||
|
|
params[key] = params[key]();
|
||
|
|
});
|
||
|
|
return resolveProperties(params).then((params) => {
|
||
|
|
return this.perform(method, params);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getBlockNumber(): Promise<number> {
|
||
|
|
return this._runPerform("getBlockNumber", { }).then((result) => {
|
||
|
|
let value = parseInt(result);
|
||
|
|
if (value != result) { throw new Error("invalid response - getBlockNumber"); }
|
||
|
|
this._setFastBlockNumber(value);
|
||
|
|
return value;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getGasPrice(): Promise<BigNumber> {
|
||
|
|
return this._runPerform("getGasPrice", { }).then((result) => {
|
||
|
|
return BigNumber.from(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber> {
|
||
|
|
return this._runPerform("getBalance", {
|
||
|
|
address: () => this.resolveName(addressOrName),
|
||
|
|
blockTag: () => this._getBlockTag(blockTag)
|
||
|
|
}).then((result) => {
|
||
|
|
return BigNumber.from(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number> {
|
||
|
|
return this._runPerform("getTransactionCount", {
|
||
|
|
address: () => this.resolveName(addressOrName),
|
||
|
|
blockTag: () => this._getBlockTag(blockTag)
|
||
|
|
}).then((result) => {
|
||
|
|
return BigNumber.from(result).toNumber();
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string> {
|
||
|
|
return this._runPerform("getCode", {
|
||
|
|
address: () => this.resolveName(addressOrName),
|
||
|
|
blockTag: () => this._getBlockTag(blockTag)
|
||
|
|
}).then((result) => {
|
||
|
|
return hexlify(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string> {
|
||
|
|
return this._runPerform("getStorageAt", {
|
||
|
|
address: () => this.resolveName(addressOrName),
|
||
|
|
blockTag: () => this._getBlockTag(blockTag),
|
||
|
|
position: () => Promise.resolve(position).then((p) => hexValue(p))
|
||
|
|
}).then((result) => {
|
||
|
|
return hexlify(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
// This should be called by any subclass wrapping a TransactionResponse
|
||
|
|
_wrapTransaction(tx: Transaction, hash?: string): TransactionResponse {
|
||
|
|
if (hash != null && hexDataLength(hash) !== 32) { throw new Error("invalid response - sendTransaction"); }
|
||
|
|
|
||
|
|
let result = <TransactionResponse>tx;
|
||
|
|
|
||
|
|
// Check the hash we expect is the same as the hash the server reported
|
||
|
|
if (hash != null && tx.hash !== hash) {
|
||
|
|
errors.throwError("Transaction hash mismatch from Provider.sendTransaction.", errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
|
||
|
|
}
|
||
|
|
|
||
|
|
// @TODO: (confirmations? number, timeout? number)
|
||
|
|
result.wait = (confirmations?: number) => {
|
||
|
|
|
||
|
|
// We know this transaction *must* exist (whether it gets mined is
|
||
|
|
// another story), so setting an emitted value forces us to
|
||
|
|
// wait even if the node returns null for the receipt
|
||
|
|
if (confirmations !== 0) {
|
||
|
|
this._emitted["t:" + tx.hash] = "pending";
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.waitForTransaction(tx.hash, confirmations).then((receipt) => {
|
||
|
|
if (receipt == null && confirmations === 0) { return null; }
|
||
|
|
|
||
|
|
// No longer pending, allow the polling loop to garbage collect this
|
||
|
|
this._emitted["t:" + tx.hash] = receipt.blockNumber;
|
||
|
|
|
||
|
|
if (receipt.status === 0) {
|
||
|
|
errors.throwError("transaction failed", errors.CALL_EXCEPTION, {
|
||
|
|
transactionHash: tx.hash,
|
||
|
|
transaction: tx
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return receipt;
|
||
|
|
});
|
||
|
|
};
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse> {
|
||
|
|
return this._runPerform("sendTransaction", {
|
||
|
|
signedTransaction: () => Promise.resolve(signedTransaction).then(t => hexlify(t))
|
||
|
|
}).then((result) => {
|
||
|
|
return this._wrapTransaction(this.formatter.transaction(signedTransaction), result);
|
||
|
|
}, (error) => {
|
||
|
|
error.transaction = this.formatter.transaction(signedTransaction);
|
||
|
|
if (error.transaction.hash) {
|
||
|
|
(<any>error).transactionHash = error.transaction.hash;
|
||
|
|
}
|
||
|
|
throw error;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
_getTransactionRequest(transaction: TransactionRequest | Promise<TransactionRequest>): Promise<Transaction> {
|
||
|
|
return Promise.resolve(transaction).then((t: any) => {
|
||
|
|
let tx: any = { };
|
||
|
|
["from", "to"].forEach((key) => {
|
||
|
|
if (t[key] == null) { return; }
|
||
|
|
tx[key] = Promise.resolve(t[key]).then(a => (a ? this.resolveName(a): null))
|
||
|
|
});
|
||
|
|
["data", "gasLimit", "gasPrice", "value"].forEach((key) => {
|
||
|
|
if (t[key] == null) { return; }
|
||
|
|
tx[key] = t[key];
|
||
|
|
});
|
||
|
|
return resolveProperties(tx).then((t) => this.formatter.transactionRequest(t));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
_getFilter(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Filter | FilterByBlockHash> {
|
||
|
|
return Promise.resolve(filter).then((f: any) => {
|
||
|
|
let filter: any = { };
|
||
|
|
|
||
|
|
if (f.address != null) {
|
||
|
|
filter.address = this.resolveName(f.address);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (f.blockHash != null) {
|
||
|
|
filter.blockHash = f.blockHash;
|
||
|
|
}
|
||
|
|
|
||
|
|
["fromBlock", "toBlock"].forEach((key) => {
|
||
|
|
if (f[key] == null) { return; }
|
||
|
|
filter[key] = this._getBlockTag(f[key]);
|
||
|
|
});
|
||
|
|
|
||
|
|
return resolveProperties(filter).then((f) => this.formatter.filter(f));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
call(transaction: TransactionRequest | Promise<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string> {
|
||
|
|
return this._runPerform("call", {
|
||
|
|
transaction: () => this._getTransactionRequest(transaction),
|
||
|
|
blockTag: () => this._getBlockTag(blockTag)
|
||
|
|
}).then((result) => {
|
||
|
|
return hexlify(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
estimateGas(transaction: TransactionRequest | Promise<TransactionRequest>) {
|
||
|
|
return this._runPerform("estimateGas", {
|
||
|
|
transaction: () => this._getTransactionRequest(transaction)
|
||
|
|
}).then((result) => {
|
||
|
|
return BigNumber.from(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
_getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>, includeTransactions?: boolean): Promise<Block | BlockWithTransactions> {
|
||
|
|
return this.ready.then(() => {
|
||
|
|
return this._getBlockTag(blockHashOrBlockTag).then((blockHashOrBlockTag) => {
|
||
|
|
let params: { [key: string]: any } = {
|
||
|
|
includeTransactions: !!includeTransactions
|
||
|
|
};
|
||
|
|
|
||
|
|
// Exactly one of blockHash or blockTag will be set
|
||
|
|
let blockHash: string = null;
|
||
|
|
let blockTag: string = null;
|
||
|
|
|
||
|
|
// If blockTag is a number (not "latest", etc), this is the block number
|
||
|
|
let blockNumber = -128;
|
||
|
|
|
||
|
|
if (isHexString(blockHashOrBlockTag, 32)) {
|
||
|
|
params.blockHash = blockHashOrBlockTag;
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
params.blockTag = this.formatter.blockTag(blockHashOrBlockTag);
|
||
|
|
if (isHexString(params.blockTag)) {
|
||
|
|
blockNumber = parseInt(params.blockTag.substring(2), 16);
|
||
|
|
}
|
||
|
|
} catch (error) {
|
||
|
|
errors.throwError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return poll(() => {
|
||
|
|
return this.perform("getBlock", params).then((block) => {
|
||
|
|
|
||
|
|
// Block was not found
|
||
|
|
if (block == null) {
|
||
|
|
|
||
|
|
// For blockhashes, if we didn't say it existed, that blockhash may
|
||
|
|
// not exist. If we did see it though, perhaps from a log, we know
|
||
|
|
// it exists, and this node is just not caught up yet.
|
||
|
|
if (blockHash) {
|
||
|
|
if (this._emitted["b:" + blockHash] == null) { return null; }
|
||
|
|
}
|
||
|
|
|
||
|
|
// For block tags, if we are asking for a future block, we return null
|
||
|
|
if (blockTag) {
|
||
|
|
if (blockNumber > this._emitted.block) { return null; }
|
||
|
|
}
|
||
|
|
|
||
|
|
// Retry on the next block
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Add transactions
|
||
|
|
if (includeTransactions) {
|
||
|
|
return this.formatter.blockWithTransactions(block);
|
||
|
|
}
|
||
|
|
|
||
|
|
return this.formatter.block(block);
|
||
|
|
});
|
||
|
|
}, { onceBlock: this });
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block> {
|
||
|
|
return <Promise<Block>>(this._getBlock(blockHashOrBlockTag, false));
|
||
|
|
}
|
||
|
|
|
||
|
|
getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions> {
|
||
|
|
return <Promise<BlockWithTransactions>>(this._getBlock(blockHashOrBlockTag, true));
|
||
|
|
}
|
||
|
|
|
||
|
|
getTransaction(transactionHash: string): Promise<TransactionResponse> {
|
||
|
|
return this.ready.then(() => {
|
||
|
|
return resolveProperties({ transactionHash: transactionHash }).then(({ transactionHash }) => {
|
||
|
|
let params = { transactionHash: this.formatter.hash(transactionHash, true) };
|
||
|
|
return poll(() => {
|
||
|
|
return this.perform("getTransaction", params).then((result) => {
|
||
|
|
if (result == null) {
|
||
|
|
if (this._emitted["t:" + transactionHash] == null) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
let tx = this.formatter.transactionResponse(result);
|
||
|
|
|
||
|
|
if (tx.blockNumber == null) {
|
||
|
|
tx.confirmations = 0;
|
||
|
|
|
||
|
|
} else if (tx.confirmations == null) {
|
||
|
|
return this._getFastBlockNumber().then((blockNumber) => {
|
||
|
|
|
||
|
|
// Add the confirmations using the fast block number (pessimistic)
|
||
|
|
let confirmations = (blockNumber - tx.blockNumber) + 1;
|
||
|
|
if (confirmations <= 0) { confirmations = 1; }
|
||
|
|
tx.confirmations = confirmations;
|
||
|
|
|
||
|
|
return this._wrapTransaction(tx);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._wrapTransaction(tx);
|
||
|
|
});
|
||
|
|
}, { onceBlock: this });
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt> {
|
||
|
|
return this.ready.then(() => {
|
||
|
|
return resolveProperties({ transactionHash: transactionHash }).then(({ transactionHash }) => {
|
||
|
|
let params = { transactionHash: this.formatter.hash(transactionHash, true) };
|
||
|
|
return poll(() => {
|
||
|
|
return this.perform("getTransactionReceipt", params).then((result) => {
|
||
|
|
if (result == null) {
|
||
|
|
if (this._emitted["t:" + transactionHash] == null) {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
// "geth-etc" returns receipts before they are ready
|
||
|
|
if (result.blockHash == null) { return undefined; }
|
||
|
|
|
||
|
|
let receipt = this.formatter.receipt(result);
|
||
|
|
|
||
|
|
if (receipt.blockNumber == null) {
|
||
|
|
receipt.confirmations = 0;
|
||
|
|
|
||
|
|
} else if (receipt.confirmations == null) {
|
||
|
|
return this._getFastBlockNumber().then((blockNumber) => {
|
||
|
|
|
||
|
|
// Add the confirmations using the fast block number (pessimistic)
|
||
|
|
let confirmations = (blockNumber - receipt.blockNumber) + 1;
|
||
|
|
if (confirmations <= 0) { confirmations = 1; }
|
||
|
|
receipt.confirmations = confirmations;
|
||
|
|
|
||
|
|
return receipt;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return receipt;
|
||
|
|
});
|
||
|
|
}, { onceBlock: this });
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
getLogs(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Array<Log>> {
|
||
|
|
return this._runPerform("getLogs", {
|
||
|
|
filter: () => this._getFilter(filter)
|
||
|
|
}).then((result) => {
|
||
|
|
return Formatter.arrayOf(this.formatter.filterLog.bind(this.formatter))(result);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
getEtherPrice(): Promise<number> {
|
||
|
|
return this._runPerform("getEtherPrice", { }).then((result) => {
|
||
|
|
return result;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
_getBlockTag(blockTag: BlockTag | Promise<BlockTag>): Promise<BlockTag> {
|
||
|
|
if (blockTag instanceof Promise) {
|
||
|
|
return blockTag.then((b) => this._getBlockTag(b));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof(blockTag) === "number" && blockTag < 0) {
|
||
|
|
if (blockTag % 1) {
|
||
|
|
errors.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._getFastBlockNumber().then((bn) => {
|
||
|
|
bn += blockTag;
|
||
|
|
if (bn < 0) { bn = 0; }
|
||
|
|
return this.formatter.blockTag(bn)
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return Promise.resolve(this.formatter.blockTag(blockTag));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
_getResolver(name: string): Promise<string> {
|
||
|
|
// Get the resolver from the blockchain
|
||
|
|
return this.getNetwork().then((network) => {
|
||
|
|
|
||
|
|
// No ENS...
|
||
|
|
if (!network.ensAddress) {
|
||
|
|
errors.throwError(
|
||
|
|
"network does support ENS",
|
||
|
|
errors.UNSUPPORTED_OPERATION,
|
||
|
|
{ operation: "ENS", network: network.name }
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// keccak256("resolver(bytes32)")
|
||
|
|
let data = "0x0178b8bf" + namehash(name).substring(2);
|
||
|
|
let transaction = { to: network.ensAddress, data: data };
|
||
|
|
|
||
|
|
return this.call(transaction).then((data) => {
|
||
|
|
return this.formatter.callAddress(data);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
resolveName(name: string | Promise<string>): Promise<string> {
|
||
|
|
|
||
|
|
// If it is a promise, resolve it then recurse
|
||
|
|
if (name instanceof Promise) {
|
||
|
|
return name.then((addressOrName) => this.resolveName(addressOrName));
|
||
|
|
}
|
||
|
|
|
||
|
|
// If it is already an address, nothing to resolve
|
||
|
|
try {
|
||
|
|
return Promise.resolve(this.formatter.address(name));
|
||
|
|
} catch (error) { }
|
||
|
|
|
||
|
|
// Get the addr from the resovler
|
||
|
|
return this._getResolver(name).then((resolverAddress) => {
|
||
|
|
if (!resolverAddress) { return null; }
|
||
|
|
|
||
|
|
// keccak256("addr(bytes32)")
|
||
|
|
let data = "0x3b3b57de" + namehash(name).substring(2);
|
||
|
|
let transaction = { to: resolverAddress, data: data };
|
||
|
|
return this.call(transaction).then((data) => {
|
||
|
|
return this.formatter.callAddress(data);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
lookupAddress(address: string | Promise<string>): Promise<string> {
|
||
|
|
if (address instanceof Promise) {
|
||
|
|
return address.then((address) => this.lookupAddress(address));
|
||
|
|
}
|
||
|
|
|
||
|
|
address = this.formatter.address(address);
|
||
|
|
|
||
|
|
let name = address.substring(2) + ".addr.reverse"
|
||
|
|
|
||
|
|
return this._getResolver(name).then((resolverAddress) => {
|
||
|
|
if (!resolverAddress) { return null; }
|
||
|
|
|
||
|
|
// keccak("name(bytes32)")
|
||
|
|
let data = "0x691f3431" + namehash(name).substring(2);
|
||
|
|
return this.call({ to: resolverAddress, data: data }).then((data) => {
|
||
|
|
let bytes = arrayify(data);
|
||
|
|
|
||
|
|
// Strip off the dynamic string pointer (0x20)
|
||
|
|
if (bytes.length < 32 || !BigNumber.from(bytes.slice(0, 32)).eq(32)) { return null; }
|
||
|
|
bytes = bytes.slice(32);
|
||
|
|
|
||
|
|
if (bytes.length < 32) { return null; }
|
||
|
|
let length = BigNumber.from(bytes.slice(0, 32)).toNumber();
|
||
|
|
bytes = bytes.slice(32);
|
||
|
|
|
||
|
|
if (length > bytes.length) { return null; }
|
||
|
|
|
||
|
|
let name = toUtf8String(bytes.slice(0, length));
|
||
|
|
|
||
|
|
// Make sure the reverse record matches the foward record
|
||
|
|
return this.resolveName(name).then((addr) => {
|
||
|
|
if (addr != address) { return null; }
|
||
|
|
return name;
|
||
|
|
});
|
||
|
|
});
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
perform(method: string, params: any): Promise<any> {
|
||
|
|
return errors.throwError(method + " not implemented", errors.NOT_IMPLEMENTED, { operation: method });
|
||
|
|
}
|
||
|
|
|
||
|
|
_startPending(): void {
|
||
|
|
console.log("WARNING: this provider does not support pending events");
|
||
|
|
}
|
||
|
|
|
||
|
|
_stopPending(): void {
|
||
|
|
}
|
||
|
|
|
||
|
|
// Returns true if there are events that still require polling
|
||
|
|
_checkPolling(): void {
|
||
|
|
this.polling = (this._events.filter((e) => e.pollable()).length > 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
_addEventListener(eventName: EventType, listener: Listener, once: boolean): this {
|
||
|
|
this._events.push(new Event(getEventTag(eventName), listener, once));
|
||
|
|
|
||
|
|
if (eventName === "pending") { this._startPending(); }
|
||
|
|
|
||
|
|
// Do we still now have any events that require polling?
|
||
|
|
this._checkPolling();
|
||
|
|
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
on(eventName: EventType, listener: Listener): this {
|
||
|
|
return this._addEventListener(eventName, listener, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
once(eventName: EventType, listener: Listener): this {
|
||
|
|
return this._addEventListener(eventName, listener, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
emit(eventName: EventType, ...args: Array<any>): boolean {
|
||
|
|
let result = false;
|
||
|
|
|
||
|
|
let eventTag = getEventTag(eventName);
|
||
|
|
this._events = this._events.filter((event) => {
|
||
|
|
if (event.tag !== eventTag) { return true; }
|
||
|
|
setTimeout(() => {
|
||
|
|
event.listener.apply(this, args);
|
||
|
|
}, 0);
|
||
|
|
result = true;
|
||
|
|
return !(event.once);
|
||
|
|
});
|
||
|
|
|
||
|
|
// Do we still have any events that require polling? ("once" events remove themselves)
|
||
|
|
this._checkPolling();
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
listenerCount(eventName?: EventType): number {
|
||
|
|
if (!eventName) { return this._events.length; }
|
||
|
|
|
||
|
|
let eventTag = getEventTag(eventName);
|
||
|
|
return this._events.filter((event) => {
|
||
|
|
return (event.tag === eventTag);
|
||
|
|
}).length;
|
||
|
|
}
|
||
|
|
|
||
|
|
listeners(eventName?: EventType): Array<Listener> {
|
||
|
|
if (eventName == null) {
|
||
|
|
return this._events.map((event) => event.listener);
|
||
|
|
}
|
||
|
|
|
||
|
|
let eventTag = getEventTag(eventName);
|
||
|
|
return this._events
|
||
|
|
.filter((event) => (event.tag === eventTag))
|
||
|
|
.map((event) => event.listener);
|
||
|
|
}
|
||
|
|
|
||
|
|
off(eventName: EventType, listener?: Listener): this {
|
||
|
|
if (listener == null) {
|
||
|
|
return this.removeAllListeners(eventName);
|
||
|
|
}
|
||
|
|
|
||
|
|
let found = false;
|
||
|
|
|
||
|
|
let eventTag = getEventTag(eventName);
|
||
|
|
this._events = this._events.filter((event) => {
|
||
|
|
if (event.tag !== eventTag || event.listener != listener) { return true; }
|
||
|
|
if (found) { return true; }
|
||
|
|
found = true;
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
|
||
|
|
if (eventName === "pending" && this.listenerCount("pending") === 0) { this._stopPending(); }
|
||
|
|
|
||
|
|
// Do we still have any events that require polling?
|
||
|
|
this._checkPolling();
|
||
|
|
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
removeAllListeners(eventName?: EventType): this {
|
||
|
|
if (eventName == null) {
|
||
|
|
this._events = [ ];
|
||
|
|
this._stopPending();
|
||
|
|
} else {
|
||
|
|
let eventTag = getEventTag(eventName);
|
||
|
|
this._events = this._events.filter((event) => {
|
||
|
|
return (event.tag !== eventTag);
|
||
|
|
});
|
||
|
|
if (eventName === "pending") { this._stopPending(); }
|
||
|
|
}
|
||
|
|
|
||
|
|
// Do we still have any events that require polling?
|
||
|
|
this._checkPolling();
|
||
|
|
|
||
|
|
return this;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|