Updated dist files.

_version.d.ts

@@ -1 +1 @@
-export declare const version = "4.0.0-beta.7";
+export declare const version = "4.0.0-beta.8";

_version.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.version = "4.0.0-beta.7";
+exports.version = "4.0.0-beta.8";

ethers.d.ts

@@ -1,103 +1,12 @@
 import { Contract, Interface } from './contracts';
-import { Provider, getDefaultProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider } from './providers';
-import { JsonRpcSigner } from './providers/json-rpc-provider';
+import * as providers from './providers';
 import { HDNode, SigningKey, Wallet } from './wallet';
-import * as utils from './utils';
-import * as wordlists from './wordlists';
+import { constants } from './utils/constants';
 import * as errors from './utils/errors';
+import * as utils from './utils';
+import * as types from './types';
+import * as wordlists from './wordlists';
 import { platform } from './utils/shims';
 import { version } from './_version';
-import { Provider as _AbstractProvider } from './providers/abstract-provider';
-import { Signer as _AbstractSigner } from './wallet/abstract-signer';
-import { ContractFunction as _ContractFunction, Event as _Event, EventFilter as _EventFilter } from './contracts/contract';
-import { Indexed as _Indexed, DeployDescription as _DeplyDescription, EventDescription as _EventDescription, FunctionDescription as _FunctionDescription, LogDescription as _LogDescription, TransactionDescription as _TransactionDescription } from './contracts/interface';
-import { Block as _Block, BlockTag as _BlockTag, EventType as _EventType, Filter as _Filter, Log as _Log, Listener as _Listener, TransactionReceipt as _TransactionReceipt, TransactionRequest as _TransactionRequest, TransactionResponse as _TransactionResponse } from './providers/abstract-provider';
-import { AsyncSendable as _AsyncSendable } from './providers/web3-provider';
-import { CoerceFunc as _CoerceFunc, EventFragment as _EventFragment, FunctionFragment as _FunctionFragment, ParamType as _ParamType } from './utils/abi-coder';
-import { BigNumberish as _BigNumberish } from './utils/bignumber';
-import { Arrayish as _Arrayish, Hexable as _Hexable, Signature as _Signature } from './utils/bytes';
-import { SupportedAlgorithms as _SupportedAlgorithms } from './utils/hmac';
-import { Network as _Network, Networkish as _Networkish } from './utils/networks';
-import { Transaction as _Transaction, UnsignedTransaction as _UnsignedTransaction } from './utils/transaction';
-import { UnicodeNormalizationForm as _UnicodeNotmalizationForm } from './utils/utf8';
-import { ConnectionInfo as _ConnectionInfo, OnceBlockable as _OnceBlockable, PollOptions as _PollOptions } from './utils/web';
-import { EncryptOptions as _EncryptOptions, ProgressCallback as _ProgressCallback } from './wallet/secret-storage';
-import { Wordlist as _Wordlist } from './wordlists/wordlist';
-declare module types {
-    const AbstractSigner: typeof _AbstractSigner;
-    const AbstractProvider: typeof _AbstractProvider;
-    type SignerOrProvider = _AbstractSigner | _AbstractProvider;
-    type ContractFunction = _ContractFunction;
-    type EventFilter = _EventFilter;
-    interface Event extends _Event {
-    }
-    interface Indexed extends _Indexed {
-    }
-    interface DeployDescription extends _DeplyDescription {
-    }
-    interface EventDescription extends _EventDescription {
-    }
-    interface FunctionDescription extends _FunctionDescription {
-    }
-    interface LogDescription extends _LogDescription {
-    }
-    interface TransactionDescription extends _TransactionDescription {
-    }
-    type BlockTag = _BlockTag;
-    type EventType = _EventType;
-    type Filter = _Filter;
-    type Listener = _Listener;
-    type TransactionRequest = _TransactionRequest;
-    interface Block extends _Block {
-    }
-    interface Log extends _Log {
-    }
-    interface TransactionReceipt extends _TransactionReceipt {
-    }
-    interface TransactionResponse extends _TransactionResponse {
-    }
-    type AsyncSendable = _AsyncSendable;
-    type CoerceFunc = _CoerceFunc;
-    type EventFragment = _EventFragment;
-    type FunctionFragment = _FunctionFragment;
-    type ParamType = _ParamType;
-    type BigNumberish = _BigNumberish;
-    type Arrayish = _Arrayish;
-    type Hexable = _Hexable;
-    type Signature = _Signature;
-    const SupportedAlgorithms: typeof _SupportedAlgorithms;
-    type Network = _Network;
-    type Networkish = _Networkish;
-    type UnsignedTransaction = _UnsignedTransaction;
-    interface Transaction extends _Transaction {
-    }
-    const UnicodeNormalizationForm: typeof _UnicodeNotmalizationForm;
-    type ConnectionInfo = _ConnectionInfo;
-    interface OnceBlockable extends _OnceBlockable {
-    }
-    type PollOptions = _PollOptions;
-    type EncryptOptions = _EncryptOptions;
-    type ProgressCallback = _ProgressCallback;
-    const Wordlist: typeof _Wordlist;
-}
-declare const constants: {
-    AddressZero: string;
-    HashZero: string;
-    NegativeOne: utils.BigNumber;
-    Zero: utils.BigNumber;
-    One: utils.BigNumber;
-    Two: utils.BigNumber;
-    WeiPerEther: utils.BigNumber;
-    MaxUint256: utils.BigNumber;
-};
-declare const providers: {
-    Provider: typeof Provider;
-    FallbackProvider: typeof FallbackProvider;
-    EtherscanProvider: typeof EtherscanProvider;
-    InfuraProvider: typeof InfuraProvider;
-    IpcProvider: typeof IpcProvider;
-    JsonRpcProvider: typeof JsonRpcProvider;
-    Web3Provider: typeof Web3Provider;
-    JsonRpcSigner: typeof JsonRpcSigner;
-};
+declare function getDefaultProvider(network?: types.Network | string): providers.BaseProvider;
 export { Wallet, HDNode, SigningKey, Contract, Interface, getDefaultProvider, providers, errors, constants, utils, types, wordlists, platform, version };

