Added default provider support for Ethereum classic (#351).

src.ts/ethers.ts

@@ -33,10 +33,9 @@ import { ContractFunction, ContractTransaction, Event, EventFilter } from './con
 // Helper Functions
 
 function getDefaultProvider(network?: utils.Network | string): providers.BaseProvider {
-    return new providers.FallbackProvider([
-        new providers.InfuraProvider(network),
-        new providers.EtherscanProvider(network),
-    ]);
+    let n = utils.getNetwork(network || 'homestead');
+    if (!n || !n._defaultProvider) { return null; }
+    return n._defaultProvider(providers);
 }
 
 

src.ts/providers/base-provider.ts

@@ -82,10 +82,14 @@ function arrayOf(check: CheckFunc): CheckFunc {
     });
 }
 
-function checkHash(hash: any): string {
-    if (typeof(hash) === 'string' && hexDataLength(hash) === 32) {
+function checkHash(hash: any, requirePrefix?: boolean): string {
+    if (typeof(hash) === 'string') {
+        // geth-etc does add a "0x" prefix on receipt.root
+        if (!requirePrefix && hash.substring(0, 2) !== '0x') { hash = '0x' + hash; }
+        if (hexDataLength(hash) === 32) {
            return hash.toLowerCase();
         }
+    }
     errors.throwError('invalid hash', errors.INVALID_ARGUMENT, { arg: 'hash', value: hash });
     return null;
 }
@@ -220,11 +224,15 @@ function checkTransactionResponse(transaction: any): TransactionResponse {
         }
     }
 
-
     let result = check(formatTransaction, transaction);
 
     let networkId = transaction.networkId;
 
+    // geth-etc returns chainId
+    if (transaction.chainId != null && networkId == null && result.v == null) {
+        networkId = transaction.chainId;
+    }
+
     if (isHexString(networkId)) {
         networkId = bigNumberify(networkId).toNumber();
     }
@@ -979,7 +987,7 @@ export class BaseProvider extends Provider {
     getTransaction(transactionHash: string): Promise<TransactionResponse> {
         return this.ready.then(() => {
             return resolveProperties({ transactionHash: transactionHash }).then(({ transactionHash }) => {
-                let params = { transactionHash: checkHash(transactionHash) };
+                let params = { transactionHash: checkHash(transactionHash, true) };
                 return poll(() => {
                     return this.perform('getTransaction', params).then((result) => {
                         if (result == null) {
@@ -1016,7 +1024,7 @@ export class BaseProvider extends Provider {
     getTransactionReceipt(transactionHash: string): Promise<TransactionReceipt> {
         return this.ready.then(() => {
             return resolveProperties({ transactionHash: transactionHash }).then(({ transactionHash }) => {
-                let params = { transactionHash: checkHash(transactionHash) };
+                let params = { transactionHash: checkHash(transactionHash, true) };
                 return poll(() => {
                     return this.perform('getTransactionReceipt', params).then((result) => {
                         if (result == null) {

src.ts/providers/fallback-provider.ts

@@ -32,7 +32,8 @@ function checkNetworks(networks: Array<Network>): boolean {
         // Matches!
         if (check.name === network.name &&
             check.chainId === network.chainId &&
-            check.ensAddress === network.ensAddress) { return; }
+            ((check.ensAddress === network.ensAddress) ||
+                (check.ensAddress == null && network.ensAddress == null))) { return; }
 
         errors.throwError(
             'provider mismatch',

src.ts/utils/networks.ts

@@ -7,33 +7,69 @@ export type Network = {
     name: string,
     chainId: number,
     ensAddress?: string,
+    _defaultProvider?: (providers: any) => any
 }
 
 export type Networkish = Network | string | number;
 
+function ethDefaultProvider(network: string): (providers: any) => any {
+    return function(providers: any): any {
+        let providerList: Array<any> = [];
+
+        if (providers.InfuraProvider) {
+            providerList.push(new providers.InfuraProvider(network));
+        }
+
+        if (providers.EtherscanProvider) {
+            providerList.push(new providers.EtherscanProvider(network));
+        }
+
+        if (providerList.length === 0) { return null; }
+
+        if (providers.FallbackProvider) {
+            return new providers.FallbackProvider(providerList);;
+        }
+
+        return providerList[0];
+    }
+}
+
+function etcDefaultProvider(url: string, network: string): (providers: any) => any {
+    return function(providers: any): any {
+        if (providers.JsonRpcProvider) {
+            return new providers.JsonRpcProvider(url, network);
+        }
+
+        return null;
+    }
+}
 
 const homestead: Network = {
     chainId: 1,
     ensAddress: "0x314159265dd8dbb310642f98f50c066173c1259b",
-    name: "homestead"
+    name: "homestead",
+    _defaultProvider: ethDefaultProvider('homestead')
 };
 
 const ropsten: Network = {
     chainId: 3,
     ensAddress: "0x112234455c3a32fd11230c42e7bccd4a84e02010",
-    name: "ropsten"
+    name: "ropsten",
+    _defaultProvider: ethDefaultProvider('ropsten')
 };
 
-const networks: { [name: string]: { chainId: number, ensAddress?: string } } = {
+const networks: { [name: string]: Network } = {
     unspecified: {
-        chainId: 0
+        chainId: 0,
+        name: 'unspecified'
     },
 
     homestead: homestead,
     mainnet: homestead,
 
     morden: {
-        chainId: 2
+        chainId: 2,
+        name: 'morden'
     },
 
     ropsten: ropsten,
@@ -41,19 +77,27 @@ const networks: { [name: string]: { chainId: number, ensAddress?: string } } = {
 
     rinkeby: {
         chainId: 4,
-        ensAddress: "0xe7410170f87102DF0055eB195163A03B7F2Bff4A"
+        ensAddress: "0xe7410170f87102DF0055eB195163A03B7F2Bff4A",
+        name: 'rinkeby',
+        _defaultProvider: ethDefaultProvider('rinkeby')
     },
 
     kovan: {
-        chainId: 42
+        chainId: 42,
+        name: 'kovan',
+        _defaultProvider: ethDefaultProvider('kovan')
     },
 
     classic: {
-        chainId: 61
+        chainId: 61,
+        name: 'classic',
+        _defaultProvider: etcDefaultProvider('https://web3.gastracker.io', 'classic')
     },
 
     classicTestnet: {
-        chainId: 62
+        chainId: 62,
+        name: 'classicTestnet',
+        _defaultProvider: etcDefaultProvider('https://web3.gastracker.io/morden', 'classicTestnet')
     }
 }
 
@@ -64,17 +108,18 @@ const networks: { [name: string]: { chainId: number, ensAddress?: string } } = {
  *  and verifies a network is a valid Network..
  */
 export function getNetwork(network: Networkish): Network {
-    // No network (null) or unspecified (chainId = 0)
-    if (!network) { return null; }
+    // No network (null)
+    if (network == null) { return null; }
 
     if (typeof(network) === 'number') {
-        for (var name in networks) {
+        for (let name in networks) {
             let n = networks[name];
             if (n.chainId === network) {
                 return {
-                    name: name,
+                    name: n.name,
                     chainId: n.chainId,
-                    ensAddress: n.ensAddress
+                    ensAddress: (n.ensAddress || null),
+                    _defaultProvider: (n._defaultProvider || null)
                 };
             }
         }
@@ -89,9 +134,10 @@ export function getNetwork(network: Networkish): Network {
         let n = networks[network];
         if (n == null) { return null; }
         return {
-            name: network,
+            name: n.name,
             chainId: n.chainId,
-            ensAddress: n.ensAddress
+            ensAddress: n.ensAddress,
+            _defaultProvider: (n._defaultProvider || null)
         };
     }
 
@@ -110,10 +156,11 @@ export function getNetwork(network: Networkish): Network {
         errors.throwError('network chainId mismatch', errors.INVALID_ARGUMENT, { arg: 'network', value: network });
     }
 
-    // Standard Network
+    // Standard Network (allow overriding the ENS address)
     return {
         name: network.name,
         chainId: n.chainId,
-        ensAddress: n.ensAddress
+        ensAddress: (network.ensAddress || n.ensAddress || null),
+        _defaultProvider: (network._defaultProvider || n._defaultProvider || null)
     };
 }