tornado-packages/ethers.js
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removed superfluous types for refining type properties.

Browse Source
This commit is contained in:
Richard Moore 2022-09-09 18:33:36 -04:00
parent 5bdac36a99
commit b617322ee8
5 changed files with 42 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src.ts/abi/fragments.ts
View File

@ -428,18 +428,6 @@ function verifyBasicType(type: string): string {
// Make the Fragment constructors effectively private
const _guard = { };
export interface ArrayParamType { //extends ParamType {
readonly arrayLength: number;
readonly arrayChildren: ParamType;
}
export interface TupleParamType extends ParamType {
readonly components: ReadonlyArray<ParamType>;
}
export interface IndexableParamType extends ParamType {
readonly indexed: boolean;
}
export type FragmentWalkFunc = (type: string, value: any) => any;
export type FragmentWalkAsyncFunc = (type: string, value: any) => any | Promise<any>;
@ -545,15 +533,15 @@ export class ParamType {
return value && (value.baseType === "array")
}
isArray(): this is (ParamType & ArrayParamType) {
isArray(): this is (ParamType & { arrayLength: number, arrayChildren: ParamType }) {
return (this.baseType === "array")
}
isTuple(): this is TupleParamType {
isTuple(): this is (ParamType & { components: ReadonlyArray<ParamType> }) {
return (this.baseType === "tuple");
}
isIndexable(): this is IndexableParamType {
isIndexable(): this is (ParamType & { indexed: boolean }) {
return (this.indexed != null);
}
@ -563,7 +551,8 @@ export class ParamType {
if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
throw new Error("array is wrong length");
}
return value.map((v) => ((<ArrayParamType>this).arrayChildren.walk(v, process)));
const _this = this;
return value.map((v) => (_this.arrayChildren.walk(v, process)));
}
if (this.isTuple()) {
@ -571,7 +560,8 @@ export class ParamType {
if (value.length !== this.components.length) {
throw new Error("array is wrong length");
}
return value.map((v, i) => ((<TupleParamType>this).components[i].walk(v, process)));
const _this = this;
return value.map((v, i) => (_this.components[i].walk(v, process)));
}
return process(this.type, value);
@ -742,13 +732,7 @@ export class ParamType {
}
}
export enum FragmentType {
"constructor" = "constructor",
"error" = "error",
"event" = "event",
"function" = "function",
"struct" = "struct",
};
export type FragmentType = "constructor" | "error" | "event" | "function" | "struct";
export abstract class Fragment {
readonly type!: FragmentType;
@ -858,7 +842,7 @@ function joinParams(format: FormatType, params: ReadonlyArray<ParamType>): strin
export class ErrorFragment extends NamedFragment {
constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>) {
super(guard, FragmentType.error, name, inputs);
super(guard, "error", name, inputs);
}
format(format: FormatType = "sighash"): string {
@ -894,7 +878,7 @@ export class EventFragment extends NamedFragment {
readonly anonymous!: boolean;
constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>, anonymous: boolean) {
super(guard, FragmentType.event, name, inputs);
super(guard, "event", name, inputs);
defineProperties<EventFragment>(this, { anonymous });
}
@ -977,7 +961,7 @@ export class ConstructorFragment extends Fragment {
const gas = consumeGas(tokens);
consumeEoi(tokens);
return new ConstructorFragment(_guard, FragmentType.constructor, inputs, payable, gas);
return new ConstructorFragment(_guard, "constructor", inputs, payable, gas);
}
}
@ -990,7 +974,7 @@ export class FunctionFragment extends NamedFragment {
readonly gas!: null | bigint;
constructor(guard: any, name: string, stateMutability: string, inputs: ReadonlyArray<ParamType>, outputs: ReadonlyArray<ParamType>, gas: null | bigint) {
super(guard, FragmentType.function, name, inputs);
super(guard, "function", name, inputs);
outputs = Object.freeze(outputs.slice());
const constant = (stateMutability === "view" || stateMutability === "pure");
const payable = (stateMutability === "payable");
@ -1068,7 +1052,7 @@ export class StructFragment extends NamedFragment {
const inputs = consumeParams(tokens);
consumeEoi(tokens);
return new StructFragment(_guard, FragmentType.struct, name, inputs);
return new StructFragment(_guard, "struct", name, inputs);
}
}

17
src.ts/providers/abstract-provider.ts
View File

@ -597,7 +597,7 @@ export class AbstractProvider implements Provider {
return network.formatter.transactionRequest(request);
}
async estimateGas(_tx: TransactionRequest) {
async estimateGas(_tx: TransactionRequest): Promise<bigint> {
const transaction = await this._getTransaction(_tx);
return getBigInt(await this.#perform({
method: "estimateGas", transaction
@ -665,7 +665,7 @@ export class AbstractProvider implements Provider {
}
}
async call(_tx: CallRequest) {
async call(_tx: CallRequest): Promise<string> {
const [ tx, blockTag ] = await Promise.all([
this._getTransaction(_tx), this._getBlockTag(_tx.blockTag)
]);
@ -684,25 +684,25 @@ export class AbstractProvider implements Provider {
return await this.#perform(Object.assign(request, { address, blockTag }));
}
async getBalance(address: AddressLike, blockTag?: BlockTag) {
async getBalance(address: AddressLike, blockTag?: BlockTag): Promise<bigint> {
return getBigInt(await this.#getAccountValue({ method: "getBalance" }, address, blockTag), "%response");
}
async getTransactionCount(address: AddressLike, blockTag?: BlockTag) {
async getTransactionCount(address: AddressLike, blockTag?: BlockTag): Promise<number> {
return getNumber(await this.#getAccountValue({ method: "getTransactionCount" }, address, blockTag), "%response");
}
async getCode(address: AddressLike, blockTag?: BlockTag) {
async getCode(address: AddressLike, blockTag?: BlockTag): Promise<string> {
return hexlify(await this.#getAccountValue({ method: "getCode" }, address, blockTag));
}
async getStorageAt(address: AddressLike, _position: BigNumberish, blockTag?: BlockTag) {
async getStorageAt(address: AddressLike, _position: BigNumberish, blockTag?: BlockTag): Promise<string> {
const position = getBigInt(_position, "position");
return hexlify(await this.#getAccountValue({ method: "getStorageAt", position }, address, blockTag));
}
// Write
async broadcastTransaction(signedTx: string) {
async broadcastTransaction(signedTx: string): Promise<TransactionResponse> {
throw new Error();
return <TransactionResponse><unknown>{ };
}
@ -869,6 +869,7 @@ export class AbstractProvider implements Provider {
}
async resolveName(name: string): Promise<null | string>{
if (isHexString(name, 20)) { return name; }
//if (typeof(name) === "string") {
const resolver = await this.getResolver(name);
if (resolver) { return await resolver.getAddress(); }
@ -1230,7 +1231,7 @@ function bytesPad(value: Uint8Array): Uint8Array {
const empty = new Uint8Array([ ]);
// ABI Encodes a series of (bytes, bytes, ...)
function encodeBytes(datas: Array<BytesLike>) {
function encodeBytes(datas: Array<BytesLike>): string {
const result: Array<Uint8Array> = [ ];
let byteCount = 0;

32
src.ts/providers/provider.ts
View File

@ -206,10 +206,6 @@ export interface MinedBlock<T extends string | TransactionResponse = string> ext
readonly miner: string;
}
export interface LondonBlock<T extends string | TransactionResponse> extends Block<T> {
readonly baseFeePerGas: bigint;
}
export class Block<T extends string | TransactionResponse> implements BlockParams<T>, Iterable<T> {
readonly provider!: Provider;
@ -320,7 +316,9 @@ export class Block<T extends string | TransactionResponse> implements BlockParam
}
isMined(): this is MinedBlock<T> { return !!this.hash; }
isLondon(): this is LondonBlock<T> { return !!this.baseFeePerGas; }
isLondon(): this is (Block<T> & { baseFeePerGas: bigint }) {
return !!this.baseFeePerGas;
}
orphanedEvent(): OrphanFilter {
if (!this.isMined()) { throw new Error(""); }
@ -449,6 +447,7 @@ export interface TransactionReceiptParams {
root: null | string;
}
/*
export interface LegacyTransactionReceipt {
byzantium: false;
status: null;
@ -460,6 +459,7 @@ export interface ByzantiumTransactionReceipt {
status: number;
root: null;
}
*/
export class TransactionReceipt implements TransactionReceiptParams, Iterable<Log> {
readonly provider!: Provider;
@ -631,23 +631,7 @@ export interface MinedTransactionResponse extends TransactionResponse {
date: Date;
}
export interface LegacyTransactionResponse extends TransactionResponse {
accessList: null;
maxFeePerGas: null;
maxPriorityFeePerGas: null;
}
export interface BerlinTransactionResponse extends TransactionResponse {
accessList: AccessList;
maxFeePerGas: null;
maxPriorityFeePerGas: null;
}
export interface LondonTransactionResponse extends TransactionResponse {
accessList: AccessList;
maxFeePerGas: bigint;
maxPriorityFeePerGas: bigint;
}
export class TransactionResponse implements TransactionLike<string>, TransactionResponseParams {
readonly provider: Provider;
@ -760,15 +744,15 @@ export class TransactionResponse implements TransactionLike<string>, Transaction
return (this.blockHash != null);
}
isLegacy(): this is LegacyTransactionResponse {
isLegacy(): this is (TransactionResponse & { accessList: null, maxFeePerGas: null, maxPriorityFeePerGas: null }) {
return (this.type === 0)
}
isBerlin(): this is BerlinTransactionResponse {
isBerlin(): this is (TransactionResponse & { accessList: AccessList, maxFeePerGas: null, maxPriorityFeePerGas: null }) {
return (this.type === 1);
}
isLondon(): this is LondonTransactionResponse {
isLondon(): this is (TransactionResponse & { accessList: AccessList, maxFeePerGas: bigint, maxPriorityFeePerGas: bigint }){
return (this.type === 2);
}

29
src.ts/transaction/transaction.ts
View File

@ -328,23 +328,6 @@ export interface SignedTransaction extends Transaction {
signature: Signature;
}
export interface LegacyTransaction extends Transaction {
type: 0;
gasPrice: bigint;
}
export interface BerlinTransaction extends Transaction {
type: 1;
gasPrice: bigint;
accessList: AccessList;
}
export interface LondonTransaction extends Transaction {
type: 2;
maxFeePerGas: bigint;
maxPriorityFeePerGas: bigint;
accessList: AccessList;
}
export class Transaction implements Freezable<Transaction>, TransactionLike<string> {
#props: {
@ -595,9 +578,15 @@ export class Transaction implements Freezable<Transaction>, TransactionLike<stri
return types;
}
isLegacy(): this is LegacyTransaction { return (this.type === 0); }
isBerlin(): this is BerlinTransaction { return (this.type === 1); }
isLondon(): this is LondonTransaction { return (this.type === 2); }
isLegacy(): this is (Transaction & { type: 0, gasPrice: bigint }) {
return (this.type === 0);
}
isBerlin(): this is (Transaction & { type: 1, gasPrice: bigint, accessList: AccessList }) {
return (this.type === 1);
}
isLondon(): this is (Transaction & { type: 2, accessList: AccessList, maxFeePerGas: bigint, maxPriorityFeePerGas: bigint}) {
return (this.type === 2);
}
clone(): Transaction {
return Transaction.from(this);

14
src.ts/utils/fetch.ts
View File

@ -14,10 +14,6 @@ export type GetUrlResponse = {
body: null | Uint8Array
};
export interface FetchRequestWithBody extends FetchRequest {
body: Uint8Array;
}
/**
* Called before any network request, allowing updated headers (e.g. Bearer tokens), etc.
*/
@ -125,7 +121,7 @@ export class FetchCancelSignal {
this.#listeners.push(listener);
}
get cancelled(): boolean { return this.cancelled; }
get cancelled(): boolean { return this.#cancelled; }
checkSignal(): void {
if (!this.cancelled) { return; }
@ -217,7 +213,7 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
/**
* Returns true if the request has a body.
*/
hasBody(): this is FetchRequestWithBody {
hasBody(): this is (FetchRequest & { body: Uint8Array }) {
return (this.#body != null);
}
@ -617,10 +613,6 @@ export class FetchRequest implements Iterable<[ key: string, value: string ]> {
}
export interface FetchResponseWithBody extends FetchResponse {
body: Readonly<Uint8Array>;
}
interface ThrottleError extends Error {
stall: number;
throttle: true;
@ -771,7 +763,7 @@ export class FetchResponse implements Iterable<[ key: string, value: string ]> {
/**
* Returns true of the response has a body.
*/
hasBody(): this is FetchResponseWithBody {
hasBody(): this is (FetchResponse & { body: Uint8Array }) {
return (this.#body != null);
}