ethers.js

@@ -10,69 +10,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var contracts_1 = require("./contracts");
 exports.Contract = contracts_1.Contract;
 exports.Interface = contracts_1.Interface;
-var providers_1 = require("./providers");
-exports.getDefaultProvider = providers_1.getDefaultProvider;
-var json_rpc_provider_1 = require("./providers/json-rpc-provider");
+var providers = __importStar(require("./providers"));
+exports.providers = providers;
 var wallet_1 = require("./wallet");
 exports.HDNode = wallet_1.HDNode;
 exports.SigningKey = wallet_1.SigningKey;
 exports.Wallet = wallet_1.Wallet;
-var utils = __importStar(require("./utils"));
-exports.utils = utils;
-var wordlists = __importStar(require("./wordlists"));
-exports.wordlists = wordlists;
+var constants_1 = require("./utils/constants");
+exports.constants = constants_1.constants;
 var errors = __importStar(require("./utils/errors"));
 exports.errors = errors;
+var utils = __importStar(require("./utils"));
+exports.utils = utils;
+var types = __importStar(require("./types"));
+exports.types = types;
+var wordlists = __importStar(require("./wordlists"));
+exports.wordlists = wordlists;
 // This is empty in node, and used by browserify to inject extra goodies
 var shims_1 = require("./utils/shims");
 exports.platform = shims_1.platform;
 // This is generated by "npm run dist"
 var _version_1 = require("./_version");
 exports.version = _version_1.version;
