dracoder-web3-package 2.0.0 → 2.0.2

package/README.md

@@ -1,431 +1,131 @@
-# Rocketchain-package.
+# web3-integration-package
 
-## Summary
+## Resumen
 
-_Package used for web3 provider integration between client side and API._
+_Paquete utilizado para la integración del proveedor web3 entre el lado del cliente y la API._
 
-A repository to integrate required interaction between platform user (on client app) and blockchain actions signatures.
-Then the info generated and logs are sent to the related API endpoints.
+Este repositorio proporciona las herramientas necesarias para conectar a los usuarios con el ecosistema blockchain de manera fluida y segura. Facilita la integración de funcionalidades de firma de transacciones blockchain en aplicaciones cliente, permitiendo que la información y los registros generados se comuniquen eficientemente con los endpoints de la API necesarios.
 
-## Index
+## Índice
 
-* Installation
-* Specification
+- Instalación
+- Funciones
 
-## Installation
+## Instalación
 
-```
-npm install rocketchain-package
-```
-
-#### Dependencies used:
-
-Axios, web3
-
-## Specification
-
-### Function: setClientServerUrl
-
-Sets the client server url received. setClientServerUrl(param1)
-
-#### Parameters:
-
-param1: client server url address
-
-#### Example:
-
-```
-setClientServerUrl("http://localhost:5000")
-```
-
-#### Return:
-
-No return.
-
-### Function: metamaskConnect
-
-Checks if client app user is logged in with Metamask (to be able to receive transaction signature requests) and returns
-a promise with the user wallet address. If not, Metamask prompts asking to log in.
-
-#### Parameters:
-
-No parameters
-
-#### Example:
-
-```
-    const someFunctionThatNeedsTheUserWalletAddress = async() => {
-        const walletAddress = await metamaskConnect()
-        ...
-    }
-```
-
-#### Return:
-
-Returns a promise.
-
-Success:
-
-```
-console.log(walletAddress)
-0xECf8C3205B230a39a71354214561dAA83433Ae3B
-```
-
-Failure - string with error description if fails (depending on where the problem was)
-
-```
-console.log(connect)
-"There is no account to connect to"
-```
-
-```
-console.log(connect)
-"There was a problem connecting to your Metamask wallet. Do you have Metamask installed?"
-```
-
-### Function: clientTokenTransfer
-
-Transfer -that must be signed- of some amount of token from the user to another receiver
-
-clientTokenTransfer(param1, param2, param3)
-
-#### Parameters:
-
-* param1: address receiver of the tokens
-* param2: address of the token contract that will be transferred
-* param3: amount of token to be transferred
-
-#### Example:
-
-```
-tokenTransfer(0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170, 0xa6c99e129cecf74865f6ed847a62c63cd6e0c045, 17) 
-```
-
-#### Return:
+`npm install dracoder-web3-package`
 
-Returns a promise:
+# Funciones
 
-Success: transaction object from Blockchain
+# `isMetamaskInstalled`
 
