Added Ethereum testnets support and fixed bugs

Author: luyzdeleon

docs.wrm/api-keys.wrm

@@ -130,10 +130,11 @@ const provider = ethers.getDefaultProvider(network, {
     //   projectSecret: YOUR_INFURA_PROJECT_SECRET,
     // },
     alchemy: YOUR_ALCHEMY_API_KEY,
-    pocket: YOUR_POCKET_APPLICATION_KEY
+    pocket_gateway: YOUR_POCKET_APPLICATION_KEY
     // Or if using an application secret key:
-    // pocket: {
+    // pocket_gateway: {
     //   applicationId: ,
     //   applicationSecretKey:
+    //   endpointType: <loadbalancer || application>
     // }
 });

docs.wrm/api/providers/api-providers.wrm

@@ -100,19 +100,24 @@ you also need to specify the ``applicationID`` property.
 - ``applicationOrigin``: By specifying this property you are setting the `Origin` header in your request
 (remember that browsers will swap this header based on the actual origin of the website loaded).
 - ``applicationUserAgent``: By specifying this property you are setting the `User-Agent` header in your request.
+- ``endpointType``: By specifying this property you can select to connect via the Pocket Gateway Single Application endpoint or a Load Balancer Endpoint (defaults to Load Balancer)
 
 The //network// and //apiKey// are specified the same as [the constructor](PocketGatewayProvider).
 
 _note: Note: Default API keys
 In the event of the //apiKey// not being present in the constructor, a shared ApplicationID will be provided,
-which has the capacity of sending up to 1 million requests per day (41,750 per hour).
+which has the capacity of sending up to 10 million requests per day (417,500 per hour) for Ethereum Mainnet, 
+for Ropsten, Rinkeby and Görli there's a shared capacity of 1 million requests per day each (41,750 per hour).
 
 For production applications it is highly recommended to register your application on the
 [Pocket Gateway](link-pocket-gateway) for your own API key.
 
 _definition: **Supported Networks**
 
-- Homestead (Mainnet Full nodes (Archival Support coming soon))
+- Homestead (Mainnet Full nodes (non-Archival Nodes))
+- Ropsten (proof-of-work testnet)
+- Rinkeby (proof-of-authority testnet)
+- Görli (clique testnet)
 
 _code: Pocket Gateway Examples @lang<javascript>
 
@@ -122,6 +127,8 @@ const applicationId = "...";
 const applicationSecretKey = "...";
 const applicationOrigin = "...";
 const applicationUserAgent = "...";
+// Endpoint Type can be either application or loadbalancer
+const endpointType = "...";
 // </hide>
 
 // Connect to mainnet (homestead)
@@ -136,7 +143,8 @@ provider = new PocketGatewayProvider("homestead", {
     applicationId: applicationId,
     applicationSecretKey: applicationSecretKey,
     applicationOrigin: applicationOrigin,
-    applicationUserAgent: applicationUserAgent
+    applicationUserAgent: applicationUserAgent,
+    endpointType: endpointType
 });
 
 _subsection: InfuraProvider @<InfuraProvider> @INHERIT<[[UrlJsonRpcProvider]]> @src<providers:class.InfuraProvider>

package-lock.json

@@ -16833,6 +16833,12 @@ function ethDefaultProvider(network) {
             }
             catch (error) { }
         }