-///////////////////////////////
-// Imported Abstracts
-var abstract_provider_1 = require("./providers/abstract-provider");
-var abstract_signer_1 = require("./wallet/abstract-signer");
-var hmac_1 = require("./utils/hmac");
-var utf8_1 = require("./utils/utf8");
-var wordlist_1 = require("./wordlists/wordlist");
-///////////////////////////////
-// Exported Types
-var types;
-(function (types) {
-    types.AbstractSigner = abstract_signer_1.Signer;
-    types.AbstractProvider = abstract_provider_1.Provider;
-    ;
-    ;
-    ;
-    ;
-    ;
-    ;
-    ;
-    ;
-    ;
-    ;
-    // ./utils/hmac
-    types.SupportedAlgorithms = hmac_1.SupportedAlgorithms;
-    ;
-    // ./utils/utf8
-    types.UnicodeNormalizationForm = utf8_1.UnicodeNormalizationForm;
-    ;
-    // ./wordlists/wordlist
-    types.Wordlist = wordlist_1.Wordlist;
-})(types || (types = {}));
-exports.types = types;
-///////////////////////////////
-var constants = utils.constants;
-exports.constants = constants;
-var providers = {
-    Provider: providers_1.Provider,
-    FallbackProvider: providers_1.FallbackProvider,
-    EtherscanProvider: providers_1.EtherscanProvider,
-    InfuraProvider: providers_1.InfuraProvider,
-    IpcProvider: providers_1.IpcProvider,
-    JsonRpcProvider: providers_1.JsonRpcProvider,
-    Web3Provider: providers_1.Web3Provider,
-    JsonRpcSigner: json_rpc_provider_1.JsonRpcSigner
-};
-exports.providers = providers;
+function getDefaultProvider(network) {
+    return new providers.FallbackProvider([
+        new providers.InfuraProvider(network),
+        new providers.EtherscanProvider(network),
+    ]);
+}
+exports.getDefaultProvider = getDefaultProvider;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ethers",
-  "version": "4.0.0-beta.7",
+  "version": "4.0.0-beta.8",
   "description": "Ethereum wallet library.",
   "main": "./index.js",
   "types": "./index.d.ts",

providers/base-provider.d.ts

@@ -0,0 +1,67 @@
+import { BigNumber } from '../utils/bignumber';
+import { Provider } from './abstract-provider';
+import { Block, BlockTag, EventType, Filter, Listener, Log, TransactionReceipt, TransactionRequest, TransactionResponse } from './abstract-provider';
+import { BigNumberish } from '../utils/bignumber';
+import { Transaction } from '../utils/transaction';
+import { Network, Networkish } from '../utils/networks';
+export declare class BaseProvider extends Provider {
+    private _network;
+    private _events;
+    protected _emitted: any;
+    private _pollingInterval;
+    private _poller;
+    private _lastBlockNumber;
+    private _balances;
+    /**
+     *  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.
+     *
+     */
+    protected ready: Promise<Network>;
+    constructor(network: Networkish | Promise<Network>);
+    private _doPoll;
+    resetEventsBlock(blockNumber: number): void;
+    readonly network: Network;
+    getNetwork(): Promise<Network>;
+    readonly blockNumber: number;
+    polling: boolean;
+    pollingInterval: number;
+    waitForTransaction(transactionHash: string, timeout?: number): Promise<TransactionReceipt>;
+    getBlockNumber(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    _wrapTransaction(tx: Transaction, hash?: string): TransactionResponse;
+    call(transaction: TransactionRequest): Promise<string>;
+    estimateGas(transaction: TransactionRequest): Promise<BigNumber>;
+    getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    getTransaction(transactionHash: string): Promise<TransactionResponse>;
+    getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt>;
+    getLogs(filter: Filter): Promise<Array<Log>>;
+    getEtherPrice(): Promise<number>;
+    private _resolveNames;
+    private _getResolver;
+    resolveName(name: string | Promise<string>): Promise<string>;
+    lookupAddress(address: string | Promise<string>): Promise<string>;
+    static checkTransactionResponse(transaction: any): TransactionResponse;
+    doPoll(): void;
+    perform(method: string, params: any): Promise<any>;
+    protected _startPending(): void;
+    protected _stopPending(): void;
+    private _addEventListener;
+    on(eventName: EventType, listener: Listener): Provider;
+    once(eventName: EventType, listener: Listener): Provider;
+    addEventListener(eventName: EventType, listener: Listener): Provider;
+    emit(eventName: EventType, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventType): number;
+    listeners(eventName: EventType): Array<Listener>;
+    removeAllListeners(eventName: EventType): Provider;
+    removeListener(eventName: EventType, listener: Listener): Provider;
+}

providers/etherscan-provider.d.ts

@@ -1,7 +1,7 @@
-import { Provider } from './provider';
+import { BaseProvider } from './base-provider';
 import { BlockTag, TransactionResponse } from './abstract-provider';
 import { Networkish } from '../utils/networks';
-export declare class EtherscanProvider extends Provider {
+export declare class EtherscanProvider extends BaseProvider {
     readonly baseUrl: string;
     readonly apiKey: string;
     constructor(network?: Networkish, apiKey?: string);

providers/etherscan-provider.js

@@ -17,7 +17,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var provider_1 = require("./provider");
+var base_provider_1 = require("./base-provider");
 var bytes_1 = require("../utils/bytes");
 var properties_1 = require("../utils/properties");
 var web_1 = require("../utils/web");
@@ -288,7 +288,7 @@ var EtherscanProvider = /** @class */ (function (_super) {
                     if (tx.creates == null && tx.contractAddress != null) {
                         tx.creates = tx.contractAddress;
                     }
-                    var item = provider_1.Provider.checkTransactionResponse(tx);
+                    var item = base_provider_1.BaseProvider.checkTransactionResponse(tx);
                     if (tx.timeStamp) {
                         item.timestamp = parseInt(tx.timeStamp);
                     }
@@ -299,5 +299,5 @@ var EtherscanProvider = /** @class */ (function (_super) {
         });
     };
     return EtherscanProvider;
-}(provider_1.Provider));
+}(base_provider_1.BaseProvider));
 exports.EtherscanProvider = EtherscanProvider;