-```
-{
-  "blockHash": "0x59ae5fc6af98787806d2733e97bc749e057ef0bf6d1c85d2f42f3eed92b9cba1",
-  "blockNumber": 9245548,
-  "contractAddress": null,
-  "cumulativeGasUsed": 8907523,
-  "effectiveGasPrice": "0x3b9aca0e",
-  "from": "0x212f260404a05e954bc9285bfae89d6b2bb45134",
-  "gasUsed": 34494,
-  "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000000000008000000000000010000008000000000000000000000000000000000040000000000000000000000000000000000000010000000000000000000000100000000004000000000004000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000",
-  "status": true,
-  "to": "0xa6c99e129cecf74865f6ed847a62c63cd6e0c045",
-  "transactionHash": "0xe8992e16afc720381390cb54f1bb3a6a0e3a30fc143797dced38417b2a02f99e",
-  "transactionIndex": 37,
-  "type": "0x2",
-  "events": {
-    "Transfer": {
-      "address": "0xa6C99E129cecF74865F6eD847a62c63cD6E0C045",
-      "blockHash": "0x59ae5fc6af98787806d2733e97bc749e057ef0bf6d1c85d2f42f3eed92b9cba1",
-      "blockNumber": 9245548,
-      "logIndex": 92,
-      "removed": false,
-      "transactionHash": "0xe8992e16afc720381390cb54f1bb3a6a0e3a30fc143797dced38417b2a02f99e",
-      "transactionIndex": 37,
-      "id": "log_696ad3a5",
-      "returnValues": {
-        "0": "0x212f260404A05E954BC9285BFAe89D6B2bB45134",
-        "1": "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-        "2": "17",
-        "from": "0x212f260404A05E954BC9285BFAe89D6B2bB45134",
-        "to": "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-        "value": "17"
-      },
-      "event": "Transfer",
-      "signature": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-      "raw": {
-        "data": "0x0000000000000000000000000000000000000000000000000000000000000011",
-        "topics": [
-          "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-          "0x000000000000000000000000212f260404a05e954bc9285bfae89d6b2bb45134",
-          "0x000000000000000000000000e4513a7bcd98de50fe7984c82daf5611beba7170"
-        ]
-      }
-    }
-  }
-}
-```
-
-Error: The log depends on where the error was produced
-
-### Function: tokenCreate
-
-Creates a token using given token parameters and the user wallet address to relate the request
-
-tokenCreate(param1, param2, param3, param4, param5)
+Verifica si Metamask está instalado en el navegador del usuario.
 
-#### Parameters:
+### Uso
 