+        if (providers.PocketGatewayProvider) {
+            try {
+                providerList.push(new providers.PocketGatewayProvider(network, options.pocket_gateway));
+            }
+            catch (error) { }
+        }
         if (providers.CloudflareProvider) {
             try {
                 providerList.push(new providers.CloudflareProvider(network));
@@ -21428,62 +21434,6 @@ class NodesmithProvider extends UrlJsonRpcProvider {
 
 "use strict";
 const logger$D = new Logger(version$m);
-const defaultApplicationId = "5f7f8547b90218002e9ce9dd";
-class PocketProvider extends UrlJsonRpcProvider {
-    static getApiKey(apiKey) {
-        const apiKeyObj = {
-            applicationId: defaultApplicationId,
-            applicationSecretKey: null
-        };
-        if (apiKey == null) {
-            return apiKeyObj;
-        }
-        // Parse applicationId and applicationSecretKey
-        if (typeof (apiKey) === "string") {
-            apiKeyObj.applicationId = apiKey;
-        }
-        else if (apiKey.applicationSecretKey != null) {
-            logger$D.assertArgument((typeof (apiKey.applicationId) === "string"), "applicationSecretKey requires an applicationId", "applicationId", apiKey.applicationId);
-            logger$D.assertArgument((typeof (apiKey.applicationSecretKey) === "string"), "invalid applicationSecretKey", "applicationSecretKey", "[REDACTED]");
-            apiKeyObj.applicationId = apiKey.applicationId;
-            apiKeyObj.applicationSecretKey = apiKey.applicationSecretKey;
-        }
-        else if (apiKey.applicationId) {
-            apiKeyObj.applicationId = apiKey.applicationId;
-        }
-        return apiKeyObj;
-    }
-    static getUrl(network, apiKey) {
-        let host = null;
-        switch (network ? network.name : "unknown") {
-            case "homestead":
-                host = "eth-mainnet.gateway.pokt.network";
-                break;
-            default:
-                logger$D.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "network",
-                    value: network
-                });
-        }
-        const connection = {
-            url: (`https:/\/${host}/v1/${apiKey.applicationId}`),
-        };
-        // Initialize empty headers
-        connection.headers = {};
-        // Apply application secret key
-        if (apiKey.applicationSecretKey != null) {
-            connection.user = "";
-            connection.password = apiKey.applicationSecretKey;
-        }
-        return connection;
-    }
-    isCommunityResource() {
-        return (this.applicationId === defaultApplicationId);
-    }
-}
-
-"use strict";
-const logger$E = new Logger(version$m);
 let _nextId = 1;
 function buildWeb3LegacyFetcher(provider, sendFunc) {
     return function (method, params) {
@@ -21531,9 +21481,9 @@ function buildEip1193Fetcher(provider) {
 }
 class Web3Provider extends JsonRpcProvider {
     constructor(provider, network) {
-        logger$E.checkNew(new.target, Web3Provider);
+        logger$D.checkNew(new.target, Web3Provider);
         if (provider == null) {
-            logger$E.throwArgumentError("missing provider", "provider", provider);
+            logger$D.throwArgumentError("missing provider", "provider", provider);
         }
         let path = null;
         let jsonRpcFetchFunc = null;
@@ -21561,7 +21511,7 @@ class Web3Provider extends JsonRpcProvider {
                 jsonRpcFetchFunc = buildWeb3LegacyFetcher(provider, provider.send.bind(provider));
             }
             else {
-                logger$E.throwArgumentError("unsupported provider", "provider", provider);
+                logger$D.throwArgumentError("unsupported provider", "provider", provider);
             }
             if (!path) {
                 path = "unknown:";
@@ -21576,6 +21526,182 @@ class Web3Provider extends JsonRpcProvider {
     }
 }
 
+"use strict";
+const logger$E = new Logger(version$m);
+const defaultApplicationId = "defaultApp";
+const defaultLoadBalancer = "defaultLB";
+var EndpointType;
+(function (EndpointType) {
+    EndpointType["LoadBalancer"] = "LoadBalancer";
+    EndpointType["Application"] = "Application";
+})(EndpointType || (EndpointType = {}));
+class PocketGatewayProvider extends UrlJsonRpcProvider {
+    static getApiKey(apiKey) {
+        let apiKeyObj = PocketApiKeyObject.build(apiKey);
+        return apiKeyObj;
+    }
+    static getUrl(network, apiKey) {
+        let host = null;
+        switch (network ? network.name : "unknown") {
+            case "homestead":
+                host = "eth-mainnet.gateway.pokt.network";
+                break;
+            case "mainnet":
+                host = "eth-mainnet.gateway.pokt.network";
+                break;
+            case "ropsten":
+                host = "eth-ropsten.gateway.pokt.network";
+                break;
+            case "goerli":
+                host = "eth-ropsten.gateway.pokt.network";
+                break;
+            case "rinkeby":
+                host = "eth-rinkeby.gateway.pokt.network";
+                break;
+            default:
+                logger$E.throwError("unsupported network", Logger.errors.INVALID_ARGUMENT, {
+                    argument: "network",
+                    value: network
+                });
+        }
+        const connection = {
+            url: PocketApiKeyObject.getUrl(apiKey, host),
+        };
+        // Initialize empty headers
+        connection.headers = {};
+        // Apply application secret key
+        if (apiKey.applicationSecretKey != null) {
+            connection.user = "";
+            connection.password = apiKey.applicationSecretKey;
+        }
+        return connection;
+    }
+    isCommunityResource() {
+        if (typeof (this.apiKey) === "string") {
+            return (this.apiKey === defaultApplicationId || this.apiKey === defaultLoadBalancer);
+        }
+        else if (typeof (this.apiKey) === "object") {
+            return (this.apiKey.applicationId === defaultApplicationId || this.apiKey.applicationId === defaultLoadBalancer);
+        }
+        return true;
+    }
+}
+class PocketApiKeyObject {
+    constructor() {
+        this.applicationId = defaultLoadBalancer;
+        this.endpointType = EndpointType.LoadBalancer;
+        this.applicationSecretKey = null;
+        this.applicationOrigin = null;
+        this.applicationUserAgent = null;
+    }
+    static build(apiKey) {
+        if (apiKey == null)
+            return new PocketApiKeyObject();
+        var apiKeyObj = new PocketApiKeyObject();
+        // Parse Origin
+        if (typeof (apiKey.applicationOrigin) === "string") {
+            apiKeyObj.applicationOrigin = apiKey.applicationOrigin;
+        }
+        // Parse User Agent
+        if (typeof (apiKey.applicationUserAgent) === "string") {
+            apiKeyObj.applicationUserAgent = apiKey.applicationUserAgent;
+        }
+        if (typeof (apiKey.endpointType) === "string") {
+            switch (apiKey.endpointType.toLowerCase()) {
+                case "application":
+                    apiKeyObj.endpointType = EndpointType.Application;
+                    apiKeyObj.applicationId = defaultApplicationId;
+                    break;
+                default:
+                    apiKeyObj.endpointType = EndpointType.LoadBalancer;
+                    apiKeyObj.applicationId = defaultLoadBalancer;
+                    break;
+            }
+        }
+        switch (true) {
+            case typeof (apiKey) === "string":
+                apiKeyObj.applicationId = apiKey;
+                break;
+            case apiKey.applicationSecretKey != null:
+                logger$E.assertArgument((typeof (apiKey.applicationId) === "string"), "applicationSecretKey requires an applicationId", "applicationId", apiKey.applicationId);
+                logger$E.assertArgument((typeof (apiKey.applicationSecretKey) === "string"), "invalid applicationSecretKey", "applicationSecretKey", "[*********]");
+                apiKeyObj.applicationId = apiKey.applicationId;
+                apiKeyObj.applicationSecretKey = apiKey.applicationSecretKey;
+                break;
+            case apiKey !== null && typeof (apiKey.applicationId) === "string":
+                apiKeyObj.applicationId = apiKey.applicationId;
+                break;
+        }
+        return apiKeyObj;
+    }
+    static getDefaultAppForHost(host) {
+        let defaultAppId = null;
+        switch (host) {
+            case "eth-mainnet.gateway.pokt.network":
+                defaultAppId = "6004b7060aea5b606775f4d9";
+                break;
+            case "eth-ropsten.gateway.pokt.network":
+                defaultAppId = "6004b9aa0aea5b606775f4de";
+                break;
+            case "eth-goerli.gateway.pokt.network":
+                defaultAppId = "6004b9e30aea5b606775f4df";
+                break;
+            case "eth-rinkeby.gateway.pokt.network":
+                defaultAppId = "6004ba310aea5b606775f4e0";
+                break;
+            default:
+                logger$E.throwError("unsupported host for default app", Logger.errors.INVALID_ARGUMENT, {
+                    argument: "host",
+                    value: host
+                });
+        }
+        return defaultAppId;
+    }
+    static getDefaultLoadBalancerForHost(host) {
+        let defaultLbId = null;
+        switch (host) {
+            case "eth-mainnet.gateway.pokt.network":
+                defaultLbId = "6004bcd10040261633ade990";
+                break;
+            case "eth-ropsten.gateway.pokt.network":
+                defaultLbId = "6004bd4d0040261633ade991";
+                break;
+            case "eth-goerli.gateway.pokt.network":
+                defaultLbId = "6004bd860040261633ade992";
+                break;
+            case "eth-rinkeby.gateway.pokt.network":
+                defaultLbId = "6004bda20040261633ade994";
+                break;
+            default:
+                logger$E.throwError("unsupported host for default app", Logger.errors.INVALID_ARGUMENT, {
+                    argument: "host",
+                    value: host
+                });
+        }
+        return defaultLbId;
+    }
+    static getUrl(apiKey, host) {
+        var appId = null;
+        if (apiKey.applicationId === defaultLoadBalancer) {
+            appId = PocketApiKeyObject.getDefaultLoadBalancerForHost(host);
+        }
+        else {
+            appId = apiKey.applicationId;
+        }
+        var url = ("https:/" + "/" + host + "/v1/lb/" + appId);
+        if (typeof (apiKey.endpointType) === "string" && apiKey.endpointType.toLowerCase() === "application") {
+            if (appId === defaultApplicationId) {
+                appId = PocketApiKeyObject.getDefaultAppForHost(host);
+            }
+            else {
+                appId = apiKey.applicationId;
+            }
+            url = ("https:/" + "/" + host + "/v1/" + appId);
+        }
+        return url;
+    }
+}
+
 "use strict";
 const logger$F = new Logger(version$m);
 ////////////////////////
@@ -21615,8 +21741,8 @@ function getDefaultProvider(network, options) {
         InfuraProvider,
         JsonRpcProvider,
         NodesmithProvider,
-        PocketProvider,
         Web3Provider,
+        PocketGatewayProvider,
         IpcProvider,
     }, options);
 }
@@ -21636,10 +21762,10 @@ var index$3 = /*#__PURE__*/Object.freeze({
 	InfuraWebSocketProvider: InfuraWebSocketProvider,
 	JsonRpcProvider: JsonRpcProvider,
 	NodesmithProvider: NodesmithProvider,
-	PocketProvider: PocketProvider,
 	StaticJsonRpcProvider: StaticJsonRpcProvider,
 	Web3Provider: Web3Provider,
 	WebSocketProvider: WebSocketProvider,
+	PocketGatewayProvider: PocketGatewayProvider,
 	IpcProvider: IpcProvider,
 	JsonRpcSigner: JsonRpcSigner,
 	getDefaultProvider: getDefaultProvider,