providers/fallback-provider.d.ts

@@ -1,7 +1,7 @@
-import { Provider } from './provider';
-export declare class FallbackProvider extends Provider {
+import { BaseProvider } from './base-provider';
+export declare class FallbackProvider extends BaseProvider {
     private _providers;
-    constructor(providers: Array<Provider>);
-    readonly providers: Array<Provider>;
+    constructor(providers: Array<BaseProvider>);
+    readonly providers: Array<BaseProvider>;
     perform(method: string, params: any): any;
 }

providers/fallback-provider.js

@@ -17,7 +17,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var provider_1 = require("./provider");
+var base_provider_1 = require("./base-provider");
 var errors = __importStar(require("../utils/errors"));
 // Returns:
 //  - true is all networks match
@@ -106,5 +106,5 @@ var FallbackProvider = /** @class */ (function (_super) {
         });
     };
     return FallbackProvider;
-}(provider_1.Provider));
+}(base_provider_1.BaseProvider));
 exports.FallbackProvider = FallbackProvider;

providers/index.d.ts

@@ -1,11 +1,8 @@
-import { Provider } from './provider';
+import { BaseProvider } from './base-provider';
 import { EtherscanProvider } from './etherscan-provider';
 import { FallbackProvider } from './fallback-provider';
 import { IpcProvider } from './ipc-provider';
 import { InfuraProvider } from './infura-provider';
 import { JsonRpcProvider, JsonRpcSigner } from './json-rpc-provider';
 import { Web3Provider } from './web3-provider';
-import { Provider as AbstractProvider } from './abstract-provider';
-import { Network } from '../utils/networks';
-declare function getDefaultProvider(network?: Network | string): Provider;
-export { AbstractProvider, Provider, getDefaultProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider, JsonRpcSigner };
+export { BaseProvider, FallbackProvider, EtherscanProvider, InfuraProvider, JsonRpcProvider, Web3Provider, IpcProvider, JsonRpcSigner };

providers/index.js

@@ -1,7 +1,7 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-var provider_1 = require("./provider");
-exports.Provider = provider_1.Provider;
+var base_provider_1 = require("./base-provider");
+exports.BaseProvider = base_provider_1.BaseProvider;
 var etherscan_provider_1 = require("./etherscan-provider");
 exports.EtherscanProvider = etherscan_provider_1.EtherscanProvider;
 var fallback_provider_1 = require("./fallback-provider");
@@ -15,15 +15,3 @@ exports.JsonRpcProvider = json_rpc_provider_1.JsonRpcProvider;
 exports.JsonRpcSigner = json_rpc_provider_1.JsonRpcSigner;
 var web3_provider_1 = require("./web3-provider");
 exports.Web3Provider = web3_provider_1.Web3Provider;