-* param1: Name given to the token by the user
-* param2: total amount of tokens that will be created
-* param3: Symbol of the token given by the user
-* param4: Decimals of the token
-* param5: wallet address of the user that requested the token creation
-
-#### Example:
-
-```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async () => {
-        const createdToken = await RocketchainPackage.tokenCreate(
-             "Token Doc",
-             "44",
-             "TkD",
-             "0",
-             "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-        );
-    }
+```javascript
+const { isMetamaskInstalled } = require("dracoder-web3-package");
+console.log(isMetamaskInstalled());
 ```
 
-#### Return:
+### Retorno
 
-Returns a promise.
-
-Database object with all the creation Blockchain data related
-
-```
-console.log(createdToken);
-{
-  "data": {
-    "is_transferred": false,
-    "_id": "613628fcf7a6782270588ee1",
-    "token_address": "0x85398185A1CBE64D7f8Bf4aD668AB7352A93F589",
-    "wallet_address": "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-    "amount": "44",
-    "log_id": "613628fcf7a6782270588edf",
-    "created_at": "2021-09-06T12:42:55.000Z",
-    "__v": 0
-  },
-  "status": 200,
-  "statusText": "OK",
-  "headers": {
-    "cache-control": "no-cache, private",
-    "content-length": "278",
-    "content-type": "text/html; charset=UTF-8"
-  },
-  "config": {
-    "url": "http://rocketchain-server.test/api/token_creation_response",
-    "method": "post",
-    "data": "{\"nameOfToken\":\"Token Doc\",\"numberOfToken\":\"44\",\"symbolOfToken\":\"TkD\",\"numberOfDecimals\":\"0\",\"userWalletAddress\":\"0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170\"}",
-    "headers": {
-      "Accept": "application/json, text/plain, */*",
-      "Content-Type": "application/json"
-    },
-    "transformRequest": [
-      null
-    ],
-    "transformResponse": [
-      null
-    ],
-    "timeout": 0,
-    "xsrfCookieName": "XSRF-TOKEN",
-    "xsrfHeaderName": "X-XSRF-TOKEN",
-    "maxContentLength": -1,
-    "maxBodyLength": -1,
-    "transitional": {
-      "silentJSONParsing": true,
-      "forcedJSONParsing": true,
-      "clarifyTimeoutError": false
-    }
-  },
-  "request": {}
-}
-```
-
-### Function: tokenTransferWithTokenAddressOnly
-
-Transfer linked with the token creation (as a second step) process
-
-tokenTransferWithTokenAddressOnly(param1)
-
-#### Parameters:
-
-param1: token smart contract address.
-
-(Retrieved from tokenCreate method response => data.token_address)
-
-#### Example:
-
-```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async data => {
-        const tokenTransferred = await RocketchainPackage.tokenTransferWithTokenAddressOnly("0x85398185A1CBE64D7f8Bf4aD668AB7352A93F589");
-    };
-```
+- `{ "ok": true, "message": "Metamask is installed" }` si Metamask está instalado.
+- `{ "ok": false, "message": "You don't have Metamask installed." }` si Metamask no está instalado.
 
-#### Return:
+# `getMetamaskAccount`
 
-Returns a promise.
+Obtiene la cuenta de Metamask conectada actualmente.
 
-Database object with all the Blockchain transfer data related
+### Uso
 
+```javascript
+const { getMetamaskAccount } = require("dracoder-web3-package");
+getMetamaskAccount().then(console.log).catch(console.error);
 ```
-console.log(tokenTransferred);
-{
-	"blockHash": "0xd5da8d878e62ec7868e80d0df0676fe9f52a21af4a1277c40ab2cb1b7d092b95",
-	"blockNumber": 9245705,
-	"contractAddress": null,
-	"cumulativeGasUsed": 3396087,
-	"effectiveGasPrice": "0x3b9aca0d",
-	"from": "0x212f260404a05e954bc9285bfae89d6b2bb45134",
-	"gasUsed": 46794,
-	"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008000000000000010004008000000000000000000000000000000000040000000000000000000000000000000000000010000000000000000000000100000000004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000002000000000000000000000000000000000000010000002000000000000000000000000000000000000000000000000000000000000000000000000000",
-	"status": true,
-	"to": "0x85398185a1cbe64d7f8bf4ad668ab7352a93f589",
-	"transactionHash": "0x6cea70d5436e706a659ff339fc7b012576eafc6b28bcf9c93355fd19ad2a800b",
-	"transactionIndex": 24,
-	"type": "0x0",
-	"events": {
-		"Transfer": {
-			"address": "0x85398185A1CBE64D7f8Bf4aD668AB7352A93F589",
-			"blockHash": "0xd5da8d878e62ec7868e80d0df0676fe9f52a21af4a1277c40ab2cb1b7d092b95",
-			"blockNumber": 9245705,
-			"logIndex": 30,
-			"removed": false,
-			"transactionHash": "0x6cea70d5436e706a659ff339fc7b012576eafc6b28bcf9c93355fd19ad2a800b",
-			"transactionIndex": 24,
-			"id": "log_0dd77e89",
-			"returnValues": {
-				"0": "0x212f260404A05E954BC9285BFAe89D6B2bB45134",
-				"1": "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-				"2": "44",
-				"from": "0x212f260404A05E954BC9285BFAe89D6B2bB45134",
-				"to": "0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170",
-				"value": "44"
-			},
-			"event": "Transfer",
-			"signature": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-			"raw": {
-				"data": "0x000000000000000000000000000000000000000000000000000000000000002c",
-				"topics": [
-					"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
-					"0x000000000000000000000000212f260404a05e954bc9285bfae89d6b2bb45134",
-					"0x000000000000000000000000e4513a7bcd98de50fe7984c82daf5611beba7170"
-				]
-			}
-		}
-	}
-}
-```
-
-### Function: getTokenOwnersBalance
-
-Retrieves all the accounts that have owned (0 balance now) or currently own (positive balance) the token specified by
-the token contract address.
 
-getTokenOwnersBalance(param1)
+### Retorno
 
-#### Parameters:
+- `{ "ok": true, "message": "Connected successfully.", "account": "0x..." }` si se obtiene la cuenta con éxito.
+- `{ "ok": false, "message": "Error message }` en caso de error.
 
-param1: smart contract token address.
+# `clientTokenTransfer`
 
-#### Example:
-
-```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async () => {
-        const ownersArray = await RocketchainPackage.getTokenOwnersBalance(0xa6c99e129cecf74865f6ed847a62c63cd6e0c045);                
-    };
-```
+Realiza una transferencia de tokens desde la cuenta conectada a una dirección específica.
 
-#### Return:
+### Parametros
 
-Returns a promise.
+- `walletAddressToTransferTo` : Dirección de la billetera receptora.
+- `tokenAddress` : Dirección del contrato del token.
+- `amount` : Cantidad de tokens a transferir.
 
-Array of objects. Each object represents a pair of owner-balance values.
+### Uso
 
+```javascript
+const { clientTokenTransfer } = require("dracoder-web3-package");
+clientTokenTransfer(walletAddressToTransferTo, tokenAddress, amount)
+  .then(console.log)
+  .catch(console.error);
 ```
-console.log(ownersArray);
-[{"owner":"0xe4513a7BCd98dE50Fe7984C82dAf5611beBa7170","balance":"41"},{"owner":"0x212f260404A05E954BC9285BFAe89D6B2bB45134","balance":"5959"}]
-```
-
-### Function: isMetamaskInstalled
-
-Checks if Metamask is installed in order to proceed with the rest of functionalities
 
-isMetamaskInstalled()
+### Retorno
 
-#### Parameters:
+- `{ "ok": true, "message": "Transfer successful", "transactionHash": "0x..." }` si la transferencia es exitosa.
+- `{ "ok": false, "message": "Transfer failed", "error": error }` si falla la transferencia.
 
-No parameters required.
+# `sendTokenToWallet`
 
-#### Example:
+Intenta añadir un token a Metamask.
 
-```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async () => {
-        const checkMetamask = await RocketchainPackage.isMetamaskInstalled();                
-    };
-```
+### Parametros
 
-#### Return:
+- `tokenAddress` : Dirección del contrato del token.
 
-Returns a response depending on Metamask is/is not installed.
+### Uso
 
-```
-{ ok: false, message: "You don't have Metamask installed." }
+```javascript
+const { sendTokenToWallet } = require("dracoder-web3-package");
+sendTokenToWallet(tokenAddress).then(console.log).catch(console.error);
 ```
 
-### Function: checkWalletFormat
+### Retorno
 
-Checks if the wallet provided has the proper structure and format.
+- `{ true }` si el token se añadió correctamente.
+- `{ [Objeto] de error }` si falla la operación.
 
-checkWalletFormat(param1)
+# `checkWalletFormat`
 
-#### Parameters:
+Verifica si una dirección de billetera tiene el formato correcto.
 
-param1: wallet address.
+### Parametros
 
-#### Example:
+- `account` : Dirección de la billetera a verificar.
 
-```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async () => {
-        const formatVerification = await RocketchainPackage.checkWalletFormat(0xLZf8C3205B230a39a71354214561dAA83433Ae4K);                
-    };
-```
-
-#### Return
+### Uso
 
-Returns a response depending on whether the data provided has the right format or not.
-
-```
-{ ok: true, message: "Proper address format" }
+```javascript
+const { checkWalletFormat } = require("dracoder-web3-package");
+console.log(checkWalletFormat(account));
 ```
 
-### Function: selectOrAddPolygonMainNetwork
-
-Selects or adds the Polygon Matic Mainnet to the Metamask wallet.
+### Retorno
 
-selectOrAddPolygonMainNetwork()
+- `{ "ok": true, "message": "Proper address format" }` si el formato es correcto.
+- `{ "ok": false, "message": "Wrong address format" }` si el formato es incorrecto.
 
-### Parameters:
+# `selectOrAddPolygonMainNetwork`
 
-No parameters required.
+Selecciona o añade la red principal de Polygon en Metamask.
 
-### Example:
+### Uso
 
+```javascript
+const { selectOrAddPolygonMainNetwork } = require("dracoder-web3-package");
+selectOrAddPolygonMainNetwork().then(console.log).catch(console.error);
 ```
-const RocketchainPackage = require('rocketchain-package');
-const someFunction = async () => {
-        const selectOrAddPolygonMainNetwork = await RocketchainPackage.selectOrAddPolygonMainNetwork();                
-    };
-```
-
-### Return 
-
-Returns a response depending on whether the Polygon main network was previously added or needs to be added. 
 