-///////////////////////////////
-// Imported Abstracts
-var abstract_provider_1 = require("./abstract-provider");
-exports.AbstractProvider = abstract_provider_1.Provider;
-///////////////////////////////
-function getDefaultProvider(network) {
-    return new fallback_provider_1.FallbackProvider([
-        new infura_provider_1.InfuraProvider(network),
-        new etherscan_provider_1.EtherscanProvider(network),
-    ]);
-}
-exports.getDefaultProvider = getDefaultProvider;

providers/json-rpc-provider.d.ts

@@ -1,4 +1,4 @@
-import { Provider } from './provider';
+import { BaseProvider } from './base-provider';
 import { Signer } from '../wallet/abstract-signer';
 import { BigNumber } from '../utils/bignumber';
 import { Arrayish } from '../utils/bytes';
@@ -17,7 +17,7 @@ export declare class JsonRpcSigner extends Signer {
     signMessage(message: Arrayish | string): Promise<string>;
     unlock(password: string): Promise<boolean>;
 }
-export declare class JsonRpcProvider extends Provider {
+export declare class JsonRpcProvider extends BaseProvider {
     readonly connection: ConnectionInfo;
     private _pendingFilter;
     constructor(url?: ConnectionInfo | string, network?: Networkish);

providers/json-rpc-provider.js

@@ -18,7 +18,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // See: https://github.com/ethereum/wiki/wiki/JSON-RPC
-var provider_1 = require("./provider");
+var base_provider_1 = require("./base-provider");
 var abstract_signer_1 = require("../wallet/abstract-signer");
 var address_1 = require("../utils/address");
 var bytes_1 = require("../utils/bytes");
@@ -344,5 +344,5 @@ var JsonRpcProvider = /** @class */ (function (_super) {
         return result;
     };
     return JsonRpcProvider;
-}(provider_1.Provider));
+}(base_provider_1.BaseProvider));
 exports.JsonRpcProvider = JsonRpcProvider;

src.ts/_version.ts

@@ -1 +1 @@
-export const version = "4.0.0-beta.7";
+export const version = "4.0.0-beta.8";

types.d.ts

@@ -1,16 +1,17 @@
-export { ContractFunction, Event, EventFilter } from './contracts/contract';
-export { Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription } from './contracts/interface';
-export { Provider as AbstractProvider, Block, BlockTag, EventType, Filter, Log, Listener, TransactionReceipt, TransactionRequest, TransactionResponse, } from './providers/abstract-provider';
-export { AsyncSendable } from './providers/web3-provider';
-export { JsonRpcSigner } from './providers/json-rpc-provider';
-export { CoerceFunc, EventFragment, FunctionFragment, ParamType } from './utils/abi-coder';
-export { BigNumberish } from './utils/bignumber';
-export { Arrayish, Hexable, Signature } from './utils/bytes';
-export { SupportedAlgorithms } from './utils/hmac';
-export { Network, Networkish } from './utils/networks';
-export { Transaction, UnsignedTransaction } from './utils/transaction';
-export { UnicodeNormalizationForm } from './utils/utf8';
-export { ConnectionInfo, OnceBlockable, PollOptions } from './utils/web';
-export { Signer as AbstractSigner } from './wallet/abstract-signer';
-export { EncryptOptions, ProgressCallback } from './wallet/secret-storage';
-export { Wordlist } from './wordlists/wordlist';
+import { Provider } from './providers/abstract-provider';
+import { Signer } from './wallet/abstract-signer';
+import { ContractFunction, Event, EventFilter } from './contracts/contract';
+import { Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription } from './contracts/interface';
+import { Block, BlockTag, EventType, Filter, Log, Listener, TransactionReceipt, TransactionRequest, TransactionResponse } from './providers/abstract-provider';
+import { AsyncSendable } from './providers/web3-provider';
+import { CoerceFunc, EventFragment, FunctionFragment, ParamType } from './utils/abi-coder';
+import { BigNumberish } from './utils/bignumber';
+import { Arrayish, Hexable, Signature } from './utils/bytes';
+import { SupportedAlgorithms } from './utils/hmac';
+import { Network, Networkish } from './utils/networks';
+import { Transaction, UnsignedTransaction } from './utils/transaction';
+import { UnicodeNormalizationForm } from './utils/utf8';
+import { ConnectionInfo, OnceBlockable, PollOptions } from './utils/web';
+import { EncryptOptions, ProgressCallback } from './wallet/secret-storage';
+import { Wordlist } from './wordlists/wordlist';
+export { Provider, Signer, ContractFunction, EventFilter, Event, Indexed, DeployDescription, EventDescription, FunctionDescription, LogDescription, TransactionDescription, BlockTag, EventType, Filter, Listener, TransactionRequest, Block, Log, TransactionReceipt, TransactionResponse, AsyncSendable, CoerceFunc, EventFragment, FunctionFragment, ParamType, BigNumberish, Arrayish, Hexable, Signature, SupportedAlgorithms, Network, Networkish, UnsignedTransaction, Transaction, UnicodeNormalizationForm, ConnectionInfo, OnceBlockable, PollOptions, EncryptOptions, ProgressCallback, Wordlist };