-```
-{ ok: true, message: "Matic Mainnet added successfully", response: ... }
-```
+### Retorno
 
+- `{ "ok": true, "message": "Already on polygon main network" }` si ya está en la red principal de Polygon.
+- `{ "ok": true, "message": "Matic MainNet added successfully", "response": response }` si se añade la red de Polygon con éxito.
+- `{ "ok": false, "message": "Matic MainNet cannot be added", "response": error }` si no se puede añadir la red.

package/index.js

@@ -1,29 +1,29 @@
 "use strict";
 
-const {Web3} = require("web3");
-const {abiToken} = require("./helpers/factory_data");
+const { Web3 } = require("web3");
+const { abiToken } = require("./helpers/factory_data");
 
 const METAMASK_NOT_INSTALLED_MESSAGE = {
   ok: false,
   message: "You don't have Metamask installed.",
-}
+};
 
-const Metamask = window.ethereum
+const Metamask = window.ethereum;
 
 const checkIfMetamaskIsAvailable = () => {
-  return typeof Metamask !== "undefined"
-}
+  return typeof Metamask !== "undefined";
+};
 
 const getMetamaskAccount = async () => {
-  const [account] = await Metamask
-    .request({method: "eth_requestAccounts"})
-    .catch(async (error) => {
-      throw {
-        ok: false,
-        message: "Something went wrong connecting to Metamask.",
-        metamaskMessage: error,
-      };
-    });
+  const [account] = await Metamask.request({
+    method: "eth_requestAccounts",
+  }).catch(async (error) => {
+    throw {
+      ok: false,
+      message: "Something went wrong connecting to Metamask.",
+      metamaskMessage: error?.message,
+    };
+  });
   if (!account) {
     throw {
       ok: false,
@@ -38,16 +38,18 @@ const getMetamaskAccount = async () => {
 };
 
 const clientTokenTransfer = async ({
-                                     walletAddressToTransferTo,
-                                     tokenAddress,
-                                     amount,
-                                   }) => {
+  walletAddressToTransferTo,
+  tokenAddress,
+  amount,
+}) => {
   if (!checkIfMetamaskIsAvailable()) {
-    return METAMASK_NOT_INSTALLED_MESSAGE
+    return METAMASK_NOT_INSTALLED_MESSAGE;
   }
+
   const response = await getMetamaskAccount().catch((error) => {
     throw error;
   });
+
   const account = response.account;
   let web3;
 
@@ -60,12 +62,15 @@ const clientTokenTransfer = async ({
   if (!web3.utils.isAddress(account)) {
     throw new Error("Not valid account");
   }
+
   if (!web3.utils.isAddress(tokenAddress)) {
     throw new Error("Is not a Token Address");
   }
+
   if (!web3.utils.isAddress(walletAddressToTransferTo)) {
     throw new Error("Is not a Wallet Address to transfer to");
   }
+
   if (amount <= 0) {
     throw new Error("Amount must be greater than 0.");
   }
@@ -98,30 +103,27 @@ const clientTokenTransfer = async ({
   }
 };
 
-const sendTokenToWallet = async ({tokenAddress}) => {
-  if (!checkIfMetamaskIsAvailable()) {
-    return METAMASK_NOT_INSTALLED_MESSAGE
+const sendTokenToWallet = async ({ tokenAddress }) => {
+  // Cambiar a red Polygon
+  const polygonResponse = await selectOrAddPolygonMainNetwork();
+  if (!polygonResponse.ok) {
+    throw polygonResponse;
   }
 
-  await getMetamaskAccount().catch((error) => {
-    throw error;
-  });
-
   let web3 = new Web3(Metamask);
   let tokenAdded = false;
 
-  const MyTokenContractInstance = new web3.eth.Contract(
-    abiToken,
-    tokenAddress
-  );
+  const MyTokenContractInstance = new web3.eth.Contract(abiToken, tokenAddress);
 
   try {
     const symbol = await MyTokenContractInstance.methods.symbol().call();
-    const decimals = web3.utils.toNumber(await MyTokenContractInstance.methods.decimals().call())
+    const decimals = web3.utils.toNumber(
+      await MyTokenContractInstance.methods.decimals().call()
+    );
     const response = await Metamask.request({
-      method: 'wallet_watchAsset',
+      method: "wallet_watchAsset",
       params: {
-        type: 'ERC20',
+        type: "ERC20",
         options: {
           address: tokenAddress,
           symbol: symbol,
@@ -131,27 +133,25 @@ const sendTokenToWallet = async ({tokenAddress}) => {
     });
     tokenAdded = !!response;
   } catch (error) {
-    return error
+    return error;
   }
   return tokenAdded;
-
 };
 
 const isMetamaskInstalled = () => {
   if (!checkIfMetamaskIsAvailable()) {
-    return METAMASK_NOT_INSTALLED_MESSAGE
+    return METAMASK_NOT_INSTALLED_MESSAGE;
   }
   return {
     ok: true,
     message: "Metamask is installed",
   };
-
 };
 
 const checkWalletFormat = (account) => {
   let web3;
   if (!checkIfMetamaskIsAvailable()) {
-    return METAMASK_NOT_INSTALLED_MESSAGE
+    return METAMASK_NOT_INSTALLED_MESSAGE;
   }
   try {
     web3 = new Web3(Metamask);
@@ -178,55 +178,58 @@ const checkWalletFormat = (account) => {
 
 const selectOrAddPolygonMainNetwork = async () => {
   if (!checkIfMetamaskIsAvailable()) {
-    return METAMASK_NOT_INSTALLED_MESSAGE
+    return METAMASK_NOT_INSTALLED_MESSAGE;
   }
   await getMetamaskAccount().catch((error) => {
     throw error;
   });
   try {
+    // Primero intentar cambiar a la red de Polygon si ya existe
     await Metamask.request({
       method: "wallet_switchEthereumChain",
-      params: [{chainId: "0x89"}],
+      params: [{ chainId: "0x89" }], // ChainId de Polygon Mainnet en hexadecimal
     });
     return {
       ok: true,
       message: "Already on polygon main network",
     };
   } catch (switchError) {
+    // Si el error es 4902, significa que la red no está añadida
     if (switchError.code === 4902) {
-      const params = [
-        {
-          chainId: "0x89",
-          chainName: "Matic MainNet",
-          nativeCurrency: {
-            name: "MATIC",
-            symbol: "MATIC",
-            decimals: 18,
-          },
-          rpcUrls: [
-            "https://polygon-rpc.com/",
-            "https://rpc-mainnet.maticvigil.com/",
-          ],
-          blockExplorerUrls: ["https://polygonscan.com/"],
-        },
-      ];
       try {
         const response = await Metamask.request({
           method: "wallet_addEthereumChain",
-          params: params,
+          params: [
+            {
+              chainId: "0x89",
+              chainName: "Polygon",
+              nativeCurrency: {
+                name: "POL",
+                symbol: "POL",
+                decimals: 18,
+              },
+              rpcUrls: ["https://polygon.llamarpc.com"],
+              blockExplorerUrls: ["https://polygonscan.com/"],
+              iconUrls: [
+                "https://polygonscan.com/assets/poly/images/svg/logos/chain-light.svg",
+              ],
+            },
+          ],
         });
         return {
           ok: true,
-          message: "Matic MainNet added successfully",
+          message: "Polygon MainNet added successfully",
           response: response,
         };
       } catch (error) {
         return {
           ok: false,
-          message: "Matic MainNet can not be added",
-          response: error,
+          message: error.message,
+          code: error.code,
         };
       }
+    } else {
+      throw switchError;
     }
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dracoder-web3-package",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Dracoder package used for web3 provider integration.",
   "main": "index.js",
   "keywords": [