types.js

@@ -1,12 +1,15 @@
 "use strict";
+///////////////////////////////
+// Imported Abstracts
 Object.defineProperty(exports, "__esModule", { value: true });
 var abstract_provider_1 = require("./providers/abstract-provider");
-exports.AbstractProvider = abstract_provider_1.Provider;
-var json_rpc_provider_1 = require("./providers/json-rpc-provider");
-exports.JsonRpcSigner = json_rpc_provider_1.JsonRpcSigner;
+exports.Provider = abstract_provider_1.Provider;
+var abstract_signer_1 = require("./wallet/abstract-signer");
+exports.Signer = abstract_signer_1.Signer;
+var hmac_1 = require("./utils/hmac");
+exports.SupportedAlgorithms = hmac_1.SupportedAlgorithms;
 var utf8_1 = require("./utils/utf8");
 exports.UnicodeNormalizationForm = utf8_1.UnicodeNormalizationForm;
-var abstract_signer_1 = require("./wallet/abstract-signer");
-exports.AbstractSigner = abstract_signer_1.Signer;
 var wordlist_1 = require("./wordlists/wordlist");
 exports.Wordlist = wordlist_1.Wordlist;
+///////////////////////////////

utils/bytes.d.ts

@@ -13,8 +13,6 @@ export interface Signature {
     recoveryParam?: number;
     v?: number;
 }
-export declare const AddressZero = "0x0000000000000000000000000000000000000000";
-export declare const HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
 export declare function isHexable(value: any): value is Hexable;
 export declare function isArrayish(value: any): value is Arrayish;
 export declare function arrayify(value: Arrayish | Hexable): Uint8Array;

utils/bytes.js

@@ -13,8 +13,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var errors = __importStar(require("./errors"));
 ///////////////////////////////
-exports.AddressZero = '0x0000000000000000000000000000000000000000';
-exports.HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
 function isHexable(value) {
     return !!(value.toHexString);
 }

utils/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const constants: {
+    AddressZero: string;
+    HashZero: string;
+    EtherSymbol: string;
+    NegativeOne: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+    Zero: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+    One: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+    Two: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+    WeiPerEther: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+    MaxUint256: import("../../../../../../../../Users/ricmoo/Development/ethers/ethers.ts/ethers.js/src.ts/utils/bignumber").BigNumber;
+};

utils/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bignumber_1 = require("./bignumber");
+var AddressZero = '0x0000000000000000000000000000000000000000';
+var HashZero = '0x0000000000000000000000000000000000000000000000000000000000000000';
+// NFKD (decomposed)
+//const EtherSymbol = '\uD835\uDF63';
+// NFKC (composed)
+var EtherSymbol = '\u039e';
+exports.constants = {
+    AddressZero: AddressZero,
+    HashZero: HashZero,
+    EtherSymbol: EtherSymbol,
+    NegativeOne: bignumber_1.ConstantNegativeOne,
+    Zero: bignumber_1.ConstantZero,
+    One: bignumber_1.ConstantOne,
+    Two: bignumber_1.ConstantTwo,
+    WeiPerEther: bignumber_1.ConstantWeiPerEther,
+    MaxUint256: bignumber_1.ConstantMaxUint256
+};

utils/index.d.ts

@@ -17,16 +17,4 @@ import { parse as parseTransaction, serialize as serializeTransaction } from './
 import { toUtf8Bytes, toUtf8String } from './utf8';
 import { formatEther, parseEther, formatUnits, parseUnits } from './units';
 import { fetchJson } from './web';
-import * as errors from './errors';
-declare const etherSymbol = "\u039E";
-declare const constants: {
-    AddressZero: string;
-    HashZero: string;
-    NegativeOne: BigNumber;
-    Zero: BigNumber;
-    One: BigNumber;
-    Two: BigNumber;
-    WeiPerEther: BigNumber;
-    MaxUint256: BigNumber;
-};
-export { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType, constants, RLP, fetchJson, getNetwork, defineReadOnly, defineFrozen, resolveProperties, shallowCopy, etherSymbol, arrayify, concat, padZeros, stripZeros, base64, BigNumber, bigNumberify, hexlify, hexStripZeros, hexZeroPad, hexDataLength, hexDataSlice, toUtf8Bytes, toUtf8String, hashMessage, namehash, id, getAddress, getIcapAddress, getContractAddress, formatEther, parseEther, formatUnits, parseUnits, keccak256, sha256, randomBytes, solidityPack, solidityKeccak256, soliditySha256, splitSignature, joinSignature, parseTransaction, serializeTransaction, getJsonWalletAddress, computePublicKey, verifyMessage, errors };
+export { AbiCoder, defaultAbiCoder, formatSignature, formatParamType, parseSignature, parseParamType, RLP, fetchJson, getNetwork, defineReadOnly, defineFrozen, resolveProperties, shallowCopy, arrayify, concat, padZeros, stripZeros, base64, BigNumber, bigNumberify, hexlify, hexStripZeros, hexZeroPad, hexDataLength, hexDataSlice, toUtf8Bytes, toUtf8String, hashMessage, namehash, id, getAddress, getIcapAddress, getContractAddress, formatEther, parseEther, formatUnits, parseUnits, keccak256, sha256, randomBytes, solidityPack, solidityKeccak256, soliditySha256, splitSignature, joinSignature, parseTransaction, serializeTransaction, getJsonWalletAddress, computePublicKey, verifyMessage };

utils/index.js

@@ -76,21 +76,3 @@ exports.formatUnits = units_1.formatUnits;
 exports.parseUnits = units_1.parseUnits;
 var web_1 = require("./web");
 exports.fetchJson = web_1.fetchJson;
-var errors = __importStar(require("./errors"));
-exports.errors = errors;
-// NFKD (decomposed)
-//const etherSymbol = '\uD835\uDF63';
-// NFKC (composed)
-var etherSymbol = '\u039e';
-exports.etherSymbol = etherSymbol;
-var constants = {
-    AddressZero: bytes_1.AddressZero,
-    HashZero: bytes_1.HashZero,
-    NegativeOne: bignumber_1.ConstantNegativeOne,
-    Zero: bignumber_1.ConstantZero,
-    One: bignumber_1.ConstantOne,
-    Two: bignumber_1.ConstantTwo,
-    WeiPerEther: bignumber_1.ConstantWeiPerEther,
-    MaxUint256: bignumber_1.ConstantMaxUint256
-};
-exports.constants = constants;

wallet/index.d.ts

@@ -1,5 +1,4 @@
 import { Wallet } from './wallet';
 import * as HDNode from './hdnode';
 import { SigningKey } from './signing-key';
-import { Signer as AbstractSigner } from './abstract-signer';
-export { AbstractSigner, HDNode, SigningKey, Wallet };
+export { HDNode, SigningKey, Wallet };

wallet/index.js

@@ -13,5 +13,3 @@ var HDNode = __importStar(require("./hdnode"));
 exports.HDNode = HDNode;
 var signing_key_1 = require("./signing-key");
 exports.SigningKey = signing_key_1.SigningKey;
-var abstract_signer_1 = require("./abstract-signer");
-exports.AbstractSigner = abstract_signer_1.Signer;